granite-mem 0.1.1

package/dist/index.js

@@ -0,0 +1,1160 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import fs2 from "fs";
+import path2 from "path";
+
+// src/core/config.ts
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+var CONFIG_FILENAME = "granite.yml";
+var DEFAULT_CONFIG = {
+  vault_name: "My Vault",
+  version: 1,
+  note_types: {
+    fleeting: {
+      folder: "notes/fleeting",
+      description: "Quick captures, inbox items",
+      template: "",
+      line_limit: 50,
+      warn_only: true,
+      slug_format: "date",
+      instructions: "Write a short thought, observation, or idea. Keep it raw \u2014 refine later into a permanent note."
+    },
+    permanent: {
+      folder: "notes/permanent",
+      description: "Refined, linked notes \u2014 one idea per note",
+      template: "## Summary\n\n## Details\n\n## Links\n",
+      line_limit: 200,
+      warn_only: false,
+      instructions: "One atomic idea per note. Write a clear summary, then expand in details. Link to related notes with [[wikilinks]]. If the note grows too long, split it."
+    },
+    reference: {
+      folder: "notes/reference",
+      description: "Notes on external sources (articles, books, talks)",
+      template: "## Source\n\nURL or citation here.\n\n## Date\n\n## Key Points\n\n- \n\n## My Take\n\n",
+      line_limit: 300,
+      warn_only: true,
+      instructions: "Capture the source, the key points in your own words, and your reaction. Link to permanent notes that relate."
+    },
+    person: {
+      folder: "notes/people",
+      description: "Card for a person \u2014 contact, context, history",
+      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."
+    },
+    meeting: {
+      folder: "notes/meetings",
+      description: "Meeting notes with attendees, decisions, and actions",
+      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."
+    },
+    project: {
+      folder: "notes/projects",
+      description: "Project overview \u2014 goals, status, people, links",
+      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."
+    },
+    decision: {
+      folder: "notes/decisions",
+      description: "Record of a decision \u2014 context, options, outcome",
+      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."
+    }
+  },
+  defaults: {
+    note_type: "fleeting",
+    editor: "$EDITOR"
+  },
+  index: {
+    auto_rebuild: true
+  }
+};
+function writeDefaultConfig(dir) {
+  const configPath = path.join(dir, CONFIG_FILENAME);
+  const content = yaml.dump(DEFAULT_CONFIG, { lineWidth: 120, noRefs: true });
+  fs.writeFileSync(configPath, content, "utf-8");
+}
+function loadConfig(vaultRoot) {
+  const configPath = path.join(vaultRoot, CONFIG_FILENAME);
+  if (!fs.existsSync(configPath)) {
+    throw new Error(`No ${CONFIG_FILENAME} found in ${vaultRoot}. Run "mem init" first.`);
+  }
+  const raw = fs.readFileSync(configPath, "utf-8");
+  const parsed = yaml.load(raw);
+  return parsed;
+}
+
+// src/commands/init.ts
+function initVault(dir) {
+  const targetDir = path2.resolve(dir);
+  if (fs2.existsSync(path2.join(targetDir, CONFIG_FILENAME))) {
+    console.error(`Vault already exists in ${targetDir}`);
+    process.exit(1);
+  }
+  writeDefaultConfig(targetDir);
+  fs2.mkdirSync(path2.join(targetDir, ".granite"), { recursive: true });
+  const config = loadConfig(targetDir);
+  for (const typeConfig of Object.values(config.note_types)) {
+    fs2.mkdirSync(path2.join(targetDir, typeConfig.folder), { recursive: true });
+  }
+  console.log(`Vault initialized in ${targetDir}`);
+  console.log("");
+  console.log("Created:");
+  console.log(`  ${CONFIG_FILENAME}`);
+  console.log("  .granite/");
+  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"');
+}
+
+// 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/core/note.ts
+import fs4 from "fs";
+import path4 from "path";
+import { v4 as uuidv4 } from "uuid";
+
+// src/core/slugify.ts
+function slugify(title) {
+  return title.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 60);
+}
+
+// src/core/frontmatter.ts
+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 ?? "",
+    tags: data.tags ?? [],
+    aliases: data.aliases ?? []
+  };
+  return { frontmatter: fm, body };
+}
+function serializeFrontmatter(fm, body) {
+  return matter.stringify(body, fm);
+}
+
+// src/core/note.ts
+function createNote(vaultRoot, config, typeName, title, bodyOverride) {
+  const typeConfig = config.note_types[typeName];
+  if (!typeConfig) {
+    throw new Error(`Unknown note type: "${typeName}". Available: ${Object.keys(config.note_types).join(", ")}`);
+  }
+  const folder = path4.join(vaultRoot, typeConfig.folder);
+  let finalSlug;
+  if (typeConfig.slug_format === "date") {
+    const now2 = /* @__PURE__ */ new Date();
+    const date = now2.toISOString().slice(0, 10);
+    const rand = Math.random().toString(36).slice(2, 6);
+    finalSlug = `${date}-${rand}`;
+    while (fs4.existsSync(path4.join(folder, `${finalSlug}.md`))) {
+      const r = Math.random().toString(36).slice(2, 6);
+      finalSlug = `${date}-${r}`;
+    }
+  } else {
+    let slug = slugify(title);
+    if (!slug) slug = "untitled";
+    finalSlug = slug;
+    let counter = 2;
+    while (fs4.existsSync(path4.join(folder, `${finalSlug}.md`))) {
+      finalSlug = `${slug}-${counter}`;
+      counter++;
+    }
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const frontmatter = {
+    id: uuidv4(),
+    title,
+    type: typeName,
+    created: now,
+    modified: now,
+    tags: [],
+    aliases: []
+  };
+  const body = bodyOverride ?? typeConfig.template;
+  const content = serializeFrontmatter(frontmatter, body);
+  const filepath = path4.join(folder, `${finalSlug}.md`);
+  fs4.mkdirSync(folder, { recursive: true });
+  fs4.writeFileSync(filepath, content, "utf-8");
+  return {
+    slug: finalSlug,
+    filepath,
+    frontmatter,
+    body,
+    outgoing_links: []
+  };
+}
+function readNote(filepath) {
+  const content = fs4.readFileSync(filepath, "utf-8");
+  const { frontmatter, body } = parseFrontmatter(content);
+  const slug = path4.basename(filepath, ".md");
+  return { slug, filepath, frontmatter, body, outgoing_links: [] };
+}
+function listNotes(vaultRoot, config) {
+  const notes = [];
+  for (const typeConfig of Object.values(config.note_types)) {
+    const folder = path4.join(vaultRoot, typeConfig.folder);
+    if (!fs4.existsSync(folder)) continue;
+    const files = fs4.readdirSync(folder).filter((f) => f.endsWith(".md"));
+    for (const file of files) {
+      const filepath = path4.join(folder, file);
+      notes.push(readNote(filepath));
+    }
+  }
+  return notes;
+}
+function findNoteBySlug(vaultRoot, config, slug) {
+  for (const typeConfig of Object.values(config.note_types)) {
+    const filepath = path4.join(vaultRoot, typeConfig.folder, `${slug}.md`);
+    if (fs4.existsSync(filepath)) {
+      return readNote(filepath);
+    }
+  }
+  return null;
+}
+
+// src/core/json-output.ts
+function jsonSuccess(data) {
+  return JSON.stringify({ success: true, data }, null, 2);
+}
+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);
+  }
+  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;
+  }
+  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 path5 from "path";
+
+// src/core/wikilinks.ts
+var WIKILINK_RE = /\[\[([^\]]+)\]\]/g;
+var FENCED_CODE_RE = /^```[\s\S]*?^```/gm;
+var INLINE_CODE_RE = /`[^`]+`/g;
+function parseWikilinks(body) {
+  const stripped = body.replace(FENCED_CODE_RE, "").replace(INLINE_CODE_RE, "");
+  const links = [];
+  let match;
+  while ((match = WIKILINK_RE.exec(stripped)) !== null) {
+    const inner = match[1];
+    const parts = inner.split("|");
+    const target = parts[0].trim();
+    const display = parts.length > 1 ? parts[1].trim() : target;
+    links.push({
+      raw: match[0],
+      target,
+      display,
+      resolved: false
+    });
+  }
+  return links;
+}
+function resolveWikilinks(links, allNotes) {
+  return links.map((link) => {
+    const targetSlug = slugify(link.target);
+    let found = allNotes.find((n) => n.slug === targetSlug);
+    if (!found) {
+      found = allNotes.find((n) => n.frontmatter.title.toLowerCase() === link.target.toLowerCase());
+    }
+    if (!found) {
+      found = allNotes.find(
+        (n) => n.frontmatter.aliases.some((a) => a.toLowerCase() === link.target.toLowerCase())
+      );
+    }
+    return {
+      ...link,
+      resolved: !!found,
+      resolved_slug: found?.slug
+    };
+  });
+}
+
+// src/core/index-db.ts
+var SCHEMA_VERSION = 1;
+var SCHEMA_SQL = `
+CREATE TABLE IF NOT EXISTS notes (
+  slug        TEXT PRIMARY KEY,
+  id          TEXT UNIQUE NOT NULL,
+  title       TEXT NOT NULL,
+  type        TEXT NOT NULL,
+  created     TEXT NOT NULL,
+  modified    TEXT NOT NULL,
+  tags        TEXT,
+  aliases     TEXT,
+  body        TEXT NOT NULL,
+  filepath    TEXT NOT NULL
+);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS notes_fts USING fts5(
+  title,
+  body,
+  tags,
+  content='notes',
+  content_rowid='rowid'
+);
+
+CREATE TRIGGER IF NOT EXISTS notes_ai AFTER INSERT ON notes BEGIN
+  INSERT INTO notes_fts(rowid, title, body, tags)
+    VALUES (new.rowid, new.title, new.body, new.tags);
+END;
+
+CREATE TRIGGER IF NOT EXISTS notes_ad AFTER DELETE ON notes BEGIN
+  INSERT INTO notes_fts(notes_fts, rowid, title, body, tags)
+    VALUES ('delete', old.rowid, old.title, old.body, old.tags);
+END;
+
+CREATE TRIGGER IF NOT EXISTS notes_au AFTER UPDATE ON notes BEGIN
+  INSERT INTO notes_fts(notes_fts, rowid, title, body, tags)
+    VALUES ('delete', old.rowid, old.title, old.body, old.tags);
+  INSERT INTO notes_fts(rowid, title, body, tags)
+    VALUES (new.rowid, new.title, new.body, new.tags);
+END;
+
+CREATE TABLE IF NOT EXISTS links (
+  source_slug   TEXT NOT NULL,
+  target_slug   TEXT,
+  target_raw    TEXT NOT NULL,
+  context       TEXT,
+  FOREIGN KEY (source_slug) REFERENCES notes(slug)
+);
+
+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;
+}
+function openDatabase(vaultRoot) {
+  const dbPath = getIndexDbPath(vaultRoot);
+  if (!fs7.existsSync(dbPath)) {
+    return createDatabase(dbPath);
+  }
+  const db = new Database(dbPath);
+  db.pragma("journal_mode = WAL");
+  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)
+    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()
+        });
+      }
+    }
+    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);
+  }
+  return db;
+}
+
+// src/core/search.ts
+function searchNotes(db, query) {
+  const stmt = db.prepare(`
+    SELECT
+      n.slug,
+      n.title,
+      snippet(notes_fts, 1, '>>>', '<<<', '...', 30) as snippet,
+      rank
+    FROM notes_fts
+    JOIN notes n ON n.rowid = notes_fts.rowid
+    WHERE notes_fts MATCH ?
+    ORDER BY rank
+    LIMIT 20
+  `);
+  const rows = stmt.all(query);
+  return rows.map((r) => ({
+    slug: r.slug,
+    title: r.title,
+    snippet: r.snippet,
+    score: r.rank
+  }));
+}
+
+// src/commands/search.ts
+function searchCommand(query, options) {
+  const vaultRoot = requireVaultRoot();
+  const config = loadConfig(vaultRoot);
+  const db = ensureIndex(vaultRoot, config);
+  const results = searchNotes(db, query);
+  db.close();
+  if (options.json) {
+    console.log(jsonSuccess(results));
+    return;
+  }
+  if (results.length === 0) {
+    console.log("No results found.");
+    return;
+  }
+  for (const r of results) {
+    console.log(`  ${r.title} (${r.slug})`);
+    console.log(`    ${r.snippet}`);
+    console.log("");
+  }
+}
+
+// src/core/backlinks.ts
+function getBacklinks(db, slug) {
+  const stmt = db.prepare(`
+    SELECT
+      l.source_slug,
+      n.title as source_title,
+      l.context
+    FROM links l
+    JOIN notes n ON n.slug = l.source_slug
+    WHERE l.target_slug = ?
+    ORDER BY n.title
+  `);
+  return stmt.all(slug);
+}
+
+// src/commands/backlinks.ts
+function backlinksCommand(slug, options) {
+  const vaultRoot = requireVaultRoot();
+  const config = loadConfig(vaultRoot);
+  const db = ensureIndex(vaultRoot, config);
+  const backlinks = getBacklinks(db, slug);
+  db.close();
+  if (options.json) {
+    console.log(jsonSuccess(backlinks));
+    return;
+  }
+  if (backlinks.length === 0) {
+    console.log(`No backlinks found for "${slug}".`);
+    return;
+  }
+  console.log(`Backlinks to "${slug}":`);
+  console.log("");
+  for (const bl of backlinks) {
+    console.log(`  \u2190 ${bl.source_title} (${bl.source_slug})`);
+    if (bl.context) {
+      console.log(`    ${bl.context}`);
+    }
+    console.log("");
+  }
+}
+
+// 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();
+  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 db = ensureIndex(vaultRoot, config);
+  const suggestions = suggestLinks(db, note);
+  db.close();
+  if (options.json) {
+    console.log(jsonSuccess(suggestions));
+    return;
+  }
+  if (suggestions.length === 0) {
+    console.log("No link suggestions found.");
+    return;
+  }
+  console.log(`Suggested links for "${note.frontmatter.title}":`);
+  console.log("");
+  for (const s of suggestions) {
+    console.log(`  \u2192 [[${s.target_title}]] \u2014 ${s.mentions} mention${s.mentions > 1 ? "s" : ""}`);
+  }
+}
+
+// src/core/doctor.ts
+import fs8 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)) {
+      issues.push({
+        level: "error",
+        file: `granite.yml`,
+        message: `Note type "${name}" folder does not exist: ${typeConfig.folder}`
+      });
+    }
+  }
+  for (const note of notes) {
+    const fm = note.frontmatter;
+    if (!fm.id) {
+      issues.push({ level: "error", file: note.filepath, message: "Missing frontmatter field: id" });
+    }
+    if (!fm.title) {
+      issues.push({ level: "error", file: note.filepath, message: "Missing frontmatter field: title" });
+    }
+    if (!fm.type) {
+      issues.push({ level: "warning", file: note.filepath, message: "Missing frontmatter field: type" });
+    }
+    if (!fm.created) {
+      issues.push({ level: "warning", file: note.filepath, message: "Missing frontmatter field: created" });
+    }
+  }
+  for (const note of notes) {
+    const links = parseWikilinks(note.body);
+    const resolved = resolveWikilinks(links, notes);
+    for (const link of resolved) {
+      if (!link.resolved) {
+        issues.push({
+          level: "warning",
+          file: note.filepath,
+          message: `Broken wikilink: [[${link.target}]]`
+        });
+      }
+    }
+  }
+  const slugMap = /* @__PURE__ */ new Map();
+  for (const note of notes) {
+    const existing = slugMap.get(note.slug) ?? [];
+    existing.push(note.filepath);
+    slugMap.set(note.slug, existing);
+  }
+  for (const [slug, files] of slugMap) {
+    if (files.length > 1) {
+      issues.push({
+        level: "warning",
+        file: files.join(", "),
+        message: `Duplicate slug "${slug}" found in multiple locations`
+      });
+    }
+  }
+  const idMap = /* @__PURE__ */ new Map();
+  for (const note of notes) {
+    if (!note.frontmatter.id) continue;
+    const existing = idMap.get(note.frontmatter.id) ?? [];
+    existing.push(note.filepath);
+    idMap.set(note.frontmatter.id, existing);
+  }
+  for (const [id, files] of idMap) {
+    if (files.length > 1) {
+      issues.push({
+        level: "error",
+        file: files.join(", "),
+        message: `Duplicate note ID "${id}"`
+      });
+    }
+  }
+  for (const note of notes) {
+    const typeConfig = config.note_types[note.frontmatter.type];
+    if (!typeConfig) continue;
+    const lineCount = note.body.split("\n").length;
+    if (typeConfig.line_limit && lineCount > typeConfig.line_limit) {
+      issues.push({
+        level: typeConfig.warn_only ? "warning" : "error",
+        file: note.filepath,
+        message: `Note has ${lineCount} lines, exceeds limit of ${typeConfig.line_limit} for type "${note.frontmatter.type}". Consider splitting into smaller notes with [[wikilinks]].`
+      });
+    }
+  }
+  const hasIncoming = /* @__PURE__ */ new Set();
+  const hasOutgoing = /* @__PURE__ */ new Set();
+  for (const note of notes) {
+    const links = parseWikilinks(note.body);
+    if (links.length > 0) hasOutgoing.add(note.slug);
+    const resolved = resolveWikilinks(links, notes);
+    for (const link of resolved) {
+      if (link.resolved_slug) hasIncoming.add(link.resolved_slug);
+    }
+  }
+  for (const note of notes) {
+    if (!hasIncoming.has(note.slug) && !hasOutgoing.has(note.slug)) {
+      issues.push({
+        level: "info",
+        file: note.filepath,
+        message: "Orphan note: no incoming or outgoing links"
+      });
+    }
+  }
+  return issues;
+}
+
+// src/commands/doctor.ts
+function doctorCommand() {
+  const vaultRoot = requireVaultRoot();
+  const config = loadConfig(vaultRoot);
+  const db = ensureIndex(vaultRoot, config);
+  const issues = runDoctor(vaultRoot, config, db);
+  db.close();
+  if (issues.length === 0) {
+    console.log("No issues found. Vault is healthy.");
+    return;
+  }
+  const errors = issues.filter((i) => i.level === "error");
+  const warnings = issues.filter((i) => i.level === "warning");
+  const infos = issues.filter((i) => i.level === "info");
+  const print = (label, items) => {
+    if (items.length === 0) return;
+    console.log(`
+${label}:`);
+    for (const i of items) {
+      const file = i.file.replace(vaultRoot + "/", "");
+      console.log(`  ${file}: ${i.message}`);
+    }
+  };
+  print("Errors", errors);
+  print("Warnings", warnings);
+  print("Info", infos);
+  console.log(`
+${errors.length} error(s), ${warnings.length} warning(s), ${infos.length} info(s)`);
+  if (errors.length > 0) process.exit(1);
+}
+
+// src/web/server.ts
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import path7 from "path";
+import fs9 from "fs";
+function createApp(vaultRoot, config) {
+  const app = new Hono();
+  app.get("/api/notes", (c) => {
+    const db = ensureIndex(vaultRoot, config);
+    const typeFilter = c.req.query("type");
+    let query = "SELECT slug, title, type, created, modified, tags FROM notes";
+    const params = [];
+    if (typeFilter) {
+      query += " WHERE type = ?";
+      params.push(typeFilter);
+    }
+    query += " ORDER BY modified DESC";
+    const notes = db.prepare(query).all(...params);
+    db.close();
+    return c.json({ notes });
+  });
+  app.get("/api/notes/:slug", (c) => {
+    const slug = c.req.param("slug");
+    const db = ensureIndex(vaultRoot, config);
+    const allNotes = listNotes(vaultRoot, config);
+    const note = findNoteBySlug(vaultRoot, config, slug);
+    if (!note) {
+      db.close();
+      return c.json({ error: "Note not found" }, 404);
+    }
+    const links = parseWikilinks(note.body);
+    const resolvedLinks = resolveWikilinks(links, allNotes);
+    const backlinks = getBacklinks(db, slug);
+    db.close();
+    return c.json({
+      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,
+      outgoing_links: resolvedLinks,
+      backlinks
+    });
+  });
+  app.get("/api/search", (c) => {
+    const q = c.req.query("q");
+    if (!q) return c.json({ query: "", results: [] });
+    const db = ensureIndex(vaultRoot, config);
+    const results = searchNotes(db, q);
+    db.close();
+    return c.json({ query: q, results });
+  });
+  app.get("/api/backlinks/:slug", (c) => {
+    const slug = c.req.param("slug");
+    const db = ensureIndex(vaultRoot, config);
+    const backlinks = getBacklinks(db, slug);
+    db.close();
+    return c.json({ slug, backlinks });
+  });
+  app.get("/api/types", (c) => {
+    return c.json({ types: config.note_types });
+  });
+  app.post("/api/notes", async (c) => {
+    const body = await c.req.json();
+    const { type, title, body: noteBody } = body;
+    if (!type || !title) {
+      return c.json({ error: "type and title are required" }, 400);
+    }
+    try {
+      const note = createNote(vaultRoot, config, type, title, noteBody || void 0);
+      return c.json({
+        slug: note.slug,
+        title: note.frontmatter.title,
+        type: note.frontmatter.type,
+        created: note.frontmatter.created
+      });
+    } catch (err) {
+      return c.json({ error: err.message }, 400);
+    }
+  });
+  app.get("/api/graph", (c) => {
+    const db = ensureIndex(vaultRoot, config);
+    const nodes = db.prepare("SELECT slug, title, type FROM notes").all();
+    const edges = db.prepare("SELECT source_slug AS source, target_slug AS target FROM links WHERE target_slug IS NOT NULL").all();
+    db.close();
+    return c.json({ nodes, edges });
+  });
+  const publicDir = path7.join(import.meta.dirname, "public");
+  app.get("/*", (c) => {
+    const reqPath = c.req.path === "/" ? "/index.html" : c.req.path;
+    const filePath = path7.join(publicDir, reqPath);
+    if (!fs9.existsSync(filePath)) {
+      const indexPath = path7.join(publicDir, "index.html");
+      const html = fs9.readFileSync(indexPath, "utf-8");
+      return c.html(html);
+    }
+    const content = fs9.readFileSync(filePath);
+    const ext = path7.extname(filePath);
+    const mimeTypes = {
+      ".html": "text/html",
+      ".css": "text/css",
+      ".js": "application/javascript",
+      ".json": "application/json",
+      ".png": "image/png",
+      ".svg": "image/svg+xml"
+    };
+    const contentType = mimeTypes[ext] || "application/octet-stream";
+    return new Response(content, { headers: { "Content-Type": contentType } });
+  });
+  return app;
+}
+function startServer(vaultRoot, config, port) {
+  const app = createApp(vaultRoot, config);
+  console.log(`Granite \u2014 serving vault at http://localhost:${port}`);
+  console.log(`Vault: ${vaultRoot}`);
+  console.log("");
+  serve({ fetch: app.fetch, port });
+}
+
+// src/commands/serve.ts
+function serveCommand(options) {
+  const vaultRoot = requireVaultRoot();
+  const config = loadConfig(vaultRoot);
+  const port = parseInt(process.env.PORT || options.port, 10) || 4321;
+  startServer(vaultRoot, config, port);
+}
+
+// src/commands/types.ts
+function typesCommand() {
+  const vaultRoot = requireVaultRoot();
+  const config = loadConfig(vaultRoot);
+  console.log("Available note types:\n");
+  for (const [name, tc] of Object.entries(config.note_types)) {
+    console.log(`  ${name}`);
+    console.log(`    ${tc.description}`);
+    console.log(`    folder: ${tc.folder}  |  limit: ${tc.line_limit} lines`);
+    if (tc.instructions) {
+      console.log(`    guide: ${tc.instructions}`);
+    }
+    console.log("");
+  }
+  console.log(`Default type: ${config.defaults.note_type}`);
+  console.log(`
+Usage: mem new <type> <title>`);
+}
+
+// src/commands/list.ts
+function listCommand(options) {
+  const vaultRoot = requireVaultRoot();
+  const config = loadConfig(vaultRoot);
+  let notes = listNotes(vaultRoot, config);
+  if (options.type) {
+    notes = notes.filter((n) => n.frontmatter.type === options.type);
+  }
+  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
+    }));
+    console.log(jsonSuccess(out));
+    return;
+  }
+  if (notes.length === 0) {
+    console.log("No notes found.");
+    return;
+  }
+  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})`);
+  }
+  console.log(`
+${notes.length} note(s)`);
+}
+
+// src/commands/edit.ts
+import fs10 from "fs";
+import { execSync as execSync2 } from "child_process";
+function editCommand(slug, options) {
+  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 hasFlags = options.body !== void 0 || options.append !== void 0 || options.title !== void 0 || options.tag !== void 0 || options.alias !== void 0;
+  if (hasFlags) {
+    let { frontmatter, body } = parseFrontmatter(fs10.readFileSync(note.filepath, "utf-8"));
+    if (options.title) {
+      frontmatter.title = options.title;
+    }
+    if (options.tag) {
+      const newTags = options.tag.split(",").map((t) => t.trim()).filter(Boolean);
+      const existing = new Set(frontmatter.tags);
+      for (const t of newTags) existing.add(t);
+      frontmatter.tags = [...existing];
+    }
+    if (options.alias) {
+      const newAliases = options.alias.split(",").map((a) => a.trim()).filter(Boolean);
+      const existing = new Set(frontmatter.aliases);
+      for (const a of newAliases) existing.add(a);
+      frontmatter.aliases = [...existing];
+    }
+    if (options.body !== void 0) {
+      body = options.body + "\n";
+    }
+    if (options.append !== void 0) {
+      body = body.trimEnd() + "\n" + options.append + "\n";
+    }
+    frontmatter.modified = (/* @__PURE__ */ new Date()).toISOString();
+    fs10.writeFileSync(note.filepath, serializeFrontmatter(frontmatter, body), "utf-8");
+    console.log(note.filepath);
+  } else {
+    const editor = process.env.EDITOR || "vi";
+    const statBefore = fs10.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;
+    if (statAfter !== statBefore) {
+      const { frontmatter, body } = parseFrontmatter(fs10.readFileSync(note.filepath, "utf-8"));
+      frontmatter.modified = (/* @__PURE__ */ new Date()).toISOString();
+      fs10.writeFileSync(note.filepath, serializeFrontmatter(frontmatter, body), "utf-8");
+      console.log(`Updated: ${note.filepath}`);
+    }
+  }
+}
+
+// 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("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) => {
+  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) => {
+  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) => {
+  editCommand(slug, options);
+});
+program.command("open").description("Open a note in your editor (alias for edit)").argument("<slug>", "Note slug").action((slug) => {
+  openNote(slug);
+});
+program.command("show").alias("cat").description("Display a note by slug").argument("<slug>", "Note slug").option("--json", "Output as JSON (agent-friendly)").option("--body", "Output body only (no frontmatter)").action((slug, options) => {
+  showCommand(slug, options);
+});
+program.command("search").description("Full-text search across notes").argument("<query>", "Search query").option("--json", "Output as JSON (agent-friendly)").action((query, options) => {
+  searchCommand(query, options);
+});
+program.command("backlinks").description("Show notes that link to a given note").argument("<slug>", "Note slug").option("--json", "Output as JSON (agent-friendly)").action((slug, options) => {
+  backlinksCommand(slug, options);
+});
+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("types").description("List available note types").action(() => {
+  typesCommand();
+});
+program.command("doctor").description("Validate vault health").action(() => {
+  doctorCommand();
+});
+program.command("serve").description("Start the local web UI").option("-p, --port <port>", "Port number", "4321").action((options) => {
+  serveCommand(options);
+});
+program.parse();