Release secrets-mcp 0.3.0: folder/type schema and MCP folder disambiguation

- Rename namespace/kind to folder/type on entries, audit_log, and history tables;
  add notes. Unique key is (user_id, folder, name).
- Service layer and MCP tools support name-first lookup with optional folder when
  multiple entries share the same name.
- secrets_delete dry_run uses the same disambiguation as real deletes.
- Add scripts/migrate-v0.3.0.sql for manual DB migration. Refresh README and
  AGENTS.md.

Made-with: Cursor

crates/secrets-core/src/service/search.rs

@@ -9,8 +9,8 @@ use crate::models::{Entry, SecretField};
 pub const FETCH_ALL_LIMIT: u32 = 100_000;
 
 pub struct SearchParams<'a> {
-    pub namespace: Option<&'a str>,
-    pub kind: Option<&'a str>,
+    pub folder: Option<&'a str>,
+    pub entry_type: Option<&'a str>,
     pub name: Option<&'a str>,
     pub tags: &'a [String],
     pub query: Option<&'a str>,
@@ -44,16 +44,16 @@ pub async fn run(pool: &PgPool, params: SearchParams<'_>) -> Result<SearchResult
 /// Fetch entries matching the given filters — returns all matching entries up to FETCH_ALL_LIMIT.
 pub async fn fetch_entries(
     pool: &PgPool,
-    namespace: Option<&str>,
-    kind: Option<&str>,
+    folder: Option<&str>,
+    entry_type: Option<&str>,
     name: Option<&str>,
     tags: &[String],
     query: Option<&str>,
     user_id: Option<Uuid>,
 ) -> Result<Vec<Entry>> {
     let params = SearchParams {
-        namespace,
-        kind,
+        folder,
+        entry_type,
         name,
         tags,
         query,
@@ -77,12 +77,12 @@ async fn fetch_entries_paged(pool: &PgPool, a: &SearchParams<'_>) -> Result<Vec<
         conditions.push("user_id IS NULL".to_string());
     }
 
-    if a.namespace.is_some() {
-        conditions.push(format!("namespace = ${}", idx));
+    if a.folder.is_some() {
+        conditions.push(format!("folder = ${}", idx));
         idx += 1;
     }
-    if a.kind.is_some() {
-        conditions.push(format!("kind = ${}", idx));
+    if a.entry_type.is_some() {
+        conditions.push(format!("type = ${}", idx));
         idx += 1;
     }
     if a.name.is_some() {
@@ -106,8 +106,9 @@ async fn fetch_entries_paged(pool: &PgPool, a: &SearchParams<'_>) -> Result<Vec<
     }
     if a.query.is_some() {
         conditions.push(format!(
-            "(name ILIKE ${i} ESCAPE '\\' OR namespace ILIKE ${i} ESCAPE '\\' \
-             OR kind ILIKE ${i} ESCAPE '\\' OR metadata::text ILIKE ${i} ESCAPE '\\' \
+            "(name ILIKE ${i} ESCAPE '\\' OR folder ILIKE ${i} ESCAPE '\\' \
+             OR type ILIKE ${i} ESCAPE '\\' OR notes ILIKE ${i} ESCAPE '\\' \
+             OR metadata::text ILIKE ${i} ESCAPE '\\' \
              OR EXISTS (SELECT 1 FROM unnest(tags) t WHERE t ILIKE ${i} ESCAPE '\\'))",
             i = idx
         ));
@@ -131,8 +132,8 @@ async fn fetch_entries_paged(pool: &PgPool, a: &SearchParams<'_>) -> Result<Vec<
     };
 
     let sql = format!(
-        "SELECT id, user_id, \
-         namespace, kind, name, tags, metadata, version, created_at, updated_at \
+        "SELECT id, user_id, folder, type, name, notes, tags, metadata, version, \
+         created_at, updated_at \
          FROM entries {where_clause} ORDER BY {order} LIMIT ${limit_idx} OFFSET ${offset_idx}"
     );
 
@@ -141,10 +142,10 @@ async fn fetch_entries_paged(pool: &PgPool, a: &SearchParams<'_>) -> Result<Vec<
     if let Some(uid) = a.user_id {
         q = q.bind(uid);
     }
-    if let Some(v) = a.namespace {
+    if let Some(v) = a.folder {
         q = q.bind(v);
     }
-    if let Some(v) = a.kind {
+    if let Some(v) = a.entry_type {
         q = q.bind(v);
     }
     if let Some(v) = a.name {
@@ -207,15 +208,51 @@ pub async fn fetch_secrets_for_entries(
     Ok(map)
 }
 
-// ── Internal raw row (because user_id is nullable in DB) ─────────────────────
+/// Resolve exactly one entry by name, with optional folder for disambiguation.
+///
+/// - If `folder` is provided: exact `(folder, name)` match.
+/// - If `folder` is None and exactly one entry matches: returns it.
+/// - If `folder` is None and multiple entries match: returns an error listing
+///   the folders and asking the caller to specify one.
+pub async fn resolve_entry(
+    pool: &PgPool,
+    name: &str,
+    folder: Option<&str>,
+    user_id: Option<Uuid>,
+) -> Result<crate::models::Entry> {
+    let entries = fetch_entries(pool, folder, None, Some(name), &[], None, user_id).await?;
+    match entries.len() {
+        0 => {
+            if let Some(f) = folder {
+                anyhow::bail!("Not found: '{}' in folder '{}'", name, f)
+            } else {
+                anyhow::bail!("Not found: '{}'", name)
+            }
+        }
+        1 => Ok(entries.into_iter().next().unwrap()),
+        _ => {
+            let folders: Vec<&str> = entries.iter().map(|e| e.folder.as_str()).collect();
+            anyhow::bail!(
+                "Ambiguous: {} entries named '{}' found in folders: [{}]. \
+                 Specify 'folder' to disambiguate.",
+                entries.len(),
+                name,
+                folders.join(", ")
+            )
+        }
+    }
+}
 
+// ── Internal raw row (because user_id is nullable in DB) ─────────────────────
 #[derive(sqlx::FromRow)]
 struct EntryRaw {
     id: Uuid,
     user_id: Option<Uuid>,
-    namespace: String,
-    kind: String,
+    folder: String,
+    #[sqlx(rename = "type")]
+    entry_type: String,
     name: String,
+    notes: String,
     tags: Vec<String>,
     metadata: Value,
     version: i64,
@@ -228,9 +265,10 @@ impl From<EntryRaw> for Entry {
         Entry {
             id: r.id,
             user_id: r.user_id,
-            namespace: r.namespace,
-            kind: r.kind,
+            folder: r.folder,
+            entry_type: r.entry_type,
             name: r.name,
+            notes: r.notes,
             tags: r.tags,
             metadata: r.metadata,
             version: r.version,