granite-mem 0.1.1 → 0.1.3

package/dist/index.js

@@ -4,8 +4,8 @@
 import { Command } from "commander";
 
 // src/commands/init.ts
-import fs2 from "fs";
-import path2 from "path";
+import fs3 from "fs";
+import path3 from "path";
 
 // src/core/config.ts
 import fs from "fs";
@@ -47,7 +47,12 @@ var DEFAULT_CONFIG = {
       template: "## Role\n\n## Context\n\nHow I know them, what we work on.\n\n## Contact\n\n## Notes\n\n- \n\n## Links\n\n",
       line_limit: 150,
       warn_only: true,
-      instructions: "Fill in their role and context. Add timestamped notes as you interact (meetings, emails, calls). Link to projects, companies, or topics they relate to."
+      instructions: "Fill in their role and context. Add timestamped notes as you interact (meetings, emails, calls). Link to projects, companies, or topics they relate to.",
+      fields: {
+        role: { type: "text", description: "Job title or role" },
+        org: { type: "text", description: "Organization or company" },
+        contact: { type: "text", description: "Email, Slack, phone" }
+      }
     },
     meeting: {
       folder: "notes/meetings",
@@ -55,7 +60,12 @@ var DEFAULT_CONFIG = {
       template: "## Attendees\n\n- \n\n## Agenda\n\n- \n\n## Notes\n\n\n\n## Decisions\n\n- \n\n## Actions\n\n- [ ] \n",
       line_limit: 300,
       warn_only: true,
-      instructions: "List attendees as [[person]] links. Capture decisions and action items clearly. Link to relevant projects or topics."
+      instructions: "List attendees as [[person]] links. Capture decisions and action items clearly. Link to relevant projects or topics.",
+      fields: {
+        attendees: { type: "list", of: "wikilink", description: "People present" },
+        date: { type: "date", description: "Meeting date" },
+        project: { type: "wikilink", description: "Related project" }
+      }
     },
     project: {
       folder: "notes/projects",
@@ -63,7 +73,11 @@ var DEFAULT_CONFIG = {
       template: "## Goal\n\n## Status\n\n## People\n\n- \n\n## Key Decisions\n\n- \n\n## Links\n\n",
       line_limit: 300,
       warn_only: true,
-      instructions: "Define the goal clearly. Keep status updated. Link to people involved, meeting notes, and related permanent notes."
+      instructions: "Define the goal clearly. Keep status updated. Link to people involved, meeting notes, and related permanent notes.",
+      fields: {
+        people: { type: "list", of: "wikilink", description: "Team members involved" },
+        project_status: { type: "enum", options: ["planning", "active", "paused", "completed"], default: "active", description: "Project lifecycle" }
+      }
     },
     decision: {
       folder: "notes/decisions",
@@ -71,7 +85,12 @@ var DEFAULT_CONFIG = {
       template: "## Context\n\nWhat prompted this decision.\n\n## Options Considered\n\n1. \n2. \n\n## Decision\n\n\n\n## Rationale\n\n## Status\n\nActive\n",
       line_limit: 200,
       warn_only: false,
-      instructions: "Document the context, what options were considered, what was decided, and why. This is a permanent record \u2014 future-you will thank you. Link to the project or topic."
+      instructions: "Document the context, what options were considered, what was decided, and why. This is a permanent record \u2014 future-you will thank you. Link to the project or topic.",
+      fields: {
+        context_for: { type: "wikilink", description: "Project or area this decision belongs to" },
+        decision_status: { type: "enum", options: ["active", "superseded", "revisit"], default: "active", description: "Decision lifecycle" },
+        superseded_by: { type: "wikilink", description: "Replacement decision if superseded" }
+      }
     }
   },
   defaults: {
@@ -97,55 +116,75 @@ function loadConfig(vaultRoot) {
   return parsed;
 }
 
+// src/core/vault.ts
+import fs2 from "fs";
+import os from "os";
+import path2 from "path";
+var DEFAULT_VAULT_DIRNAME = ".granite";
+function hasVaultConfig(dir) {
+  return fs2.existsSync(path2.join(dir, CONFIG_FILENAME));
+}
+function getDefaultVaultRoot(homeDir = os.homedir()) {
+  return path2.resolve(homeDir, DEFAULT_VAULT_DIRNAME);
+}
+function findVaultRoot(from) {
+  let dir = from ? path2.resolve(from) : process.cwd();
+  while (true) {
+    if (hasVaultConfig(dir)) {
+      return dir;
+    }
+    const parent = path2.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  const defaultVaultRoot = getDefaultVaultRoot();
+  return hasVaultConfig(defaultVaultRoot) ? defaultVaultRoot : null;
+}
+function requireVaultRoot(from) {
+  const root = findVaultRoot(from);
+  if (!root) {
+    throw new Error(`No Granite vault found. Run "mem init" to create ${getDefaultVaultRoot()}.`);
+  }
+  return root;
+}
+function getIndexDbPath(vaultRoot) {
+  if (path2.basename(path2.resolve(vaultRoot)) === DEFAULT_VAULT_DIRNAME) {
+    return path2.join(vaultRoot, "index.db");
+  }
+  return path2.join(vaultRoot, ".granite", "index.db");
+}
+
 // src/commands/init.ts
-function initVault(dir) {
-  const targetDir = path2.resolve(dir);
-  if (fs2.existsSync(path2.join(targetDir, CONFIG_FILENAME))) {
+function initVault(dir = getDefaultVaultRoot()) {
+  const targetDir = path3.resolve(dir);
+  fs3.mkdirSync(targetDir, { recursive: true });
+  if (fs3.existsSync(path3.join(targetDir, CONFIG_FILENAME))) {
     console.error(`Vault already exists in ${targetDir}`);
     process.exit(1);
   }
   writeDefaultConfig(targetDir);
-  fs2.mkdirSync(path2.join(targetDir, ".granite"), { recursive: true });
+  fs3.mkdirSync(path3.dirname(getIndexDbPath(targetDir)), { recursive: true });
   const config = loadConfig(targetDir);
   for (const typeConfig of Object.values(config.note_types)) {
-    fs2.mkdirSync(path2.join(targetDir, typeConfig.folder), { recursive: true });
+    fs3.mkdirSync(path3.join(targetDir, typeConfig.folder), { recursive: true });
   }
   console.log(`Vault initialized in ${targetDir}`);
   console.log("");
   console.log("Created:");
   console.log(`  ${CONFIG_FILENAME}`);
-  console.log("  .granite/");
+  const indexDir = path3.relative(targetDir, path3.dirname(getIndexDbPath(targetDir)));
+  if (indexDir) {
+    console.log(`  ${indexDir}/`);
+  }
   for (const [name, typeConfig] of Object.entries(config.note_types)) {
     console.log(`  ${typeConfig.folder}/  (${name})`);
   }
   console.log("");
-  console.log('Next: mem new fleeting "My first note"');
+  console.log('Next: mem new "My first note" --type fleeting');
 }
 
-// src/core/vault.ts
-import fs3 from "fs";
-import path3 from "path";
-function findVaultRoot(from) {
-  let dir = from ? path3.resolve(from) : process.cwd();
-  while (true) {
-    if (fs3.existsSync(path3.join(dir, CONFIG_FILENAME))) {
-      return dir;
-    }
-    const parent = path3.dirname(dir);
-    if (parent === dir) return null;
-    dir = parent;
-  }
-}
-function requireVaultRoot(from) {
-  const root = findVaultRoot(from);
-  if (!root) {
-    throw new Error('Not inside a Granite vault. Run "mem init" to create one.');
-  }
-  return root;
-}
-function getIndexDbPath(vaultRoot) {
-  return path3.join(vaultRoot, ".granite", "index.db");
-}
+// src/commands/new.ts
+import fs6 from "fs";
 
 // src/core/note.ts
 import fs4 from "fs";
@@ -162,19 +201,31 @@ import matter from "gray-matter";
 function parseFrontmatter(content) {
   const { data, content: body } = matter(content);
   const fm = {
-    id: data.id ?? "",
-    title: data.title ?? "",
-    type: data.type ?? "",
-    created: data.created ?? "",
-    modified: data.modified ?? "",
+    id: toFrontmatterString(data.id),
+    title: toFrontmatterString(data.title),
+    type: toFrontmatterString(data.type),
+    created: toFrontmatterString(data.created),
+    modified: toFrontmatterString(data.modified),
     tags: data.tags ?? [],
-    aliases: data.aliases ?? []
+    aliases: data.aliases ?? [],
+    status: data.status ?? "active",
+    source: data.source ?? "human"
   };
+  for (const [key, value] of Object.entries(data)) {
+    if (!(key in fm)) {
+      fm[key] = value;
+    }
+  }
   return { frontmatter: fm, body };
 }
 function serializeFrontmatter(fm, body) {
   return matter.stringify(body, fm);
 }
+function toFrontmatterString(value) {
+  if (value === null || value === void 0) return "";
+  if (value instanceof Date) return value.toISOString();
+  return String(value);
+}
 
 // src/core/note.ts
 function createNote(vaultRoot, config, typeName, title, bodyOverride) {
@@ -211,7 +262,9 @@ function createNote(vaultRoot, config, typeName, title, bodyOverride) {
     created: now,
     modified: now,
     tags: [],
-    aliases: []
+    aliases: [],
+    status: "active",
+    source: "human"
   };
   const body = bodyOverride ?? typeConfig.template;
   const content = serializeFrontmatter(frontmatter, body);
@@ -262,153 +315,22 @@ function jsonSuccess(data) {
 function jsonError(error) {
   return JSON.stringify({ success: false, error }, null, 2);
 }
-
-// src/commands/new.ts
-function newNote(title, options) {
-  const vaultRoot = requireVaultRoot();
-  const config = loadConfig(vaultRoot);
-  const resolvedType = options.type || config.defaults.note_type;
-  const typeConfig = config.note_types[resolvedType];
-  const bodyOverride = typeConfig?.slug_format === "date" ? title + "\n" : void 0;
-  const note = createNote(vaultRoot, config, resolvedType, title, bodyOverride);
-  const lines = note.body.split("\n").length;
-  const overLimit = typeConfig && typeConfig.line_limit && lines > typeConfig.line_limit;
-  const textToScan = (note.body + " " + title).toLowerCase();
-  const allNotes = listNotes(vaultRoot, config).filter((n) => n.slug !== note.slug);
-  const suggestions = [];
-  for (const other of allNotes) {
-    const otherTitle = other.frontmatter.title.toLowerCase();
-    if (otherTitle.length < 3) continue;
-    if (textToScan.includes(otherTitle)) {
-      suggestions.push({ slug: other.slug, title: other.frontmatter.title, type: other.frontmatter.type });
-      continue;
-    }
-    for (const alias of other.frontmatter.aliases) {
-      if (alias.length < 3) continue;
-      if (textToScan.includes(alias.toLowerCase())) {
-        suggestions.push({ slug: other.slug, title: other.frontmatter.title, type: other.frontmatter.type });
-        break;
-      }
-    }
-  }
-  if (options.json) {
-    console.log(jsonSuccess({
-      slug: note.slug,
-      title: note.frontmatter.title,
-      type: resolvedType,
-      filepath: note.filepath,
-      suggestions
-    }));
-    return;
-  }
-  if (overLimit) {
-    const action = typeConfig.warn_only ? "Warning" : "Error";
-    console.warn(`${action}: Note exceeds ${typeConfig.line_limit} line limit for type "${resolvedType}"`);
-  }
-  console.log(note.filepath);
-  if (typeConfig?.instructions) {
-    console.log("");
-    console.log(`  \u{1F4A1} ${typeConfig.instructions}`);
-  }
-  if (suggestions.length > 0) {
-    console.log("");
-    console.log("  \u{1F517} Linked notes detected:");
-    for (const s of suggestions) {
-      console.log(`     [[${s.slug}]] \u2014 ${s.title} (${s.type})`);
-    }
-  }
-}
-
-// src/commands/add.ts
-import fs5 from "fs";
-function addNote(text, options = {}) {
-  const vaultRoot = requireVaultRoot();
-  const config = loadConfig(vaultRoot);
-  const typeName = config.defaults.note_type;
-  let content;
-  if (text) {
-    content = text;
-  } else if (!process.stdin.isTTY) {
-    content = fs5.readFileSync(0, "utf-8").trim();
-  } else {
-    console.error('Usage: mem add "some text" or echo "text" | mem add');
-    process.exit(1);
-  }
-  if (!content) {
-    console.error("No content provided.");
-    process.exit(1);
-  }
-  const firstLine = content.split("\n")[0];
-  const title = firstLine.length > 60 ? firstLine.slice(0, 60).trim() + "..." : firstLine;
-  const note = createNote(vaultRoot, config, typeName, title, content + "\n");
-  if (options.json) {
-    console.log(jsonSuccess({
-      slug: note.slug,
-      title: note.frontmatter.title,
-      type: typeName,
-      filepath: note.filepath
-    }));
-    return;
-  }
-  console.log(note.filepath);
-}
-
-// src/commands/open.ts
-import { execSync } from "child_process";
-function openNote(slug) {
-  const vaultRoot = requireVaultRoot();
-  const config = loadConfig(vaultRoot);
-  const note = findNoteBySlug(vaultRoot, config, slug);
-  if (!note) {
-    console.error(`Note not found: "${slug}"`);
-    process.exit(1);
+var VALID_STATUSES = ["inbox", "active", "archived"];
+var VALID_SOURCES = ["human", "agent", "extraction"];
+function validateStatus(value) {
+  if (!VALID_STATUSES.includes(value)) {
+    throw new Error(`Invalid status: "${value}". Expected one of: ${VALID_STATUSES.join(", ")}`);
   }
-  const editor = config.defaults.editor === "$EDITOR" ? process.env.EDITOR || "vi" : config.defaults.editor;
-  execSync(`${editor} "${note.filepath}"`, { stdio: "inherit" });
 }
-
-// src/commands/show.ts
-import fs6 from "fs";
-function showCommand(slug, options) {
-  const vaultRoot = requireVaultRoot();
-  const config = loadConfig(vaultRoot);
-  const note = findNoteBySlug(vaultRoot, config, slug);
-  if (!note) {
-    if (options.json) {
-      console.log(jsonError(`Note not found: ${slug}`));
-    } else {
-      console.error(`Note not found: ${slug}`);
-    }
-    process.exit(1);
-  }
-  if (options.json) {
-    console.log(jsonSuccess({
-      slug: note.slug,
-      title: note.frontmatter.title,
-      type: note.frontmatter.type,
-      created: note.frontmatter.created,
-      modified: note.frontmatter.modified,
-      tags: note.frontmatter.tags,
-      aliases: note.frontmatter.aliases,
-      body: note.body,
-      filepath: note.filepath
-    }));
-    return;
+function validateSource(value) {
+  if (!VALID_SOURCES.includes(value)) {
+    throw new Error(`Invalid source: "${value}". Expected one of: ${VALID_SOURCES.join(", ")}`);
   }
-  if (options.body) {
-    process.stdout.write(note.body);
-    return;
-  }
-  console.log(`# ${note.frontmatter.title}  (${note.slug})`);
-  console.log(`# type: ${note.frontmatter.type}  |  modified: ${note.frontmatter.modified.slice(0, 10)}`);
-  console.log("");
-  const content = fs6.readFileSync(note.filepath, "utf-8");
-  console.log(content);
 }
 
 // src/core/index-db.ts
 import Database from "better-sqlite3";
-import fs7 from "fs";
+import fs5 from "fs";
 import path5 from "path";
 
 // src/core/wikilinks.ts
@@ -454,7 +376,7 @@ function resolveWikilinks(links, allNotes) {
 }
 
 // src/core/index-db.ts
-var SCHEMA_VERSION = 1;
+var SCHEMA_VERSION = 2;
 var SCHEMA_SQL = `
 CREATE TABLE IF NOT EXISTS notes (
   slug        TEXT PRIMARY KEY,
@@ -466,7 +388,9 @@ CREATE TABLE IF NOT EXISTS notes (
   tags        TEXT,
   aliases     TEXT,
   body        TEXT NOT NULL,
-  filepath    TEXT NOT NULL
+  filepath    TEXT NOT NULL,
+  status      TEXT NOT NULL DEFAULT 'active',
+  source      TEXT NOT NULL DEFAULT 'human'
 );
 
 CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(
@@ -505,78 +429,928 @@ CREATE TABLE IF NOT EXISTS links (
 CREATE INDEX IF NOT EXISTS idx_links_target ON links(target_slug);
 CREATE INDEX IF NOT EXISTS idx_links_source ON links(source_slug);
 
-CREATE TABLE IF NOT EXISTS meta (
-  key   TEXT PRIMARY KEY,
-  value TEXT
-);
-`;
-function createDatabase(dbPath) {
-  fs7.mkdirSync(path5.dirname(dbPath), { recursive: true });
-  const db = new Database(dbPath);
-  db.pragma("journal_mode = WAL");
-  db.exec(SCHEMA_SQL);
-  db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run("schema_version", String(SCHEMA_VERSION));
-  return db;
+CREATE TABLE IF NOT EXISTS meta (
+  key   TEXT PRIMARY KEY,
+  value TEXT
+);
+`;
+function createDatabase(dbPath) {
+  fs5.mkdirSync(path5.dirname(dbPath), { recursive: true });
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  db.exec(SCHEMA_SQL);
+  db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run("schema_version", String(SCHEMA_VERSION));
+  return db;
+}
+function openDatabase(vaultRoot) {
+  const dbPath = getIndexDbPath(vaultRoot);
+  if (!fs5.existsSync(dbPath)) {
+    return createDatabase(dbPath);
+  }
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  const row = db.prepare("SELECT value FROM meta WHERE key = ?").get("schema_version");
+  const currentVersion = row ? Number(row.value) : 0;
+  if (currentVersion < SCHEMA_VERSION) {
+    db.close();
+    fs5.unlinkSync(dbPath);
+    return createDatabase(dbPath);
+  }
+  return db;
+}
+function rebuildIndex(vaultRoot, config, db) {
+  const notes = listNotes(vaultRoot, config);
+  db.exec("DELETE FROM links");
+  db.exec("DELETE FROM notes");
+  db.exec("INSERT INTO notes_fts(notes_fts) VALUES('rebuild')");
+  const insertNote = db.prepare(`
+    INSERT INTO notes (slug, id, title, type, created, modified, tags, aliases, body, filepath, status, source)
+    VALUES (@slug, @id, @title, @type, @created, @modified, @tags, @aliases, @body, @filepath, @status, @source)
+  `);
+  const insertLink = db.prepare(`
+    INSERT INTO links (source_slug, target_slug, target_raw, context)
+    VALUES (@source_slug, @target_slug, @target_raw, @context)
+  `);
+  const transaction = db.transaction(() => {
+    for (const note of notes) {
+      insertNote.run({
+        slug: note.slug,
+        id: note.frontmatter.id,
+        title: note.frontmatter.title,
+        type: note.frontmatter.type,
+        created: note.frontmatter.created,
+        modified: note.frontmatter.modified,
+        tags: JSON.stringify(note.frontmatter.tags),
+        aliases: JSON.stringify(note.frontmatter.aliases),
+        body: note.body,
+        filepath: note.filepath,
+        status: note.frontmatter.status ?? "active",
+        source: note.frontmatter.source ?? "human"
+      });
+      const links = parseWikilinks(note.body);
+      const resolved = resolveLinksAgainstNotes(links, notes);
+      for (const link of resolved) {
+        const bodyLines = note.body.split("\n");
+        const contextLine = bodyLines.find((l) => l.includes(link.raw)) ?? "";
+        insertLink.run({
+          source_slug: note.slug,
+          target_slug: link.resolved_slug ?? null,
+          target_raw: link.target,
+          context: contextLine.trim()
+        });
+      }
+    }
+    db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run("last_rebuild", (/* @__PURE__ */ new Date()).toISOString());
+  });
+  transaction();
+}
+function syncNoteInIndex(vaultRoot, config, db, note) {
+  const noteCountInDb = db.prepare("SELECT COUNT(*) as c FROM notes").get();
+  const noteCountOnDisk = countNoteFiles(vaultRoot, config);
+  const noteExists = db.prepare("SELECT 1 FROM notes WHERE slug = ?").get(note.slug);
+  const allowedCount = noteExists ? noteCountOnDisk : noteCountOnDisk - 1;
+  if (noteCountInDb.c !== allowedCount) {
+    rebuildIndex(vaultRoot, config, db);
+    return;
+  }
+  upsertNoteAndLinks(db, note);
+}
+function ensureIndex(vaultRoot, config) {
+  const db = openDatabase(vaultRoot);
+  if (config.index.auto_rebuild) {
+    rebuildIndex(vaultRoot, config, db);
+  }
+  return db;
+}
+function countNoteFiles(vaultRoot, config) {
+  let count = 0;
+  for (const typeConfig of Object.values(config.note_types)) {
+    const folder = path5.join(vaultRoot, typeConfig.folder);
+    if (!fs5.existsSync(folder)) continue;
+    count += fs5.readdirSync(folder).filter((file) => file.endsWith(".md")).length;
+  }
+  return count;
+}
+function upsertNoteAndLinks(db, note) {
+  const upsertNote = db.prepare(`
+    INSERT INTO notes (slug, id, title, type, created, modified, tags, aliases, body, filepath)
+    VALUES (@slug, @id, @title, @type, @created, @modified, @tags, @aliases, @body, @filepath)
+    ON CONFLICT(slug) DO UPDATE SET
+      id = excluded.id,
+      title = excluded.title,
+      type = excluded.type,
+      created = excluded.created,
+      modified = excluded.modified,
+      tags = excluded.tags,
+      aliases = excluded.aliases,
+      body = excluded.body,
+      filepath = excluded.filepath
+  `);
+  const deleteLinks = db.prepare("DELETE FROM links WHERE source_slug = ?");
+  const insertLink = db.prepare(`
+    INSERT INTO links (source_slug, target_slug, target_raw, context)
+    VALUES (@source_slug, @target_slug, @target_raw, @context)
+  `);
+  const transaction = db.transaction(() => {
+    upsertNote.run({
+      slug: note.slug,
+      id: note.frontmatter.id,
+      title: note.frontmatter.title,
+      type: note.frontmatter.type,
+      created: note.frontmatter.created,
+      modified: note.frontmatter.modified,
+      tags: JSON.stringify(note.frontmatter.tags),
+      aliases: JSON.stringify(note.frontmatter.aliases),
+      body: note.body,
+      filepath: note.filepath
+    });
+    deleteLinks.run(note.slug);
+    const links = parseWikilinks(note.body);
+    for (const link of links) {
+      const resolvedSlug = resolveLinkTarget(db, link.target);
+      const contextLine = note.body.split("\n").find((line) => line.includes(link.raw)) ?? "";
+      insertLink.run({
+        source_slug: note.slug,
+        target_slug: resolvedSlug,
+        target_raw: link.target,
+        context: contextLine.trim()
+      });
+    }
+    db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run("last_rebuild", (/* @__PURE__ */ new Date()).toISOString());
+  });
+  transaction();
+}
+function resolveLinksAgainstNotes(links, allNotes) {
+  return links.map((link) => {
+    const targetSlug = slugify(link.target);
+    let found = allNotes.find((note) => note.slug === targetSlug);
+    if (!found) {
+      found = allNotes.find((note) => note.frontmatter.title.toLowerCase() === link.target.toLowerCase());
+    }
+    if (!found) {
+      found = allNotes.find(
+        (note) => note.frontmatter.aliases.some((alias) => alias.toLowerCase() === link.target.toLowerCase())
+      );
+    }
+    return {
+      ...link,
+      resolved: !!found,
+      resolved_slug: found?.slug
+    };
+  });
+}
+function resolveLinkTarget(db, target) {
+  const targetSlug = slugify(target);
+  const exact = db.prepare(`
+    SELECT slug
+    FROM notes
+    WHERE slug = ? OR lower(title) = ?
+    LIMIT 1
+  `).get(targetSlug, target.toLowerCase());
+  if (exact) return exact.slug;
+  const rows = db.prepare("SELECT slug, aliases FROM notes").all();
+  for (const row of rows) {
+    try {
+      const aliases = JSON.parse(row.aliases || "[]");
+      if (aliases.some((alias) => typeof alias === "string" && alias.toLowerCase() === target.toLowerCase())) {
+        return row.slug;
+      }
+    } catch {
+      continue;
+    }
+  }
+  return null;
+}
+
+// src/core/suggest.ts
+function suggestLinks(db, note) {
+  const existingLinks = new Set(
+    parseWikilinks(note.body).map((l) => l.target.toLowerCase())
+  );
+  const allNotes = db.prepare("SELECT slug, title, aliases FROM notes WHERE slug != ?").all(note.slug);
+  const bodyLower = note.body.toLowerCase();
+  const suggestions = [];
+  for (const other of allNotes) {
+    const titleLower = other.title.toLowerCase();
+    if (existingLinks.has(titleLower) || existingLinks.has(other.slug)) continue;
+    let mentions = 0;
+    let idx = 0;
+    while ((idx = bodyLower.indexOf(titleLower, idx)) !== -1) {
+      mentions++;
+      idx += titleLower.length;
+    }
+    const aliases = JSON.parse(other.aliases || "[]");
+    for (const alias of aliases) {
+      const aliasLower = alias.toLowerCase();
+      if (existingLinks.has(aliasLower)) continue;
+      let aidx = 0;
+      while ((aidx = bodyLower.indexOf(aliasLower, aidx)) !== -1) {
+        mentions++;
+        aidx += aliasLower.length;
+      }
+    }
+    if (mentions > 0) {
+      suggestions.push({
+        target_slug: other.slug,
+        target_title: other.title,
+        mentions
+      });
+    }
+  }
+  return suggestions.sort((a, b) => b.mentions - a.mentions);
+}
+
+// src/core/recommendations.ts
+var MAX_LINK_RECOMMENDATIONS = 3;
+var MAX_TAG_RECOMMENDATIONS = 3;
+var MAX_ADDITION_RECOMMENDATIONS = 3;
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "with",
+  "from",
+  "that",
+  "this",
+  "into",
+  "about",
+  "your",
+  "have",
+  "will",
+  "them",
+  "they",
+  "what",
+  "when",
+  "where",
+  "which",
+  "their",
+  "there",
+  "here",
+  "then",
+  "than",
+  "also",
+  "just",
+  "should",
+  "could",
+  "would",
+  "into",
+  "over",
+  "under",
+  "after",
+  "before",
+  "using",
+  "used",
+  "make",
+  "made",
+  "more",
+  "most",
+  "some",
+  "such",
+  "each",
+  "many",
+  "only",
+  "through",
+  "between",
+  "within",
+  "write",
+  "notes",
+  "note",
+  "links",
+  "link",
+  "summary",
+  "details",
+  "source",
+  "date",
+  "role",
+  "context",
+  "contact",
+  "attendees",
+  "agenda",
+  "decisions",
+  "actions",
+  "goal",
+  "status",
+  "people",
+  "rationale",
+  "decision",
+  "options",
+  "considered",
+  "active",
+  "points",
+  "take",
+  "idea",
+  "ideas",
+  "project",
+  "meeting",
+  "person",
+  "reference",
+  "permanent",
+  "fleeting",
+  "how",
+  "know",
+  "work",
+  "works",
+  "what",
+  "prompted",
+  "them",
+  "what",
+  "plus",
+  "latest",
+  "recent",
+  "capture",
+  "record",
+  "refine",
+  "later",
+  "local",
+  "first",
+  "short",
+  "clear",
+  "split",
+  "related",
+  "relevant",
+  "title",
+  "titles"
+]);
+function recommendNote(vaultRoot, config, note, options = {}) {
+  const strategy = options.strategy ?? "rebuild";
+  const db = strategy === "incremental" ? openDatabase(vaultRoot) : ensureIndex(vaultRoot, config);
+  try {
+    if (strategy === "incremental") {
+      syncNoteInIndex(vaultRoot, config, db, note);
+    }
+    return getRecommendations(db, note, config);
+  } finally {
+    db.close();
+  }
+}
+function getRecommendations(db, note, config) {
+  const nearbyNotes = getNearbyNotes(db, note);
+  const existingTargets = getExistingTargets(db, note);
+  const mentionLinks = getMentionRecommendations(db, note);
+  const excludedSlugs = new Set(mentionLinks.map((link) => link.slug));
+  const similarLinks = getSearchRecommendations(db, note, existingTargets, excludedSlugs);
+  const links = [...mentionLinks, ...similarLinks].sort((a, b) => b.rank - a.rank || a.title.localeCompare(b.title)).slice(0, MAX_LINK_RECOMMENDATIONS);
+  const allNearbyNotes = mergeNearbyNotes(nearbyNotes, links);
+  return {
+    additions: getAdditionRecommendations(note, config),
+    links: links.map(({ tags: _tags, rank: _rank, ...link }) => link),
+    tags: getTagRecommendations(note, allNearbyNotes),
+    next_steps: getNextSteps(note, allNearbyNotes)
+  };
+}
+function formatRecommendations(recommendations) {
+  const lines = [];
+  if (recommendations.additions.length === 0 && recommendations.links.length === 0 && recommendations.tags.length === 0 && recommendations.next_steps.length === 0) {
+    return lines;
+  }
+  if (recommendations.additions.length > 0) {
+    lines.push("  Add now:");
+    for (const item of recommendations.additions) {
+      lines.push(`    ${item.text}`);
+    }
+  }
+  if (recommendations.links.length > 0) {
+    lines.push("  Link now:");
+    for (const link of recommendations.links) {
+      lines.push(`    [[${link.slug}]] \u2014 ${link.reason}`);
+    }
+  }
+  if (recommendations.tags.length > 0) {
+    lines.push("  Tag now:");
+    for (const tag of recommendations.tags) {
+      const notes = tag.source_slugs.length === 1 ? "1 nearby note" : `${tag.source_slugs.length} nearby notes`;
+      lines.push(`    ${tag.tag} \u2014 seen on ${notes}`);
+    }
+  }
+  if (recommendations.next_steps.length > 0) {
+    lines.push("  Next note:");
+    for (const step of recommendations.next_steps) {
+      const hint = step.title_hint ? ` Title hint: ${step.title_hint}.` : "";
+      lines.push(`    ${step.type} \u2014 ${step.reason}${hint}`);
+    }
+  }
+  return lines;
+}
+function getExistingTargets(db, note) {
+  const existing = /* @__PURE__ */ new Set();
+  const rows = db.prepare(`
+    SELECT target_slug, target_raw
+    FROM links
+    WHERE source_slug = ?
+  `).all(note.slug);
+  for (const row of rows) {
+    existing.add(row.target_raw.toLowerCase());
+    if (row.target_slug) {
+      existing.add(row.target_slug.toLowerCase());
+    }
+  }
+  return existing;
+}
+function getMentionRecommendations(db, note) {
+  const raw = suggestLinks(db, note);
+  const recommendations = [];
+  for (const suggestion of raw) {
+    const metadata = getNoteMetadata(db, suggestion.target_slug);
+    if (!metadata) continue;
+    recommendations.push({
+      slug: metadata.slug,
+      title: metadata.title,
+      type: metadata.type,
+      reason: `mentioned ${suggestion.mentions} time${suggestion.mentions === 1 ? "" : "s"}`,
+      source: "mention",
+      tags: metadata.tags,
+      rank: 100 + suggestion.mentions
+    });
+  }
+  return recommendations;
+}
+function getSearchRecommendations(db, note, existingTargets, excludedSlugs) {
+  const query = buildSearchQuery(note);
+  if (!query) return [];
+  const rows = db.prepare(`
+    SELECT
+      n.slug,
+      n.title,
+      n.type,
+      n.tags,
+      bm25(notes_fts, 8.0, 1.5, 0.5) AS score
+    FROM notes_fts
+    JOIN notes n ON n.rowid = notes_fts.rowid
+    WHERE notes_fts MATCH ? AND n.slug != ?
+    ORDER BY score
+    LIMIT 12
+  `).all(query, note.slug);
+  const out = [];
+  for (const row of rows) {
+    if (existingTargets.has(row.slug.toLowerCase()) || excludedSlugs.has(row.slug)) continue;
+    out.push({
+      slug: row.slug,
+      title: row.title,
+      type: row.type,
+      reason: "shared keywords",
+      source: "search",
+      tags: parseJsonArray(row.tags),
+      rank: Math.max(1, 40 - Math.round(row.score * 10))
+    });
+  }
+  return out;
+}
+function getTagRecommendations(note, nearbyNotes) {
+  const existingTags = new Set(note.frontmatter.tags.map((tag) => tag.toLowerCase()));
+  const noteTokens = new Set(tokenize(`${note.frontmatter.title} ${note.body}`));
+  const counts = /* @__PURE__ */ new Map();
+  for (const nearby of nearbyNotes) {
+    const weight = getNearbyWeight(nearby.source);
+    for (const tag of nearby.tags) {
+      const normalized = tag.trim().toLowerCase();
+      if (!normalized || existingTags.has(normalized)) continue;
+      const entry = counts.get(normalized) ?? { weight: 0, sourceSlugs: /* @__PURE__ */ new Set() };
+      entry.weight += weight;
+      if (tagMatchesNoteTokens(normalized, noteTokens)) {
+        entry.weight += 2;
+      }
+      entry.sourceSlugs.add(nearby.slug);
+      counts.set(normalized, entry);
+    }
+  }
+  return [...counts.entries()].map(([tag, info]) => ({
+    tag,
+    weight: info.weight,
+    source_slugs: [...info.sourceSlugs]
+  })).sort((a, b) => b.weight - a.weight || a.tag.localeCompare(b.tag)).slice(0, MAX_TAG_RECOMMENDATIONS);
+}
+function getNextSteps(note, nearbyNotes) {
+  const projectLink = nearbyNotes.find((link) => link.type === "project");
+  const personLink = nearbyNotes.find((link) => link.type === "person");
+  switch (note.frontmatter.type) {
+    case "fleeting":
+      return [{
+        type: "permanent",
+        title_hint: note.frontmatter.title,
+        reason: "Promote this into a durable note if it keeps mattering."
+      }];
+    case "reference":
+      return [{
+        type: "permanent",
+        title_hint: `Idea from ${note.frontmatter.title}`,
+        reason: "Distill one durable idea from this source."
+      }];
+    case "person":
+      return [{
+        type: projectLink ? "meeting" : "project",
+        title_hint: projectLink ? `${note.frontmatter.title} + ${projectLink.title}` : `${note.frontmatter.title} collaboration`,
+        reason: projectLink ? "Capture the latest interaction connected to this person." : "Anchor this person to a company, project, or collaboration note."
+      }];
+    case "meeting":
+      return [{
+        type: "decision",
+        title_hint: `Decision from ${note.frontmatter.title}`,
+        reason: "Extract the main decision so it can be linked independently."
+      }];
+    case "project":
+      return [{
+        type: personLink ? "meeting" : "decision",
+        title_hint: personLink ? `${note.frontmatter.title} sync` : `${note.frontmatter.title} decision`,
+        reason: personLink ? "Capture the next concrete conversation for this project." : "Record the decision that drives this project forward."
+      }];
+    case "decision":
+      return [{
+        type: "project",
+        title_hint: `${note.frontmatter.title} rollout`,
+        reason: "Attach this decision to the project where it applies."
+      }];
+    case "permanent":
+      return [{
+        type: projectLink ? "decision" : "project",
+        title_hint: projectLink ? `Decision from ${note.frontmatter.title}` : `${note.frontmatter.title} in practice`,
+        reason: projectLink ? "Capture the concrete decision this idea supports." : "Anchor this idea in a project, company, or active thread."
+      }];
+    default:
+      return [];
+  }
+}
+function getAdditionRecommendations(note, config) {
+  const recommendations = [];
+  const body = note.body;
+  const existingLinks = parseWikilinks(body);
+  const templateBody = config?.note_types[note.frontmatter.type]?.template ?? "";
+  switch (note.frontmatter.type) {
+    case "person":
+      if (isSectionSparse(body, "Role", templateBody)) {
+        recommendations.push({ text: "Add a one-line role, company, or why this person matters." });
+      }
+      if (isSectionSparse(body, "Context", templateBody)) {
+        recommendations.push({ text: "Add how you know them or what you work on together." });
+      }
+      if (existingLinks.length === 0) {
+        recommendations.push({ text: "Link one project, company, or topic in the Links section." });
+      }
+      break;
+    case "reference":
+      if (!hasUrl(body) || body.includes("URL or citation here.")) {
+        recommendations.push({ text: "Add the source URL or citation." });
+      }
+      if (!hasMeaningfulBullets(body, "Key Points")) {
+        recommendations.push({ text: "Write 2-3 key points in your own words." });
+      }
+      if (existingLinks.length === 0) {
+        recommendations.push({ text: "Link one permanent note, project, or topic this source relates to." });
+      }
+      break;
+    case "project":
+      if (isSectionSparse(body, "Goal", templateBody)) {
+        recommendations.push({ text: "Add a one-line goal so the project has a clear anchor." });
+      }
+      if (isSectionSparse(body, "People", templateBody)) {
+        recommendations.push({ text: "Link the people involved in the project." });
+      }
+      if (!hasMeaningfulBullets(body, "Key Decisions")) {
+        recommendations.push({ text: "Record one key decision or current status update." });
+      }
+      break;
+    case "meeting":
+      if (!hasAnyWikilinks(body)) {
+        recommendations.push({ text: "Link the attendees directly in the note." });
+      }
+      if (!hasMeaningfulBullets(body, "Actions")) {
+        recommendations.push({ text: "Capture at least one next action." });
+      }
+      if (!hasMeaningfulBullets(body, "Decisions")) {
+        recommendations.push({ text: "Capture one decision or open question." });
+      }
+      break;
+    case "permanent":
+      if (isSectionSparse(body, "Summary", templateBody)) {
+        recommendations.push({ text: "Write a one-line summary before expanding the idea." });
+      }
+      if (existingLinks.length === 0) {
+        recommendations.push({ text: "Link one project, company, person, or adjacent idea." });
+      }
+      break;
+    case "decision":
+      if (isSectionSparse(body, "Context", templateBody)) {
+        recommendations.push({ text: "Add the context that forced this decision." });
+      }
+      if (isSectionSparse(body, "Decision", templateBody)) {
+        recommendations.push({ text: "State the decision in one sentence." });
+      }
+      if (existingLinks.length === 0) {
+        recommendations.push({ text: "Link the project, meeting, or note affected by this decision." });
+      }
+      break;
+    case "fleeting":
+      if (tokenize(body).length < 8) {
+        recommendations.push({ text: "Add one more sentence if this capture is worth keeping." });
+      }
+      break;
+    default:
+      break;
+  }
+  if (config) {
+    const typeTemplate = config.note_types[note.frontmatter.type]?.template ?? "";
+    if (body.trim() === typeTemplate.trim() && recommendations.length === 0) {
+      recommendations.push({ text: "Fill the main sections before asking for related notes." });
+    }
+  }
+  return recommendations.slice(0, MAX_ADDITION_RECOMMENDATIONS);
+}
+function buildSearchQuery(note) {
+  const counts = /* @__PURE__ */ new Map();
+  const titleTokens = tokenize(note.frontmatter.title);
+  const bodyTokens = tokenize(note.body);
+  for (const token of titleTokens) {
+    counts.set(token, (counts.get(token) ?? 0) + 3);
+  }
+  for (const token of bodyTokens) {
+    counts.set(token, (counts.get(token) ?? 0) + 1);
+  }
+  const terms = [...counts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([token]) => token).slice(0, 8);
+  return terms.map((token) => `"${token}"`).join(" OR ");
+}
+function tokenize(text) {
+  const matches = text.toLowerCase().match(/[\p{L}\p{N}]{3,}/gu) ?? [];
+  return matches.filter((token) => !STOP_WORDS.has(token));
+}
+function tagMatchesNoteTokens(tag, noteTokens) {
+  const tagTokens = tokenize(tag.replace(/[-_]/g, " "));
+  return tagTokens.some((token) => noteTokens.has(token));
+}
+function getNearbyNotes(db, note) {
+  const bySlug = /* @__PURE__ */ new Map();
+  const outgoingRows = db.prepare(`
+    SELECT DISTINCT n.slug, n.title, n.type, n.tags
+    FROM links l
+    JOIN notes n ON n.slug = l.target_slug
+    WHERE l.source_slug = ?
+  `).all(note.slug);
+  for (const row of outgoingRows) {
+    bySlug.set(row.slug, {
+      slug: row.slug,
+      title: row.title,
+      type: row.type,
+      tags: parseJsonArray(row.tags),
+      source: "outgoing"
+    });
+  }
+  const backlinkRows = db.prepare(`
+    SELECT DISTINCT n.slug, n.title, n.type, n.tags
+    FROM links l
+    JOIN notes n ON n.slug = l.source_slug
+    WHERE l.target_slug = ? AND n.slug != ?
+  `).all(note.slug, note.slug);
+  for (const row of backlinkRows) {
+    if (bySlug.has(row.slug)) continue;
+    bySlug.set(row.slug, {
+      slug: row.slug,
+      title: row.title,
+      type: row.type,
+      tags: parseJsonArray(row.tags),
+      source: "backlink"
+    });
+  }
+  return [...bySlug.values()];
+}
+function mergeNearbyNotes(nearbyNotes, links) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const nearby of nearbyNotes) {
+    merged.set(nearby.slug, nearby);
+  }
+  for (const link of links) {
+    if (merged.has(link.slug)) continue;
+    merged.set(link.slug, {
+      slug: link.slug,
+      title: link.title,
+      type: link.type,
+      tags: link.tags,
+      source: link.source
+    });
+  }
+  return [...merged.values()];
+}
+function getNearbyWeight(source) {
+  switch (source) {
+    case "outgoing":
+    case "mention":
+      return 2;
+    case "backlink":
+    case "search":
+    default:
+      return 1;
+  }
+}
+function isSectionSparse(body, heading, templateBody) {
+  const section = getSectionContent(body, heading);
+  if (!section) return true;
+  const cleaned = section.replace(/^- \[ \]\s*$/gm, "").replace(/^-\s*$/gm, "").trim();
+  const templateSection = templateBody ? getSectionContent(templateBody, heading).trim() : "";
+  if (templateSection && cleaned === templateSection) {
+    return true;
+  }
+  return cleaned.length < 8;
+}
+function hasMeaningfulBullets(body, heading) {
+  const section = getSectionContent(body, heading);
+  if (!section) return false;
+  return section.split("\n").some((line) => /^-/.test(line.trim()) && line.replace(/^-+\s*/, "").trim().length > 2);
+}
+function getSectionContent(body, heading) {
+  const lines = body.split("\n");
+  const headingLine = `## ${heading}`;
+  const startIndex = lines.findIndex((line) => line.trim() === headingLine);
+  if (startIndex === -1) return "";
+  const collected = [];
+  for (let index = startIndex + 1; index < lines.length; index++) {
+    if (lines[index].startsWith("## ")) break;
+    collected.push(lines[index]);
+  }
+  return collected.join("\n");
+}
+function hasUrl(body) {
+  return /https?:\/\/\S+/i.test(body);
+}
+function hasAnyWikilinks(body) {
+  return parseWikilinks(body).length > 0;
+}
+function getNoteMetadata(db, slug) {
+  if (!slug) return null;
+  const row = db.prepare(`
+    SELECT slug, title, type, tags
+    FROM notes
+    WHERE slug = ?
+  `).get(slug);
+  if (!row) return null;
+  return {
+    slug: row.slug,
+    title: row.title,
+    type: row.type,
+    tags: parseJsonArray(row.tags)
+  };
+}
+function parseJsonArray(raw) {
+  if (!raw) return [];
+  try {
+    const value = JSON.parse(raw);
+    return Array.isArray(value) ? value.filter((item) => typeof item === "string") : [];
+  } catch {
+    return [];
+  }
+}
+
+// src/commands/new.ts
+function newNote(title, options) {
+  const vaultRoot = requireVaultRoot();
+  const config = loadConfig(vaultRoot);
+  const resolvedType = options.type || config.defaults.note_type;
+  const typeConfig = config.note_types[resolvedType];
+  const bodyOverride = typeConfig?.slug_format === "date" ? title + "\n" : void 0;
+  const note = createNote(vaultRoot, config, resolvedType, title, bodyOverride);
+  if (options.source || options.status) {
+    if (options.source) validateSource(options.source);
+    if (options.status) validateStatus(options.status);
+    const raw = fs6.readFileSync(note.filepath, "utf-8");
+    const { frontmatter, body } = parseFrontmatter(raw);
+    if (options.source) frontmatter.source = options.source;
+    if (options.status) frontmatter.status = options.status;
+    fs6.writeFileSync(note.filepath, serializeFrontmatter(frontmatter, body), "utf-8");
+    note.frontmatter = frontmatter;
+  }
+  const recommendationStrategy = typeConfig?.slug_format === "date" ? "incremental" : "rebuild";
+  const recommendations = recommendNote(vaultRoot, config, note, { strategy: recommendationStrategy });
+  const lines = note.body.split("\n").length;
+  const overLimit = typeConfig && typeConfig.line_limit && lines > typeConfig.line_limit;
+  if (options.json) {
+    console.log(jsonSuccess({
+      slug: note.slug,
+      title: note.frontmatter.title,
+      type: resolvedType,
+      status: note.frontmatter.status,
+      source: note.frontmatter.source,
+      filepath: note.filepath,
+      suggestions: recommendations.links.map((link) => ({
+        slug: link.slug,
+        title: link.title,
+        type: link.type
+      })),
+      recommendations
+    }));
+    return;
+  }
+  if (overLimit) {
+    const action = typeConfig.warn_only ? "Warning" : "Error";
+    console.warn(`${action}: Note exceeds ${typeConfig.line_limit} line limit for type "${resolvedType}"`);
+  }
+  console.log(note.filepath);
+  if (typeConfig?.instructions) {
+    console.log("");
+    console.log(`  \u{1F4A1} ${typeConfig.instructions}`);
+  }
+  const recommendationLines = formatRecommendations(recommendations);
+  if (recommendationLines.length > 0) {
+    console.log("");
+    console.log("Recommendations:");
+    for (const line of recommendationLines) {
+      console.log(line);
+    }
+  }
+}
+
+// src/commands/add.ts
+import fs7 from "fs";
+function addNote(text, options = {}) {
+  const vaultRoot = requireVaultRoot();
+  const config = loadConfig(vaultRoot);
+  const typeName = config.defaults.note_type;
+  let content;
+  if (text) {
+    content = text;
+  } else if (!process.stdin.isTTY) {
+    content = fs7.readFileSync(0, "utf-8").trim();
+  } else {
+    console.error('Usage: mem add "some text" or echo "text" | mem add');
+    process.exit(1);
+  }
+  if (!content) {
+    console.error("No content provided.");
+    process.exit(1);
+  }
+  const firstLine = content.split("\n")[0];
+  const title = firstLine.length > 60 ? firstLine.slice(0, 60).trim() + "..." : firstLine;
+  const note = createNote(vaultRoot, config, typeName, title, content + "\n");
+  const recommendations = recommendNote(vaultRoot, config, note, { strategy: "incremental" });
+  if (options.json) {
+    console.log(jsonSuccess({
+      slug: note.slug,
+      title: note.frontmatter.title,
+      type: typeName,
+      filepath: note.filepath,
+      recommendations
+    }));
+    return;
+  }
+  console.log(note.filepath);
+  const recommendationLines = formatRecommendations(recommendations);
+  if (recommendationLines.length > 0) {
+    console.log("");
+    console.log("Recommendations:");
+    for (const line of recommendationLines) {
+      console.log(line);
+    }
+  }
 }
-function openDatabase(vaultRoot) {
-  const dbPath = getIndexDbPath(vaultRoot);
-  if (!fs7.existsSync(dbPath)) {
-    return createDatabase(dbPath);
+
+// src/commands/open.ts
+import { execSync } from "child_process";
+function openNote(slug) {
+  const vaultRoot = requireVaultRoot();
+  const config = loadConfig(vaultRoot);
+  const note = findNoteBySlug(vaultRoot, config, slug);
+  if (!note) {
+    console.error(`Note not found: "${slug}"`);
+    process.exit(1);
   }
-  const db = new Database(dbPath);
-  db.pragma("journal_mode = WAL");
-  return db;
+  const editor = config.defaults.editor === "$EDITOR" ? process.env.EDITOR || "vi" : config.defaults.editor;
+  execSync(`${editor} "${note.filepath}"`, { stdio: "inherit" });
 }
-function rebuildIndex(vaultRoot, config, db) {
-  const notes = listNotes(vaultRoot, config);
-  db.exec("DELETE FROM links");
-  db.exec("DELETE FROM notes");
-  db.exec("INSERT INTO notes_fts(notes_fts) VALUES('rebuild')");
-  const insertNote = db.prepare(`
-    INSERT INTO notes (slug, id, title, type, created, modified, tags, aliases, body, filepath)
-    VALUES (@slug, @id, @title, @type, @created, @modified, @tags, @aliases, @body, @filepath)
-  `);
-  const insertLink = db.prepare(`
-    INSERT INTO links (source_slug, target_slug, target_raw, context)
-    VALUES (@source_slug, @target_slug, @target_raw, @context)
-  `);
-  const transaction = db.transaction(() => {
-    for (const note of notes) {
-      insertNote.run({
-        slug: note.slug,
-        id: note.frontmatter.id,
-        title: note.frontmatter.title,
-        type: note.frontmatter.type,
-        created: note.frontmatter.created,
-        modified: note.frontmatter.modified,
-        tags: JSON.stringify(note.frontmatter.tags),
-        aliases: JSON.stringify(note.frontmatter.aliases),
-        body: note.body,
-        filepath: note.filepath
-      });
-      const links = parseWikilinks(note.body);
-      const resolved = resolveWikilinks(links, notes);
-      for (const link of resolved) {
-        const bodyLines = note.body.split("\n");
-        const contextLine = bodyLines.find((l) => l.includes(link.raw)) ?? "";
-        insertLink.run({
-          source_slug: note.slug,
-          target_slug: link.resolved_slug ?? null,
-          target_raw: link.target,
-          context: contextLine.trim()
-        });
-      }
+
+// src/commands/show.ts
+import fs8 from "fs";
+function showCommand(slug, options) {
+  const vaultRoot = requireVaultRoot();
+  const config = loadConfig(vaultRoot);
+  const note = findNoteBySlug(vaultRoot, config, slug);
+  if (!note) {
+    if (options.json) {
+      console.log(jsonError(`Note not found: ${slug}`));
+    } else {
+      console.error(`Note not found: ${slug}`);
     }
-    db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES (?, ?)").run("last_rebuild", (/* @__PURE__ */ new Date()).toISOString());
-  });
-  transaction();
-}
-function ensureIndex(vaultRoot, config) {
-  const db = openDatabase(vaultRoot);
-  if (config.index.auto_rebuild) {
-    rebuildIndex(vaultRoot, config, db);
+    process.exit(1);
   }
-  return db;
+  if (options.json) {
+    console.log(jsonSuccess({
+      slug: note.slug,
+      title: note.frontmatter.title,
+      type: note.frontmatter.type,
+      created: note.frontmatter.created,
+      modified: note.frontmatter.modified,
+      tags: note.frontmatter.tags,
+      aliases: note.frontmatter.aliases,
+      status: note.frontmatter.status,
+      source: note.frontmatter.source,
+      body: note.body,
+      filepath: note.filepath
+    }));
+    return;
+  }
+  if (options.body) {
+    process.stdout.write(note.body);
+    return;
+  }
+  console.log(`# ${note.frontmatter.title}  (${note.slug})`);
+  console.log(`# type: ${note.frontmatter.type}  |  modified: ${note.frontmatter.modified.slice(0, 10)}`);
+  console.log("");
+  const content = fs8.readFileSync(note.filepath, "utf-8");
+  console.log(content);
 }
 
 // src/core/search.ts
@@ -665,44 +1439,6 @@ function backlinksCommand(slug, options) {
   }
 }
 
-// src/core/suggest.ts
-function suggestLinks(db, note) {
-  const existingLinks = new Set(
-    parseWikilinks(note.body).map((l) => l.target.toLowerCase())
-  );
-  const allNotes = db.prepare("SELECT slug, title, aliases FROM notes WHERE slug != ?").all(note.slug);
-  const bodyLower = note.body.toLowerCase();
-  const suggestions = [];
-  for (const other of allNotes) {
-    const titleLower = other.title.toLowerCase();
-    if (existingLinks.has(titleLower) || existingLinks.has(other.slug)) continue;
-    let mentions = 0;
-    let idx = 0;
-    while ((idx = bodyLower.indexOf(titleLower, idx)) !== -1) {
-      mentions++;
-      idx += titleLower.length;
-    }
-    const aliases = JSON.parse(other.aliases || "[]");
-    for (const alias of aliases) {
-      const aliasLower = alias.toLowerCase();
-      if (existingLinks.has(aliasLower)) continue;
-      let aidx = 0;
-      while ((aidx = bodyLower.indexOf(aliasLower, aidx)) !== -1) {
-        mentions++;
-        aidx += aliasLower.length;
-      }
-    }
-    if (mentions > 0) {
-      suggestions.push({
-        target_slug: other.slug,
-        target_title: other.title,
-        mentions
-      });
-    }
-  }
-  return suggestions.sort((a, b) => b.mentions - a.mentions);
-}
-
 // src/commands/suggest-links.ts
 function suggestLinksCommand(slug, options) {
   const vaultRoot = requireVaultRoot();
@@ -734,15 +1470,50 @@ function suggestLinksCommand(slug, options) {
   }
 }
 
+// src/commands/recommend.ts
+function recommendCommand(slug, options) {
+  const vaultRoot = requireVaultRoot();
+  const config = loadConfig(vaultRoot);
+  const note = findNoteBySlug(vaultRoot, config, slug);
+  if (!note) {
+    if (options.json) {
+      console.log(jsonError(`Note not found: ${slug}`));
+    } else {
+      console.error(`Note not found: "${slug}"`);
+    }
+    process.exit(1);
+  }
+  const recommendations = recommendNote(vaultRoot, config, note);
+  if (options.json) {
+    console.log(jsonSuccess({
+      slug: note.slug,
+      title: note.frontmatter.title,
+      type: note.frontmatter.type,
+      recommendations
+    }));
+    return;
+  }
+  const lines = formatRecommendations(recommendations);
+  if (lines.length === 0) {
+    console.log(`No recommendations found for "${note.frontmatter.title}".`);
+    return;
+  }
+  console.log(`Recommendations for "${note.frontmatter.title}":`);
+  console.log("");
+  for (const line of lines) {
+    console.log(line);
+  }
+}
+
 // src/core/doctor.ts
-import fs8 from "fs";
+import fs9 from "fs";
 import path6 from "path";
 function runDoctor(vaultRoot, config, db) {
   const issues = [];
   const notes = listNotes(vaultRoot, config);
   for (const [name, typeConfig] of Object.entries(config.note_types)) {
     const folder = path6.join(vaultRoot, typeConfig.folder);
-    if (!fs8.existsSync(folder)) {
+    if (!fs9.existsSync(folder)) {
       issues.push({
         level: "error",
         file: `granite.yml`,
@@ -878,7 +1649,7 @@ ${errors.length} error(s), ${warnings.length} warning(s), ${infos.length} info(s
 import { Hono } from "hono";
 import { serve } from "@hono/node-server";
 import path7 from "path";
-import fs9 from "fs";
+import fs10 from "fs";
 function createApp(vaultRoot, config) {
   const app = new Hono();
   app.get("/api/notes", (c) => {
@@ -968,12 +1739,12 @@ function createApp(vaultRoot, config) {
   app.get("/*", (c) => {
     const reqPath = c.req.path === "/" ? "/index.html" : c.req.path;
     const filePath = path7.join(publicDir, reqPath);
-    if (!fs9.existsSync(filePath)) {
+    if (!fs10.existsSync(filePath)) {
       const indexPath = path7.join(publicDir, "index.html");
-      const html = fs9.readFileSync(indexPath, "utf-8");
+      const html = fs10.readFileSync(indexPath, "utf-8");
       return c.html(html);
     }
-    const content = fs9.readFileSync(filePath);
+    const content = fs10.readFileSync(filePath);
     const ext = path7.extname(filePath);
     const mimeTypes = {
       ".html": "text/html",
@@ -1024,6 +1795,45 @@ Usage: mem new <type> <title>`);
 }
 
 // src/commands/list.ts
+var AVAILABLE_FIELDS = ["slug", "title", "type", "created", "modified", "tags", "aliases", "status", "source", "filepath"];
+function pickFields(note, fields) {
+  const out = {};
+  for (const f of fields) {
+    switch (f) {
+      case "slug":
+        out.slug = note.slug;
+        break;
+      case "title":
+        out.title = note.frontmatter.title;
+        break;
+      case "type":
+        out.type = note.frontmatter.type;
+        break;
+      case "created":
+        out.created = note.frontmatter.created;
+        break;
+      case "modified":
+        out.modified = note.frontmatter.modified;
+        break;
+      case "tags":
+        out.tags = note.frontmatter.tags;
+        break;
+      case "aliases":
+        out.aliases = note.frontmatter.aliases;
+        break;
+      case "status":
+        out.status = note.frontmatter.status;
+        break;
+      case "source":
+        out.source = note.frontmatter.source;
+        break;
+      case "filepath":
+        out.filepath = note.filepath;
+        break;
+    }
+  }
+  return out;
+}
 function listCommand(options) {
   const vaultRoot = requireVaultRoot();
   const config = loadConfig(vaultRoot);
@@ -1031,17 +1841,28 @@ function listCommand(options) {
   if (options.type) {
     notes = notes.filter((n) => n.frontmatter.type === options.type);
   }
+  if (options.status) {
+    notes = notes.filter((n) => n.frontmatter.status === options.status);
+  }
+  if (options.source) {
+    notes = notes.filter((n) => n.frontmatter.source === options.source);
+  }
+  if (options.since) {
+    notes = notes.filter((n) => n.frontmatter.modified >= options.since);
+  }
   notes.sort((a, b) => b.frontmatter.modified.localeCompare(a.frontmatter.modified));
-  if (options.json) {
-    const out = notes.map((n) => ({
-      slug: n.slug,
-      title: n.frontmatter.title,
-      type: n.frontmatter.type,
-      created: n.frontmatter.created,
-      modified: n.frontmatter.modified,
-      tags: n.frontmatter.tags,
-      filepath: n.filepath
-    }));
+  if (options.json !== void 0 && options.json !== false) {
+    let fields;
+    if (typeof options.json === "string") {
+      fields = options.json.split(",").map((f) => f.trim()).filter((f) => AVAILABLE_FIELDS.includes(f));
+      if (fields.length === 0) {
+        console.log(`Available fields: ${AVAILABLE_FIELDS.join(", ")}`);
+        return;
+      }
+    } else {
+      fields = AVAILABLE_FIELDS;
+    }
+    const out = notes.map((n) => pickFields(n, fields));
     console.log(jsonSuccess(out));
     return;
   }
@@ -1052,14 +1873,15 @@ function listCommand(options) {
   for (const note of notes) {
     const date = note.frontmatter.modified.slice(0, 10);
     const type = note.frontmatter.type.padEnd(10);
-    console.log(`  ${date}  ${type}  ${note.frontmatter.title}  (${note.slug})`);
+    const status = note.frontmatter.status?.padEnd(8) ?? "active  ";
+    console.log(`  ${date}  ${type}  ${status}  ${note.frontmatter.title}  (${note.slug})`);
   }
   console.log(`
 ${notes.length} note(s)`);
 }
 
 // src/commands/edit.ts
-import fs10 from "fs";
+import fs11 from "fs";
 import { execSync as execSync2 } from "child_process";
 function editCommand(slug, options) {
   const vaultRoot = requireVaultRoot();
@@ -1069,9 +1891,9 @@ function editCommand(slug, options) {
     console.error(`Note not found: ${slug}`);
     process.exit(1);
   }
-  const hasFlags = options.body !== void 0 || options.append !== void 0 || options.title !== void 0 || options.tag !== void 0 || options.alias !== void 0;
+  const hasFlags = options.body !== void 0 || options.append !== void 0 || options.title !== void 0 || options.tag !== void 0 || options.alias !== void 0 || options.status !== void 0 || options.source !== void 0;
   if (hasFlags) {
-    let { frontmatter, body } = parseFrontmatter(fs10.readFileSync(note.filepath, "utf-8"));
+    let { frontmatter, body } = parseFrontmatter(fs11.readFileSync(note.filepath, "utf-8"));
     if (options.title) {
       frontmatter.title = options.title;
     }
@@ -1087,6 +1909,14 @@ function editCommand(slug, options) {
       for (const a of newAliases) existing.add(a);
       frontmatter.aliases = [...existing];
     }
+    if (options.status) {
+      validateStatus(options.status);
+      frontmatter.status = options.status;
+    }
+    if (options.source) {
+      validateSource(options.source);
+      frontmatter.source = options.source;
+    }
     if (options.body !== void 0) {
       body = options.body + "\n";
     }
@@ -1094,43 +1924,57 @@ function editCommand(slug, options) {
       body = body.trimEnd() + "\n" + options.append + "\n";
     }
     frontmatter.modified = (/* @__PURE__ */ new Date()).toISOString();
-    fs10.writeFileSync(note.filepath, serializeFrontmatter(frontmatter, body), "utf-8");
+    fs11.writeFileSync(note.filepath, serializeFrontmatter(frontmatter, body), "utf-8");
     console.log(note.filepath);
+    const recommendationStrategy = options.title !== void 0 || options.alias !== void 0 ? "rebuild" : "incremental";
+    printRecommendations(vaultRoot, config, note.filepath, recommendationStrategy);
   } else {
     const editor = process.env.EDITOR || "vi";
-    const statBefore = fs10.statSync(note.filepath).mtimeMs;
+    const statBefore = fs11.statSync(note.filepath).mtimeMs;
     try {
       execSync2(`${editor} "${note.filepath}"`, { stdio: "inherit" });
     } catch {
       console.error(`Failed to open editor: ${editor}`);
       process.exit(1);
     }
-    const statAfter = fs10.statSync(note.filepath).mtimeMs;
+    const statAfter = fs11.statSync(note.filepath).mtimeMs;
     if (statAfter !== statBefore) {
-      const { frontmatter, body } = parseFrontmatter(fs10.readFileSync(note.filepath, "utf-8"));
+      const { frontmatter, body } = parseFrontmatter(fs11.readFileSync(note.filepath, "utf-8"));
       frontmatter.modified = (/* @__PURE__ */ new Date()).toISOString();
-      fs10.writeFileSync(note.filepath, serializeFrontmatter(frontmatter, body), "utf-8");
+      fs11.writeFileSync(note.filepath, serializeFrontmatter(frontmatter, body), "utf-8");
       console.log(`Updated: ${note.filepath}`);
+      printRecommendations(vaultRoot, config, note.filepath, "rebuild");
     }
   }
 }
+function printRecommendations(vaultRoot, config, filepath, strategy) {
+  const updatedNote = readNote(filepath);
+  const recommendations = recommendNote(vaultRoot, config, updatedNote, { strategy });
+  const lines = formatRecommendations(recommendations);
+  if (lines.length === 0) return;
+  console.log("");
+  console.log("Recommendations:");
+  for (const line of lines) {
+    console.log(line);
+  }
+}
 
 // src/index.ts
 var program = new Command();
 program.name("mem").description("Granite \u2014 a local-first markdown memory system").version("0.1.0");
-program.command("init").description("Initialize a new vault in the current directory").action(() => {
-  initVault(process.cwd());
+program.command("init").description("Initialize the default vault in ~/.granite").action(() => {
+  initVault();
 });
-program.command("new").description("Create a new note").argument("<title>", "Note title").option("-t, --type <type>", "Note type (e.g. fleeting, permanent, reference)").option("--json", "Output as JSON (agent-friendly)").action((title, options) => {
+program.command("new").description("Create a new note").argument("<title>", "Note title").option("-t, --type <type>", "Note type (e.g. fleeting, permanent, reference)").option("--source <source>", "Set source (human, agent, extraction)").option("--status <status>", "Set status (inbox, active, archived)").option("--json", "Output as JSON (agent-friendly)").action((title, options) => {
   newNote(title, options);
 });
 program.command("add").description("Quick-capture a fleeting note (reads stdin if no text given)").argument("[text]", "Note text (or pipe via stdin)").option("--json", "Output as JSON (agent-friendly)").action((text, options) => {
   addNote(text, options);
 });
-program.command("list").alias("ls").description("List notes").option("-t, --type <type>", "Filter by note type").option("--json", "Output as JSON (agent-friendly)").action((options) => {
+program.command("list").alias("ls").description("List notes").option("-t, --type <type>", "Filter by note type").option("-s, --status <status>", "Filter by status (inbox, active, archived)").option("--source <source>", "Filter by source (human, agent, extraction)").option("--since <date>", "Filter notes modified since date (YYYY-MM-DD)").option("--json [fields]", "Output as JSON; optionally specify fields (e.g. --json slug,title,type)").action((options) => {
   listCommand(options);
 });
-program.command("edit").description("Edit a note (opens $EDITOR, or use flags for programmatic edits)").argument("<slug>", "Note slug").option("--body <text>", "Replace the note body").option("--append <text>", "Append text to the note body").option("--title <title>", "Update the note title").option("--tag <tags>", "Add tags (comma-separated)").option("--alias <aliases>", "Add aliases (comma-separated)").action((slug, options) => {
+program.command("edit").description("Edit a note (opens $EDITOR, or use flags for programmatic edits)").argument("<slug>", "Note slug").option("--body <text>", "Replace the note body").option("--append <text>", "Append text to the note body").option("--title <title>", "Update the note title").option("--tag <tags>", "Add tags (comma-separated)").option("--alias <aliases>", "Add aliases (comma-separated)").option("--status <status>", "Set status (inbox, active, archived)").option("--source <source>", "Set source (human, agent, extraction)").action((slug, options) => {
   editCommand(slug, options);
 });
 program.command("open").description("Open a note in your editor (alias for edit)").argument("<slug>", "Note slug").action((slug) => {
@@ -1148,6 +1992,9 @@ program.command("backlinks").description("Show notes that link to a given note")
 program.command("suggest-links").description("Suggest wikilinks based on unlinked mentions").argument("<slug>", "Note slug").option("--json", "Output as JSON (agent-friendly)").action((slug, options) => {
   suggestLinksCommand(slug, options);
 });
+program.command("recommend").description("Suggest links, tags, and the next note to create").argument("<slug>", "Note slug").option("--json", "Output as JSON (agent-friendly)").action((slug, options) => {
+  recommendCommand(slug, options);
+});
 program.command("types").description("List available note types").action(() => {
   typesCommand();
 });