@memories.sh/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2899 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command as Command21 } from "commander";
+
+// src/commands/init.ts
+import { Command } from "commander";
+import chalk from "chalk";
+
+// src/lib/db.ts
+import { createClient } from "@libsql/client";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+function resolveConfigDir() {
+  return process.env.MEMORIES_DATA_DIR ?? join(homedir(), ".config", "memories");
+}
+function getConfigDir() {
+  return resolveConfigDir();
+}
+function getDbPath() {
+  return join(resolveConfigDir(), "local.db");
+}
+function getSyncConfigPath() {
+  return join(resolveConfigDir(), "sync.json");
+}
+var client;
+async function getDb() {
+  if (client) return client;
+  const configDir = resolveConfigDir();
+  const dbPath = getDbPath();
+  await mkdir(configDir, { recursive: true });
+  const sync = await readSyncConfig();
+  if (sync) {
+    client = createClient({
+      url: `file:${dbPath}`,
+      syncUrl: sync.syncUrl,
+      authToken: sync.syncToken
+    });
+    await runMigrations(client);
+    await client.sync();
+  } else {
+    client = createClient({ url: `file:${dbPath}` });
+    await runMigrations(client);
+  }
+  return client;
+}
+function resetDb() {
+  client?.close();
+  client = void 0;
+}
+async function syncDb() {
+  const db = await getDb();
+  await db.sync();
+}
+async function saveSyncConfig(config) {
+  const configDir = resolveConfigDir();
+  await mkdir(configDir, { recursive: true });
+  await writeFile(getSyncConfigPath(), JSON.stringify(config, null, 2), "utf-8");
+}
+async function readSyncConfig() {
+  const syncPath = getSyncConfigPath();
+  if (!existsSync(syncPath)) return null;
+  const raw = await readFile(syncPath, "utf-8");
+  return JSON.parse(raw);
+}
+async function runMigrations(db) {
+  await db.execute(
+    `CREATE TABLE IF NOT EXISTS memories (
+      id TEXT PRIMARY KEY,
+      content TEXT NOT NULL,
+      tags TEXT,
+      scope TEXT NOT NULL DEFAULT 'global',
+      project_id TEXT,
+      type TEXT NOT NULL DEFAULT 'note',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      deleted_at TEXT
+    )`
+  );
+  try {
+    await db.execute(`ALTER TABLE memories ADD COLUMN scope TEXT NOT NULL DEFAULT 'global'`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE memories ADD COLUMN project_id TEXT`);
+  } catch {
+  }
+  try {
+    await db.execute(`ALTER TABLE memories ADD COLUMN type TEXT NOT NULL DEFAULT 'note'`);
+  } catch {
+  }
+  await db.execute(
+    `CREATE TABLE IF NOT EXISTS configs (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    )`
+  );
+  await db.execute(
+    `CREATE TABLE IF NOT EXISTS projects (
+      id TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      path TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now'))
+    )`
+  );
+  await db.execute(
+    `CREATE TABLE IF NOT EXISTS sync_state (
+      id TEXT PRIMARY KEY,
+      last_synced_at TEXT,
+      remote_url TEXT
+    )`
+  );
+  await db.execute(
+    `CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts USING fts5(
+      content,
+      tags,
+      content='memories',
+      content_rowid='rowid'
+    )`
+  );
+  await db.execute(`DROP TRIGGER IF EXISTS memories_ai`);
+  await db.execute(`DROP TRIGGER IF EXISTS memories_ad`);
+  await db.execute(`DROP TRIGGER IF EXISTS memories_au`);
+  await db.execute(`
+    CREATE TRIGGER memories_ai AFTER INSERT ON memories
+    WHEN NEW.deleted_at IS NULL
+    BEGIN
+      INSERT INTO memories_fts(rowid, content, tags) VALUES (NEW.rowid, NEW.content, NEW.tags);
+    END
+  `);
+  await db.execute(`
+    CREATE TRIGGER memories_ad AFTER DELETE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, content, tags) VALUES('delete', OLD.rowid, OLD.content, OLD.tags);
+    END
+  `);
+  await db.execute(`
+    CREATE TRIGGER memories_au AFTER UPDATE ON memories BEGIN
+      INSERT INTO memories_fts(memories_fts, rowid, content, tags) VALUES('delete', OLD.rowid, OLD.content, OLD.tags);
+      INSERT INTO memories_fts(rowid, content, tags)
+        SELECT NEW.rowid, NEW.content, NEW.tags WHERE NEW.deleted_at IS NULL;
+    END
+  `);
+  try {
+    await db.execute(`CREATE INDEX IF NOT EXISTS idx_memories_type ON memories(type)`);
+  } catch {
+  }
+  try {
+    await db.execute(`CREATE INDEX IF NOT EXISTS idx_memories_scope_project ON memories(scope, project_id)`);
+  } catch {
+  }
+}
+
+// src/lib/git.ts
+import { execSync } from "child_process";
+function getGitRemoteUrl(cwd) {
+  try {
+    const remote = execSync("git remote get-url origin", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return remote || null;
+  } catch {
+    return null;
+  }
+}
+function getGitRoot(cwd) {
+  try {
+    const root = execSync("git rev-parse --show-toplevel", {
+      cwd,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return root || null;
+  } catch {
+    return null;
+  }
+}
+function normalizeGitUrl(url) {
+  let normalized = url.trim();
+  if (normalized.endsWith(".git")) {
+    normalized = normalized.slice(0, -4);
+  }
+  const sshMatch = normalized.match(/^git@([^:]+):(.+)$/);
+  if (sshMatch) {
+    return `${sshMatch[1]}/${sshMatch[2]}`;
+  }
+  const httpsMatch = normalized.match(/^https?:\/\/([^/]+)\/(.+)$/);
+  if (httpsMatch) {
+    return `${httpsMatch[1]}/${httpsMatch[2]}`;
+  }
+  return normalized;
+}
+function getProjectId(cwd) {
+  const remoteUrl = getGitRemoteUrl(cwd);
+  if (!remoteUrl) return null;
+  return normalizeGitUrl(remoteUrl);
+}
+
+// src/lib/memory.ts
+import { nanoid } from "nanoid";
+async function addMemory(content, opts) {
+  const db = await getDb();
+  const id = nanoid(12);
+  const tags = opts?.tags?.length ? opts.tags.join(",") : null;
+  const type = opts?.type ?? "note";
+  let scope = "global";
+  let projectId = null;
+  if (!opts?.global) {
+    projectId = opts?.projectId ?? getProjectId();
+    if (projectId) {
+      scope = "project";
+    }
+  }
+  await db.execute({
+    sql: `INSERT INTO memories (id, content, tags, scope, project_id, type) VALUES (?, ?, ?, ?, ?, ?)`,
+    args: [id, content, tags, scope, projectId, type]
+  });
+  const result = await db.execute({
+    sql: `SELECT * FROM memories WHERE id = ?`,
+    args: [id]
+  });
+  return result.rows[0];
+}
+async function searchMemories(query, opts) {
+  const db = await getDb();
+  const limit = opts?.limit ?? 20;
+  const includeGlobal = opts?.includeGlobal ?? true;
+  const projectId = opts?.globalOnly ? void 0 : opts?.projectId ?? getProjectId();
+  const scopeConditions = [];
+  const args = [];
+  if (includeGlobal) {
+    scopeConditions.push("m.scope = 'global'");
+  }
+  if (projectId) {
+    scopeConditions.push("(m.scope = 'project' AND m.project_id = ?)");
+    args.push(projectId);
+  }
+  if (scopeConditions.length === 0) {
+    return [];
+  }
+  let typeFilter = "";
+  if (opts?.types?.length) {
+    const placeholders = opts.types.map(() => "?").join(", ");
+    typeFilter = `AND m.type IN (${placeholders})`;
+    args.push(...opts.types);
+  }
+  const ftsQuery = query.split(/\s+/).filter(Boolean).map((term) => `"${term}"*`).join(" OR ");
+  args.push(limit);
+  try {
+    const result = await db.execute({
+      sql: `
+        SELECT m.*, bm25(memories_fts) as rank
+        FROM memories m
+        JOIN memories_fts fts ON m.rowid = fts.rowid
+        WHERE memories_fts MATCH ?
+          AND m.deleted_at IS NULL
+          AND (${scopeConditions.join(" OR ")})
+          ${typeFilter}
+        ORDER BY rank ASC, m.created_at DESC
+        LIMIT ?
+      `,
+      args: [ftsQuery, ...args]
+    });
+    return result.rows;
+  } catch (error) {
+    console.error("FTS search failed, falling back to LIKE:", error);
+    return searchMemoriesLike(query, opts);
+  }
+}
+async function searchMemoriesLike(query, opts) {
+  const db = await getDb();
+  const limit = opts?.limit ?? 20;
+  const includeGlobal = opts?.includeGlobal ?? true;
+  const projectId = opts?.globalOnly ? void 0 : opts?.projectId ?? getProjectId();
+  const conditions = ["deleted_at IS NULL", "content LIKE ?"];
+  const args = [`%${query}%`];
+  const scopeConditions = [];
+  if (includeGlobal) {
+    scopeConditions.push("scope = 'global'");
+  }
+  if (projectId) {
+    scopeConditions.push("(scope = 'project' AND project_id = ?)");
+    args.push(projectId);
+  }
+  if (scopeConditions.length === 0) {
+    return [];
+  }
+  conditions.push(`(${scopeConditions.join(" OR ")})`);
+  if (opts?.types?.length) {
+    const placeholders = opts.types.map(() => "?").join(", ");
+    conditions.push(`type IN (${placeholders})`);
+    args.push(...opts.types);
+  }
+  args.push(limit);
+  const result = await db.execute({
+    sql: `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY created_at DESC LIMIT ?`,
+    args
+  });
+  return result.rows;
+}
+async function listMemories(opts) {
+  const db = await getDb();
+  const limit = opts?.limit ?? 50;
+  const includeGlobal = opts?.includeGlobal ?? true;
+  const projectId = opts?.globalOnly ? void 0 : opts?.projectId ?? getProjectId();
+  const conditions = ["deleted_at IS NULL"];
+  const args = [];
+  const scopeConditions = [];
+  if (includeGlobal) {
+    scopeConditions.push("scope = 'global'");
+  }
+  if (projectId) {
+    scopeConditions.push("(scope = 'project' AND project_id = ?)");
+    args.push(projectId);
+  }
+  if (scopeConditions.length === 0) {
+    return [];
+  }
+  conditions.push(`(${scopeConditions.join(" OR ")})`);
+  if (opts?.tags?.length) {
+    const tagClauses = opts.tags.map(() => `tags LIKE ?`).join(" OR ");
+    conditions.push(`(${tagClauses})`);
+    args.push(...opts.tags.map((t) => `%${t}%`));
+  }
+  if (opts?.types?.length) {
+    const placeholders = opts.types.map(() => "?").join(", ");
+    conditions.push(`type IN (${placeholders})`);
+    args.push(...opts.types);
+  }
+  args.push(limit);
+  const result = await db.execute({
+    sql: `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY type ASC, scope ASC, created_at DESC LIMIT ?`,
+    args
+  });
+  return result.rows;
+}
+async function getRules(opts) {
+  const db = await getDb();
+  const projectId = opts?.projectId ?? getProjectId();
+  const conditions = ["deleted_at IS NULL", "type = 'rule'"];
+  const args = [];
+  const scopeConditions = ["scope = 'global'"];
+  if (projectId) {
+    scopeConditions.push("(scope = 'project' AND project_id = ?)");
+    args.push(projectId);
+  }
+  conditions.push(`(${scopeConditions.join(" OR ")})`);
+  const result = await db.execute({
+    sql: `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY scope ASC, created_at ASC`,
+    args
+  });
+  return result.rows;
+}
+async function getContext(query, opts) {
+  const projectId = opts?.projectId ?? getProjectId();
+  const limit = opts?.limit ?? 10;
+  const rules = await getRules({ projectId: projectId ?? void 0 });
+  let memories = [];
+  if (query) {
+    memories = await searchMemories(query, {
+      projectId: projectId ?? void 0,
+      limit,
+      types: ["decision", "fact", "note"]
+      // Exclude rules, they're already included
+    });
+  }
+  return { rules, memories };
+}
+async function updateMemory(id, updates) {
+  const db = await getDb();
+  const existing = await db.execute({
+    sql: `SELECT * FROM memories WHERE id = ? AND deleted_at IS NULL`,
+    args: [id]
+  });
+  if (existing.rows.length === 0) return null;
+  const setClauses = ["updated_at = datetime('now')"];
+  const args = [];
+  if (updates.content !== void 0) {
+    setClauses.push("content = ?");
+    args.push(updates.content);
+  }
+  if (updates.tags !== void 0) {
+    setClauses.push("tags = ?");
+    args.push(updates.tags.length ? updates.tags.join(",") : null);
+  }
+  if (updates.type !== void 0) {
+    setClauses.push("type = ?");
+    args.push(updates.type);
+  }
+  args.push(id);
+  await db.execute({
+    sql: `UPDATE memories SET ${setClauses.join(", ")} WHERE id = ?`,
+    args
+  });
+  const result = await db.execute({
+    sql: `SELECT * FROM memories WHERE id = ?`,
+    args: [id]
+  });
+  return result.rows[0];
+}
+async function forgetMemory(id) {
+  const db = await getDb();
+  const existing = await db.execute({
+    sql: `SELECT id FROM memories WHERE id = ? AND deleted_at IS NULL`,
+    args: [id]
+  });
+  if (existing.rows.length === 0) return false;
+  await db.execute({
+    sql: `UPDATE memories SET deleted_at = datetime('now') WHERE id = ?`,
+    args: [id]
+  });
+  return true;
+}
+async function findMemoriesToForget(filter) {
+  const db = await getDb();
+  const conditions = ["deleted_at IS NULL"];
+  const args = [];
+  if (filter.types?.length) {
+    const placeholders = filter.types.map(() => "?").join(", ");
+    conditions.push(`type IN (${placeholders})`);
+    args.push(...filter.types);
+  }
+  if (filter.tags?.length) {
+    const tagClauses = filter.tags.map(() => `tags LIKE ?`).join(" OR ");
+    conditions.push(`(${tagClauses})`);
+    args.push(...filter.tags.map((t) => `%${t}%`));
+  }
+  if (filter.olderThanDays !== void 0) {
+    conditions.push(`created_at < datetime('now', ?)`);
+    args.push(`-${filter.olderThanDays} days`);
+  }
+  if (filter.pattern) {
+    const likePattern = filter.pattern.replace(/%/g, "\\%").replace(/_/g, "\\_").replace(/\*/g, "%").replace(/\?/g, "_");
+    conditions.push(`content LIKE ? ESCAPE '\\'`);
+    args.push(`%${likePattern}%`);
+  }
+  if (filter.projectId) {
+    conditions.push("(scope = 'project' AND project_id = ?)");
+    args.push(filter.projectId);
+  }
+  const result = await db.execute({
+    sql: `SELECT * FROM memories WHERE ${conditions.join(" AND ")} ORDER BY created_at DESC`,
+    args
+  });
+  return result.rows;
+}
+async function bulkForgetByIds(ids) {
+  if (ids.length === 0) return 0;
+  const db = await getDb();
+  const batchSize = 500;
+  for (let i = 0; i < ids.length; i += batchSize) {
+    const batch = ids.slice(i, i + batchSize);
+    const placeholders = batch.map(() => "?").join(", ");
+    await db.execute({
+      sql: `UPDATE memories SET deleted_at = datetime('now') WHERE id IN (${placeholders})`,
+      args: batch
+    });
+  }
+  return ids.length;
+}
+
+// src/commands/init.ts
+var initCommand = new Command("init").description("Initialize memories for the current project or globally").option("-g, --global", "Initialize global memories (user-wide)").option("-r, --rule <rule>", "Add an initial rule", (val, acc) => [...acc, val], []).action(async (opts) => {
+  try {
+    await getDb();
+    const configDir = getConfigDir();
+    if (opts.global) {
+      console.log(chalk.green("\u2713") + " Initialized global memories");
+      console.log(chalk.dim(`  Database: ${configDir}/local.db`));
+    } else {
+      const projectId = getProjectId();
+      const gitRoot = getGitRoot();
+      if (!projectId) {
+        console.log(chalk.yellow("\u26A0") + " Not in a git repository.");
+        console.log(chalk.dim("  Run from a git repo for project-scoped memories, or use --global"));
+        return;
+      }
+      console.log(chalk.green("\u2713") + " Initialized project memories");
+      console.log(chalk.dim(`  Project: ${projectId}`));
+      console.log(chalk.dim(`  Root: ${gitRoot}`));
+      console.log(chalk.dim(`  Database: ${configDir}/local.db`));
+    }
+    if (opts.rule?.length) {
+      console.log("");
+      console.log(chalk.blue("Adding rules:"));
+      for (const rule of opts.rule) {
+        const memory = await addMemory(rule, {
+          type: "rule",
+          global: opts.global
+        });
+        console.log(chalk.dim(`  ${memory.id}: ${rule}`));
+      }
+    }
+    console.log("");
+    console.log(chalk.dim("Quick start:"));
+    console.log(chalk.dim(`  memories add "Your first memory"`));
+    console.log(chalk.dim(`  memories add --rule "Always use TypeScript strict mode"`));
+    console.log(chalk.dim(`  memories recall "what are my coding preferences"`));
+  } catch (error) {
+    console.error(chalk.red("\u2717") + " Failed to initialize:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/add.ts
+import { Command as Command2 } from "commander";
+import chalk2 from "chalk";
+var VALID_TYPES = ["rule", "decision", "fact", "note"];
+var addCommand = new Command2("add").description("Add a new memory").argument("<content>", "Memory content").option("-t, --tags <tags>", "Comma-separated tags").option("-g, --global", "Store as global memory (default: project-scoped if in git repo)").option("--type <type>", "Memory type: rule, decision, fact, note (default: note)").option("-r, --rule", "Shorthand for --type rule").option("-d, --decision", "Shorthand for --type decision").option("-f, --fact", "Shorthand for --type fact").action(async (content, opts) => {
+  try {
+    const tags = opts.tags?.split(",").map((t) => t.trim());
+    let type = "note";
+    if (opts.rule) type = "rule";
+    else if (opts.decision) type = "decision";
+    else if (opts.fact) type = "fact";
+    else if (opts.type) {
+      if (!VALID_TYPES.includes(opts.type)) {
+        console.error(chalk2.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES.join(", ")}`);
+        process.exit(1);
+      }
+      type = opts.type;
+    }
+    const memory = await addMemory(content, { tags, global: opts.global, type });
+    const typeIcon = type === "rule" ? "\u{1F4CC}" : type === "decision" ? "\u{1F4A1}" : type === "fact" ? "\u{1F4CB}" : "\u{1F4DD}";
+    const scopeInfo = memory.scope === "global" ? chalk2.dim("(global)") : chalk2.dim(`(project)`);
+    console.log(chalk2.green("\u2713") + ` ${typeIcon} Stored ${type} ${chalk2.dim(memory.id)} ${scopeInfo}`);
+  } catch (error) {
+    console.error(chalk2.red("\u2717") + " Failed to add memory:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/recall.ts
+import { Command as Command3 } from "commander";
+import chalk3 from "chalk";
+var TYPE_ICONS = {
+  rule: "\u{1F4CC}",
+  decision: "\u{1F4A1}",
+  fact: "\u{1F4CB}",
+  note: "\u{1F4DD}"
+};
+var TYPE_COLORS = {
+  rule: chalk3.yellow,
+  decision: chalk3.cyan,
+  fact: chalk3.green,
+  note: chalk3.white
+};
+function formatMemory(m, verbose) {
+  const icon = TYPE_ICONS[m.type] || "\u{1F4DD}";
+  const colorFn = TYPE_COLORS[m.type] || chalk3.white;
+  const scope = m.scope === "global" ? chalk3.dim("G") : chalk3.dim("P");
+  const tags = m.tags ? chalk3.dim(` [${m.tags}]`) : "";
+  if (verbose) {
+    return `${icon} ${scope} ${chalk3.dim(m.id)} ${colorFn(m.content)}${tags}`;
+  }
+  return `${icon} ${colorFn(m.content)}`;
+}
+var recallCommand = new Command3("recall").description("Recall context - get rules and relevant memories for AI agents").argument("[query]", "Optional search query to find relevant memories").option("-l, --limit <n>", "Max memories to return (excludes rules)", "10").option("-r, --rules-only", "Only return rules").option("-v, --verbose", "Show memory IDs and metadata").option("--json", "Output as JSON (for programmatic use)").action(async (query, opts) => {
+  try {
+    const projectId = getProjectId();
+    if (opts.rulesOnly) {
+      const rules2 = await getRules({ projectId: projectId ?? void 0 });
+      if (opts.json) {
+        console.log(JSON.stringify({ rules: rules2 }, null, 2));
+        return;
+      }
+      if (rules2.length === 0) {
+        console.log(chalk3.dim("No rules defined."));
+        console.log(chalk3.dim('Add one with: memories add --rule "Your rule here"'));
+        return;
+      }
+      console.log(chalk3.bold("Rules:"));
+      for (const rule of rules2) {
+        console.log(formatMemory(rule, opts.verbose ?? false));
+      }
+      return;
+    }
+    const { rules, memories } = await getContext(query, {
+      projectId: projectId ?? void 0,
+      limit: parseInt(opts.limit, 10)
+    });
+    if (opts.json) {
+      console.log(JSON.stringify({ rules, memories }, null, 2));
+      return;
+    }
+    if (rules.length > 0) {
+      console.log(chalk3.bold("Rules:"));
+      for (const rule of rules) {
+        console.log(formatMemory(rule, opts.verbose ?? false));
+      }
+      console.log("");
+    }
+    if (memories.length > 0) {
+      console.log(chalk3.bold(query ? `Relevant to "${query}":` : "Recent memories:"));
+      for (const m of memories) {
+        console.log(formatMemory(m, opts.verbose ?? false));
+      }
+    } else if (query) {
+      console.log(chalk3.dim(`No memories found matching "${query}"`));
+    }
+    if (rules.length === 0 && memories.length === 0) {
+      console.log(chalk3.dim("No memories found."));
+      console.log(chalk3.dim('Add some with: memories add "Your memory here"'));
+    }
+  } catch (error) {
+    console.error(chalk3.red("\u2717") + " Failed to recall:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/prompt.ts
+import { Command as Command4 } from "commander";
+import { execFileSync } from "child_process";
+import chalk4 from "chalk";
+var VALID_TYPES2 = ["rule", "decision", "fact", "note"];
+function formatMarkdown(sections) {
+  return sections.map(({ title, memories }) => {
+    const items = memories.map((m) => `- ${m.content}`).join("\n");
+    return `## ${title}
+
+${items}`;
+  }).join("\n\n");
+}
+function formatXml(sections) {
+  return sections.map(({ title, memories }) => {
+    const tag = title.toLowerCase().replace(/\s+/g, "-");
+    const items = memories.map((m) => `  <item>${m.content}</item>`).join("\n");
+    return `<${tag}>
+${items}
+</${tag}>`;
+  }).join("\n");
+}
+function formatPlain(sections) {
+  return sections.flatMap(({ memories }) => memories.map((m) => m.content)).join("\n");
+}
+function copyToClipboard(text) {
+  try {
+    const platform = process.platform;
+    if (platform === "darwin") {
+      execFileSync("pbcopy", [], { input: text });
+    } else if (platform === "linux") {
+      execFileSync("xclip", ["-selection", "clipboard"], { input: text });
+    } else if (platform === "win32") {
+      execFileSync("clip", [], { input: text });
+    } else {
+      return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+var promptCommand = new Command4("prompt").description("Output memories formatted for AI system prompts").option("-f, --format <format>", "Output format: markdown, xml, plain (default: markdown)").option("-i, --include <types>", "Include additional types: decisions,facts,notes (comma-separated)").option("-a, --all", "Include all memory types").option("-c, --copy", "Copy output to clipboard").option("-q, --quiet", "No stderr status messages (just the prompt)").action(async (opts) => {
+  try {
+    const format = opts.format ?? "markdown";
+    if (!["markdown", "xml", "plain"].includes(format)) {
+      console.error(chalk4.red("\u2717") + ` Invalid format "${opts.format}". Use: markdown, xml, plain`);
+      process.exit(1);
+    }
+    const projectId = getProjectId() ?? void 0;
+    const rules = await getRules({ projectId });
+    const extraTypes = [];
+    if (opts.all) {
+      extraTypes.push("decision", "fact", "note");
+    } else if (opts.include) {
+      for (const t of opts.include.split(",").map((s) => s.trim())) {
+        const normalized = t.replace(/s$/, "");
+        if (!VALID_TYPES2.includes(normalized)) {
+          console.error(chalk4.red("\u2717") + ` Invalid type "${t}". Valid: decisions, facts, notes`);
+          process.exit(1);
+        }
+        if (normalized !== "rule") extraTypes.push(normalized);
+      }
+    }
+    const sections = [];
+    if (rules.length > 0) {
+      const globalRules = rules.filter((r) => r.scope === "global");
+      const projectRules = rules.filter((r) => r.scope === "project");
+      if (globalRules.length > 0 && projectRules.length > 0) {
+        sections.push({ title: "Global Rules", memories: globalRules });
+        sections.push({ title: "Project Rules", memories: projectRules });
+      } else {
+        sections.push({ title: "Rules", memories: rules });
+      }
+    }
+    for (const type of extraTypes) {
+      const memories = await listMemories({
+        types: [type],
+        projectId
+      });
+      if (memories.length > 0) {
+        const title = type === "decision" ? "Key Decisions" : type === "fact" ? "Project Facts" : "Notes";
+        sections.push({ title, memories });
+      }
+    }
+    if (sections.length === 0) {
+      if (!opts.quiet) {
+        console.error(chalk4.dim('No memories found. Add rules with: memories add --rule "Your rule"'));
+      }
+      return;
+    }
+    let output;
+    switch (format) {
+      case "xml":
+        output = formatXml(sections);
+        break;
+      case "plain":
+        output = formatPlain(sections);
+        break;
+      default:
+        output = formatMarkdown(sections);
+    }
+    if (opts.copy) {
+      const copied = copyToClipboard(output);
+      if (copied) {
+        console.log(output);
+        if (!opts.quiet) {
+          console.error(chalk4.green("\u2713") + " Copied to clipboard");
+        }
+      } else {
+        console.log(output);
+        if (!opts.quiet) {
+          console.error(chalk4.yellow("\u26A0") + " Could not copy to clipboard (unsupported platform)");
+        }
+      }
+    } else {
+      console.log(output);
+    }
+  } catch (error) {
+    console.error(chalk4.red("\u2717") + " Failed to generate prompt:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/search.ts
+import { Command as Command5 } from "commander";
+import chalk5 from "chalk";
+var TYPE_ICONS2 = {
+  rule: "\u{1F4CC}",
+  decision: "\u{1F4A1}",
+  fact: "\u{1F4CB}",
+  note: "\u{1F4DD}"
+};
+var VALID_TYPES3 = ["rule", "decision", "fact", "note"];
+function formatMemory2(m) {
+  const icon = TYPE_ICONS2[m.type] || "\u{1F4DD}";
+  const scope = m.scope === "global" ? chalk5.dim("G") : chalk5.dim("P");
+  const tags = m.tags ? chalk5.dim(` [${m.tags}]`) : "";
+  return `${icon} ${scope} ${chalk5.dim(m.id)}  ${m.content}${tags}`;
+}
+var searchCommand = new Command5("search").description("Search memories using full-text search").argument("<query>", "Search query").option("-l, --limit <n>", "Max results", "20").option("--type <type>", "Filter by type: rule, decision, fact, note").option("-g, --global", "Search only global memories").option("--project-only", "Search only project memories (exclude global)").option("--json", "Output as JSON").action(async (query, opts) => {
+  try {
+    let types;
+    if (opts.type) {
+      if (!VALID_TYPES3.includes(opts.type)) {
+        console.error(chalk5.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES3.join(", ")}`);
+        process.exit(1);
+      }
+      types = [opts.type];
+    }
+    let globalOnly = false;
+    let includeGlobal = true;
+    let projectId;
+    if (opts.global) {
+      globalOnly = true;
+    } else if (opts.projectOnly) {
+      includeGlobal = false;
+      projectId = getProjectId() ?? void 0;
+      if (!projectId) {
+        console.log(chalk5.yellow("\u26A0") + " Not in a git repository. No project memories to search.");
+        return;
+      }
+    }
+    const memories = await searchMemories(query, {
+      limit: parseInt(opts.limit, 10),
+      types,
+      projectId,
+      includeGlobal,
+      globalOnly
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(memories, null, 2));
+      return;
+    }
+    if (memories.length === 0) {
+      console.log(chalk5.dim(`No memories found matching "${query}"`));
+      return;
+    }
+    console.log(chalk5.bold(`Results for "${query}":`));
+    console.log("");
+    for (const m of memories) {
+      console.log(formatMemory2(m));
+    }
+    console.log(chalk5.dim(`
+${memories.length} results`));
+  } catch (error) {
+    console.error(chalk5.red("\u2717") + " Failed to search:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/list.ts
+import { Command as Command6 } from "commander";
+import chalk6 from "chalk";
+var TYPE_COLORS2 = {
+  rule: chalk6.blue,
+  decision: chalk6.yellow,
+  fact: chalk6.green,
+  note: chalk6.dim
+};
+var TYPE_LABELS = {
+  rule: "rule",
+  decision: "decision",
+  fact: "fact",
+  note: "note"
+};
+var VALID_TYPES4 = ["rule", "decision", "fact", "note"];
+var MAX_CONTENT_WIDTH = 80;
+function truncate(str, max) {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 1) + "\u2026";
+}
+function formatMemory3(m) {
+  const typeColor = TYPE_COLORS2[m.type] ?? chalk6.dim;
+  const typeLabel = typeColor(TYPE_LABELS[m.type].padEnd(9));
+  const scope = m.scope === "global" ? chalk6.magenta("G") : chalk6.cyan("P");
+  const id = chalk6.dim(m.id);
+  const content = truncate(m.content, MAX_CONTENT_WIDTH);
+  const tags = m.tags ? chalk6.dim(` [${m.tags}]`) : "";
+  return `  ${scope} ${typeLabel} ${id}  ${content}${tags}`;
+}
+var listCommand = new Command6("list").description("List memories").option("-l, --limit <n>", "Max results", "50").option("-t, --tags <tags>", "Filter by comma-separated tags").option("--type <type>", "Filter by type: rule, decision, fact, note").option("-g, --global", "Show only global memories").option("--project-only", "Show only project memories (exclude global)").option("--json", "Output as JSON").action(async (opts) => {
+  try {
+    const tags = opts.tags?.split(",").map((t) => t.trim());
+    let types;
+    if (opts.type) {
+      if (!VALID_TYPES4.includes(opts.type)) {
+        console.error(chalk6.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES4.join(", ")}`);
+        process.exit(1);
+      }
+      types = [opts.type];
+    }
+    let globalOnly = false;
+    let includeGlobal = true;
+    let projectId;
+    if (opts.global) {
+      globalOnly = true;
+    } else if (opts.projectOnly) {
+      includeGlobal = false;
+      projectId = getProjectId() ?? void 0;
+      if (!projectId) {
+        console.log(chalk6.yellow("\u26A0") + " Not in a git repository. No project memories to show.");
+        return;
+      }
+    }
+    const memories = await listMemories({
+      limit: parseInt(opts.limit, 10),
+      tags,
+      types,
+      projectId,
+      includeGlobal,
+      globalOnly
+    });
+    if (opts.json) {
+      console.log(JSON.stringify(memories, null, 2));
+      return;
+    }
+    if (memories.length === 0) {
+      console.log(chalk6.dim("No memories found."));
+      return;
+    }
+    const currentProject = getProjectId();
+    if (currentProject && !opts.global) {
+      console.log(chalk6.dim(`  Project: ${currentProject}
+`));
+    }
+    for (const m of memories) {
+      console.log(formatMemory3(m));
+    }
+    console.log(chalk6.dim(`
+  ${memories.length} memories`));
+  } catch (error) {
+    console.error(chalk6.red("\u2717") + " Failed to list memories:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/forget.ts
+import { Command as Command7 } from "commander";
+import { createInterface } from "readline";
+import chalk7 from "chalk";
+var VALID_TYPES5 = ["rule", "decision", "fact", "note"];
+var TYPE_ICONS3 = {
+  rule: "\u{1F4CC}",
+  decision: "\u{1F4A1}",
+  fact: "\u{1F4CB}",
+  note: "\u{1F4DD}"
+};
+async function confirm(message) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve3) => {
+    rl.question(message, (answer) => {
+      rl.close();
+      resolve3(answer.toLowerCase().startsWith("y"));
+    });
+  });
+}
+var forgetCommand = new Command7("forget").description("Soft-delete memories by ID or bulk filter").argument("[id]", "Memory ID to forget (omit for bulk operations)").option("--type <type>", "Forget all memories of this type: rule, decision, fact, note").option("--tag <tag>", "Forget all memories with this tag").option("--older-than <days>", "Forget memories older than N days").option("--pattern <pattern>", "Forget memories matching pattern (use * as wildcard)").option("--all", "Forget ALL memories (requires --force or confirmation)").option("--project-only", "Only forget project-scoped memories").option("--dry-run", "Preview what would be deleted without deleting").option("--force", "Skip confirmation prompt").action(async (id, opts) => {
+  try {
+    if (id) {
+      const deleted = await forgetMemory(id);
+      if (deleted) {
+        console.log(chalk7.green("\u2713") + ` Forgot memory ${chalk7.dim(id)}`);
+      } else {
+        console.error(chalk7.red("\u2717") + ` Memory ${id} not found or already forgotten.`);
+        process.exit(1);
+      }
+      return;
+    }
+    const hasBulkFilter = opts.type || opts.tag || opts.olderThan || opts.pattern || opts.all;
+    if (!hasBulkFilter) {
+      console.error(chalk7.red("\u2717") + " Provide a memory ID or a bulk filter (--type, --tag, --older-than, --pattern, --all)");
+      process.exit(1);
+    }
+    if (opts.all && (opts.type || opts.tag || opts.olderThan || opts.pattern)) {
+      console.error(chalk7.red("\u2717") + " --all cannot be combined with other filters. Use --all alone to delete everything.");
+      process.exit(1);
+    }
+    if (opts.type && !VALID_TYPES5.includes(opts.type)) {
+      console.error(chalk7.red("\u2717") + ` Invalid type "${opts.type}". Valid: ${VALID_TYPES5.join(", ")}`);
+      process.exit(1);
+    }
+    if (opts.olderThan && (isNaN(parseInt(opts.olderThan, 10)) || parseInt(opts.olderThan, 10) <= 0)) {
+      console.error(chalk7.red("\u2717") + " --older-than must be a positive number of days");
+      process.exit(1);
+    }
+    const filter = {
+      types: opts.type ? [opts.type] : void 0,
+      tags: opts.tag ? [opts.tag] : void 0,
+      olderThanDays: opts.olderThan ? parseInt(opts.olderThan, 10) : void 0,
+      pattern: opts.pattern,
+      all: opts.all,
+      projectId: opts.projectOnly ? getProjectId() ?? void 0 : void 0
+    };
+    const matches = await findMemoriesToForget(filter);
+    if (matches.length === 0) {
+      console.log(chalk7.dim("No memories match the filter."));
+      return;
+    }
+    console.log(chalk7.bold(`${matches.length} memories will be forgotten:
+`));
+    for (const m of matches.slice(0, 30)) {
+      const icon = TYPE_ICONS3[m.type] || "\u{1F4DD}";
+      const scope = m.scope === "global" ? chalk7.dim("G") : chalk7.dim("P");
+      console.log(`  ${icon} ${scope} ${chalk7.dim(m.id)}  ${m.content}`);
+    }
+    if (matches.length > 30) {
+      console.log(chalk7.dim(`  ... and ${matches.length - 30} more`));
+    }
+    console.log("");
+    if (opts.dryRun) {
+      console.log(chalk7.yellow("Dry run") + " \u2014 no memories were deleted.");
+      return;
+    }
+    if (!opts.force) {
+      const proceed = await confirm(
+        chalk7.yellow(`Forget ${matches.length} memories? This is a soft-delete. [y/N] `)
+      );
+      if (!proceed) {
+        console.log("Cancelled.");
+        return;
+      }
+    }
+    const ids = matches.map((m) => m.id);
+    const count = await bulkForgetByIds(ids);
+    console.log(chalk7.green("\u2713") + ` Forgot ${count} memories.`);
+  } catch (error) {
+    console.error(chalk7.red("\u2717") + " Failed to forget:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/export.ts
+import { Command as Command8 } from "commander";
+import chalk8 from "chalk";
+import { writeFile as writeFile2 } from "fs/promises";
+var exportCommand = new Command8("export").description("Export memories to JSON or YAML file").option("-o, --output <file>", "Output file path (default: stdout)").option("-f, --format <format>", "Output format: json, yaml (default: json)", "json").option("-g, --global", "Export only global memories").option("--project-only", "Export only project memories").option("--type <type>", "Filter by type: rule, decision, fact, note").action(async (opts) => {
+  try {
+    const projectId = getProjectId();
+    let globalOnly = false;
+    let includeGlobal = true;
+    let queryProjectId;
+    if (opts.global) {
+      globalOnly = true;
+    } else if (opts.projectOnly) {
+      includeGlobal = false;
+      queryProjectId = projectId ?? void 0;
+      if (!queryProjectId) {
+        console.error(chalk8.red("\u2717") + " Not in a git repository. No project memories to export.");
+        process.exit(1);
+      }
+    }
+    const types = opts.type ? [opts.type] : void 0;
+    const memories = await listMemories({
+      limit: 1e4,
+      // Export all
+      types,
+      projectId: queryProjectId,
+      includeGlobal,
+      globalOnly
+    });
+    const exportData = {
+      version: "1.0",
+      exported_at: (/* @__PURE__ */ new Date()).toISOString(),
+      project_id: projectId,
+      memories: memories.map((m) => ({
+        id: m.id,
+        content: m.content,
+        type: m.type,
+        tags: m.tags ? m.tags.split(",") : [],
+        scope: m.scope,
+        created_at: m.created_at
+      }))
+    };
+    let output;
+    if (opts.format === "yaml") {
+      const yaml = await import("yaml");
+      output = yaml.stringify(exportData);
+    } else {
+      output = JSON.stringify(exportData, null, 2);
+    }
+    if (opts.output) {
+      await writeFile2(opts.output, output, "utf-8");
+      console.log(chalk8.green("\u2713") + ` Exported ${memories.length} memories to ${chalk8.dim(opts.output)}`);
+    } else {
+      console.log(output);
+    }
+  } catch (error) {
+    console.error(chalk8.red("\u2717") + " Failed to export:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/import.ts
+import { Command as Command9 } from "commander";
+import chalk9 from "chalk";
+import { readFile as readFile2 } from "fs/promises";
+var importCommand = new Command9("import").description("Import memories from JSON or YAML file").argument("<file>", "Input file path").option("-f, --format <format>", "Input format: json, yaml (auto-detected from extension)").option("-g, --global", "Import all as global memories (override file scope)").option("--dry-run", "Show what would be imported without actually importing").action(async (file, opts) => {
+  try {
+    const content = await readFile2(file, "utf-8");
+    let format = opts.format;
+    if (!format) {
+      if (file.endsWith(".yaml") || file.endsWith(".yml")) {
+        format = "yaml";
+      } else {
+        format = "json";
+      }
+    }
+    let data;
+    if (format === "yaml") {
+      const yaml = await import("yaml");
+      data = yaml.parse(content);
+    } else {
+      data = JSON.parse(content);
+    }
+    if (!data || typeof data !== "object" || !("memories" in data) || !Array.isArray(data.memories)) {
+      console.error(chalk9.red("\u2717") + " Invalid import file: missing 'memories' array");
+      process.exit(1);
+    }
+    const VALID_TYPES11 = ["rule", "decision", "fact", "note"];
+    const importData = data;
+    let skipped = 0;
+    const validMemories = [];
+    for (const m of importData.memories) {
+      if (!m.content || typeof m.content !== "string" || m.content.trim().length === 0) {
+        skipped++;
+        continue;
+      }
+      if (m.type && !VALID_TYPES11.includes(m.type)) {
+        console.error(chalk9.yellow("\u26A0") + ` Skipping memory with invalid type "${m.type}": ${m.content.slice(0, 50)}`);
+        skipped++;
+        continue;
+      }
+      validMemories.push(m);
+    }
+    if (opts.dryRun) {
+      console.log(chalk9.blue("Dry run - would import:"));
+      for (const m of validMemories) {
+        const type = m.type || "note";
+        const scope = opts.global ? "global" : m.scope || "project";
+        const tags = m.tags?.length ? ` [${m.tags.join(", ")}]` : "";
+        console.log(`  ${type} (${scope}): ${m.content}${tags}`);
+      }
+      console.log(chalk9.dim(`
+${validMemories.length} memories would be imported`));
+      if (skipped > 0) console.log(chalk9.dim(`${skipped} entries skipped (invalid)`));
+      return;
+    }
+    let imported = 0;
+    let failed = 0;
+    for (const m of validMemories) {
+      try {
+        await addMemory(m.content, {
+          type: m.type || "note",
+          tags: m.tags,
+          global: opts.global || m.scope === "global"
+        });
+        imported++;
+      } catch (error) {
+        console.error(chalk9.yellow("\u26A0") + ` Failed to import: ${m.content.slice(0, 50)}...`);
+        failed++;
+      }
+    }
+    console.log(chalk9.green("\u2713") + ` Imported ${imported} memories`);
+    if (failed > 0) {
+      console.log(chalk9.yellow("\u26A0") + ` ${failed} memories failed to import`);
+    }
+    if (skipped > 0) {
+      console.log(chalk9.dim(`${skipped} entries skipped (invalid content or type)`));
+    }
+  } catch (error) {
+    console.error(chalk9.red("\u2717") + " Failed to import:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/config.ts
+import { Command as Command10 } from "commander";
+
+// src/lib/config.ts
+import { readFile as readFile3, writeFile as writeFile3, mkdir as mkdir2 } from "fs/promises";
+import { join as join2 } from "path";
+import { existsSync as existsSync2 } from "fs";
+import { parse, stringify } from "yaml";
+var AGENTS_DIR = ".agents";
+var CONFIG_FILE = "config.yaml";
+async function initConfig(dir) {
+  const agentsDir = join2(dir, AGENTS_DIR);
+  await mkdir2(agentsDir, { recursive: true });
+  const configPath = join2(agentsDir, CONFIG_FILE);
+  if (!existsSync2(configPath)) {
+    const defaultConfig = {
+      name: "my-project",
+      description: "Agent memory configuration",
+      version: "0.1.0",
+      memory: {
+        provider: "local",
+        store: "~/.config/memories/local.db"
+      }
+    };
+    await writeFile3(configPath, stringify(defaultConfig), "utf-8");
+  }
+  return configPath;
+}
+async function readConfig(dir) {
+  const configPath = join2(dir, AGENTS_DIR, CONFIG_FILE);
+  if (!existsSync2(configPath)) return null;
+  const raw = await readFile3(configPath, "utf-8");
+  return parse(raw);
+}
+
+// src/commands/config.ts
+var configCommand = new Command10("config").description("Manage agent configuration");
+configCommand.command("init").description("Initialize .agents/config.yaml in current directory").action(async () => {
+  const path = await initConfig(process.cwd());
+  console.log(`Created config at ${path}`);
+});
+configCommand.command("show").description("Show current agent configuration").action(async () => {
+  const config = await readConfig(process.cwd());
+  if (!config) {
+    console.log("No .agents/config.yaml found. Run `memories config init` first.");
+    return;
+  }
+  console.log(JSON.stringify(config, null, 2));
+});
+
+// src/commands/serve.ts
+import { Command as Command11 } from "commander";
+
+// src/mcp/index.ts
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+var TYPE_LABELS2 = {
+  rule: "\u{1F4CC} RULE",
+  decision: "\u{1F4A1} DECISION",
+  fact: "\u{1F4CB} FACT",
+  note: "\u{1F4DD} NOTE"
+};
+function formatMemory4(m) {
+  const tags = m.tags ? ` [${m.tags}]` : "";
+  const scope = m.scope === "global" ? "G" : "P";
+  const typeLabel = TYPE_LABELS2[m.type] || "\u{1F4DD} NOTE";
+  return `${typeLabel} (${scope}) ${m.id}: ${m.content}${tags}`;
+}
+function formatRulesSection(rules) {
+  if (rules.length === 0) return "";
+  return `## Active Rules
+${rules.map((r) => `- ${r.content}`).join("\n")}`;
+}
+function formatMemoriesSection(memories, title) {
+  if (memories.length === 0) return "";
+  return `## ${title}
+${memories.map(formatMemory4).join("\n")}`;
+}
+async function startMcpServer() {
+  const projectId = getProjectId();
+  const server = new McpServer({
+    name: "memories",
+    version: "0.1.0"
+  });
+  server.resource(
+    "rules",
+    "memories://rules",
+    { description: "All active rules (coding standards, preferences, constraints)", mimeType: "text/markdown" },
+    async () => {
+      try {
+        const rules = await getRules({ projectId: projectId ?? void 0 });
+        if (rules.length === 0) {
+          return {
+            contents: [{ uri: "memories://rules", mimeType: "text/markdown", text: "No rules defined." }]
+          };
+        }
+        const globalRules = rules.filter((r) => r.scope === "global");
+        const projectRules = rules.filter((r) => r.scope === "project");
+        const parts = [];
+        if (globalRules.length > 0) {
+          parts.push(`## Global Rules
+
+${globalRules.map((r) => `- ${r.content}`).join("\n")}`);
+        }
+        if (projectRules.length > 0) {
+          parts.push(`## Project Rules
+
+${projectRules.map((r) => `- ${r.content}`).join("\n")}`);
+        }
+        return {
+          contents: [{ uri: "memories://rules", mimeType: "text/markdown", text: parts.join("\n\n") }]
+        };
+      } catch (error) {
+        return {
+          contents: [{ uri: "memories://rules", mimeType: "text/markdown", text: `Error loading rules: ${error instanceof Error ? error.message : "Unknown error"}` }]
+        };
+      }
+    }
+  );
+  server.resource(
+    "recent",
+    "memories://recent",
+    { description: "20 most recent memories across all types", mimeType: "text/markdown" },
+    async () => {
+      try {
+        const memories = await listMemories({
+          limit: 20,
+          projectId: projectId ?? void 0
+        });
+        if (memories.length === 0) {
+          return {
+            contents: [{ uri: "memories://recent", mimeType: "text/markdown", text: "No memories found." }]
+          };
+        }
+        const text = memories.map(formatMemory4).join("\n");
+        return {
+          contents: [{ uri: "memories://recent", mimeType: "text/markdown", text: `## Recent Memories
+
+${text}` }]
+        };
+      } catch (error) {
+        return {
+          contents: [{ uri: "memories://recent", mimeType: "text/markdown", text: `Error loading memories: ${error instanceof Error ? error.message : "Unknown error"}` }]
+        };
+      }
+    }
+  );
+  server.resource(
+    "project-memories",
+    new ResourceTemplate("memories://project/{projectId}", { list: void 0 }),
+    { description: "All memories for a specific project", mimeType: "text/markdown" },
+    async (uri, variables) => {
+      try {
+        const pid = String(variables.projectId);
+        const memories = await listMemories({
+          projectId: pid,
+          includeGlobal: false
+        });
+        if (memories.length === 0) {
+          return {
+            contents: [{ uri: uri.href, mimeType: "text/markdown", text: `No memories found for project ${pid}.` }]
+          };
+        }
+        const text = memories.map(formatMemory4).join("\n");
+        return {
+          contents: [{ uri: uri.href, mimeType: "text/markdown", text: `## Memories for ${pid}
+
+${text}` }]
+        };
+      } catch (error) {
+        return {
+          contents: [{ uri: uri.href, mimeType: "text/markdown", text: `Error loading project memories: ${error instanceof Error ? error.message : "Unknown error"}` }]
+        };
+      }
+    }
+  );
+  server.tool(
+    "get_context",
+    `Get relevant context for the current task. This is the PRIMARY tool for AI agents.
+Returns:
+1. All active RULES (coding standards, preferences) - always included
+2. Relevant memories matching your query (decisions, facts, notes)
+
+Use this at the start of tasks to understand project conventions and recall past decisions.`,
+    {
+      query: z.string().optional().describe("What you're working on - used to find relevant memories. Leave empty to get just rules."),
+      limit: z.number().optional().describe("Max memories to return (default: 10, rules always included)")
+    },
+    async ({ query, limit }) => {
+      try {
+        const { rules, memories } = await getContext(query, {
+          projectId: projectId ?? void 0,
+          limit
+        });
+        const parts = [];
+        if (rules.length > 0) {
+          parts.push(formatRulesSection(rules));
+        }
+        if (memories.length > 0) {
+          parts.push(formatMemoriesSection(memories, query ? `Relevant to: "${query}"` : "Recent Memories"));
+        }
+        if (parts.length === 0) {
+          return {
+            content: [{ type: "text", text: "No context found. Use add_memory to store rules and knowledge." }]
+          };
+        }
+        return {
+          content: [{ type: "text", text: parts.join("\n\n") }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to get context: ${error instanceof Error ? error.message : "Unknown error"}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "add_memory",
+    `Store a new memory. Choose the appropriate type:
+- rule: Coding standards, preferences, constraints (e.g., "Always use TypeScript strict mode")
+- decision: Why we chose something (e.g., "Chose PostgreSQL for JSONB support")
+- fact: Project-specific knowledge (e.g., "API rate limit is 100 req/min")
+- note: General notes (default)
+
+By default, memories are project-scoped when in a git repo. Use global: true for user-wide preferences.`,
+    {
+      content: z.string().describe("The memory content to store"),
+      type: z.enum(["rule", "decision", "fact", "note"]).optional().describe("Memory type (default: note)"),
+      tags: z.array(z.string()).optional().describe("Tags to categorize the memory"),
+      global: z.boolean().optional().describe("Store as global memory instead of project-scoped")
+    },
+    async ({ content, type, tags, global: isGlobal }) => {
+      try {
+        const memory = await addMemory(content, {
+          tags,
+          global: isGlobal,
+          type
+        });
+        const typeLabel = TYPE_LABELS2[memory.type];
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Stored ${typeLabel} ${memory.id} (${memory.scope}${memory.project_id ? `: ${memory.project_id}` : ""})`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to add memory: ${error instanceof Error ? error.message : "Unknown error"}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "search_memories",
+    "Search memories by content using full-text search. Returns both global and project-scoped memories ranked by relevance.",
+    {
+      query: z.string().describe("Search query - words are matched with prefix matching"),
+      limit: z.number().optional().describe("Maximum number of results (default: 20)"),
+      types: z.array(z.enum(["rule", "decision", "fact", "note"])).optional().describe("Filter by memory types")
+    },
+    async ({ query, limit, types }) => {
+      try {
+        const memories = await searchMemories(query, {
+          limit,
+          projectId: projectId ?? void 0,
+          types
+        });
+        if (memories.length === 0) {
+          return {
+            content: [{ type: "text", text: "No memories found matching your query." }]
+          };
+        }
+        const formatted = memories.map(formatMemory4).join("\n");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Found ${memories.length} memories:
+
+${formatted}`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to search memories: ${error instanceof Error ? error.message : "Unknown error"}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "get_rules",
+    "Get all active rules for the current project. Rules are coding standards, preferences, and constraints that should always be followed.",
+    {},
+    async () => {
+      try {
+        const rules = await getRules({ projectId: projectId ?? void 0 });
+        if (rules.length === 0) {
+          return {
+            content: [{ type: "text", text: "No rules defined. Add rules with: add_memory with type='rule'" }]
+          };
+        }
+        const globalRules = rules.filter((r) => r.scope === "global");
+        const projectRules = rules.filter((r) => r.scope === "project");
+        const parts = [];
+        if (globalRules.length > 0) {
+          parts.push(`## Global Rules
+${globalRules.map((r) => `- ${r.content}`).join("\n")}`);
+        }
+        if (projectRules.length > 0) {
+          parts.push(`## Project Rules
+${projectRules.map((r) => `- ${r.content}`).join("\n")}`);
+        }
+        return {
+          content: [{ type: "text", text: parts.join("\n\n") }]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to get rules: ${error instanceof Error ? error.message : "Unknown error"}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "list_memories",
+    "List recent memories. Returns both global and project-scoped memories.",
+    {
+      limit: z.number().optional().describe("Maximum number of results (default: 50)"),
+      tags: z.array(z.string()).optional().describe("Filter by tags"),
+      types: z.array(z.enum(["rule", "decision", "fact", "note"])).optional().describe("Filter by memory types")
+    },
+    async ({ limit, tags, types }) => {
+      try {
+        const memories = await listMemories({
+          limit,
+          tags,
+          projectId: projectId ?? void 0,
+          types
+        });
+        if (memories.length === 0) {
+          return {
+            content: [{ type: "text", text: "No memories found." }]
+          };
+        }
+        const formatted = memories.map(formatMemory4).join("\n");
+        return {
+          content: [
+            {
+              type: "text",
+              text: `${memories.length} memories:
+
+${formatted}`
+            }
+          ]
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to list memories: ${error instanceof Error ? error.message : "Unknown error"}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "edit_memory",
+    `Update an existing memory's content, type, or tags. Use this to refine or correct memories.
+Find the memory ID first with search_memories or list_memories.`,
+    {
+      id: z.string().describe("The memory ID to edit"),
+      content: z.string().optional().describe("New content for the memory"),
+      type: z.enum(["rule", "decision", "fact", "note"]).optional().describe("New type for the memory"),
+      tags: z.array(z.string()).optional().describe("New tags (replaces existing tags)")
+    },
+    async ({ id, content, type, tags }) => {
+      try {
+        if (!content && !type && !tags) {
+          return {
+            content: [{ type: "text", text: "Nothing to update. Provide at least one of: content, type, tags." }],
+            isError: true
+          };
+        }
+        const updated = await updateMemory(id, {
+          content,
+          type,
+          tags
+        });
+        if (updated) {
+          const typeLabel = TYPE_LABELS2[updated.type];
+          return {
+            content: [{ type: "text", text: `Updated ${typeLabel} ${updated.id}: ${updated.content}` }]
+          };
+        }
+        return {
+          content: [{ type: "text", text: `Memory ${id} not found or already deleted.` }],
+          isError: true
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to edit memory: ${error instanceof Error ? error.message : "Unknown error"}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server.tool(
+    "forget_memory",
+    "Soft-delete a memory by ID. The memory can be recovered if needed.",
+    {
+      id: z.string().describe("The memory ID to forget")
+    },
+    async ({ id }) => {
+      try {
+        const deleted = await forgetMemory(id);
+        if (deleted) {
+          return {
+            content: [{ type: "text", text: `Forgot memory ${id}` }]
+          };
+        }
+        return {
+          content: [{ type: "text", text: `Memory ${id} not found or already forgotten.` }],
+          isError: true
+        };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Failed to forget memory: ${error instanceof Error ? error.message : "Unknown error"}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+// src/commands/serve.ts
+var serveCommand = new Command11("serve").description("Start the MCP server (stdio transport)").action(async () => {
+  const projectId = getProjectId();
+  if (projectId) {
+    console.error(`[memories] MCP server starting (project: ${projectId})`);
+  } else {
+    console.error("[memories] MCP server starting (global only - not in a git repo)");
+  }
+  await startMcpServer();
+});
+
+// src/commands/sync.ts
+import { Command as Command12 } from "commander";
+
+// src/lib/turso.ts
+import { nanoid as nanoid2 } from "nanoid";
+var API_BASE = "https://api.turso.tech/v1";
+function getApiToken() {
+  const token = process.env.TURSO_PLATFORM_API_TOKEN;
+  if (!token) {
+    throw new Error(
+      "TURSO_PLATFORM_API_TOKEN not set. Get one at https://turso.tech/app/settings/api-tokens"
+    );
+  }
+  return token;
+}
+async function api(path, opts) {
+  const res = await fetch(`${API_BASE}${path}`, {
+    method: opts?.method ?? "GET",
+    headers: {
+      Authorization: `Bearer ${getApiToken()}`,
+      "Content-Type": "application/json"
+    },
+    body: opts?.body ? JSON.stringify(opts.body) : void 0
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Turso API error (${res.status}): ${text}`);
+  }
+  return res.json();
+}
+async function createDatabase(org) {
+  const name = `memories-${nanoid2(8).toLowerCase()}`;
+  const { database } = await api(
+    `/organizations/${org}/databases`,
+    {
+      method: "POST",
+      body: { name, group: "default" }
+    }
+  );
+  return {
+    name: database.Name,
+    hostname: database.Hostname,
+    dbId: database.DbId
+  };
+}
+async function createDatabaseToken(org, dbName) {
+  const { jwt } = await api(
+    `/organizations/${org}/databases/${dbName}/auth/tokens`,
+    { method: "POST" }
+  );
+  return jwt;
+}
+
+// src/commands/sync.ts
+import { unlinkSync, existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+import { homedir as homedir2 } from "os";
+var DB_PATH = join3(homedir2(), ".config", "memories", "local.db");
+var syncCommand = new Command12("sync").description(
+  "Manage remote sync"
+);
+syncCommand.command("enable").description("Provision a Turso database and enable sync").option("-o, --org <org>", "Turso organization", "webrenew").action(async (opts) => {
+  const existing = await readSyncConfig();
+  if (existing) {
+    console.log(`Sync already enabled: ${existing.syncUrl}`);
+    console.log('Run "memories sync push" to sync now.');
+    return;
+  }
+  console.log(`Creating database in ${opts.org}...`);
+  const db = await createDatabase(opts.org);
+  console.log(`Created database: ${db.name} (${db.hostname})`);
+  console.log("Generating auth token...");
+  const token = await createDatabaseToken(opts.org, db.name);
+  const syncUrl = `libsql://${db.hostname}`;
+  if (existsSync3(DB_PATH)) {
+    resetDb();
+    unlinkSync(DB_PATH);
+  }
+  await saveSyncConfig({
+    syncUrl,
+    syncToken: token,
+    org: opts.org,
+    dbName: db.name
+  });
+  console.log("Waiting for database to be ready...");
+  await new Promise((r) => setTimeout(r, 3e3));
+  resetDb();
+  await syncDb();
+  console.log(`Sync enabled: ${syncUrl}`);
+});
+syncCommand.command("push").description("Push local changes to remote").action(async () => {
+  const config = await readSyncConfig();
+  if (!config) {
+    console.error('Sync not enabled. Run "memories sync enable" first.');
+    process.exitCode = 1;
+    return;
+  }
+  await syncDb();
+  console.log("Synced to remote.");
+});
+syncCommand.command("status").description("Show sync configuration").action(async () => {
+  const config = await readSyncConfig();
+  if (!config) {
+    console.log("Sync not enabled.");
+    return;
+  }
+  console.log(`Remote: ${config.syncUrl}`);
+  console.log(`Org: ${config.org}`);
+  console.log(`Database: ${config.dbName}`);
+});
+
+// src/commands/generate.ts
+import { Command as Command13 } from "commander";
+import chalk10 from "chalk";
+import { writeFile as writeFile4, readFile as readFile4, mkdir as mkdir3 } from "fs/promises";
+import { existsSync as existsSync4, watch as fsWatch } from "fs";
+import { dirname, resolve, join as join4 } from "path";
+import { homedir as homedir3 } from "os";
+import { checkbox } from "@inquirer/prompts";
+var MARKER = "Generated by memories.sh";
+var VALID_TYPES6 = ["rule", "decision", "fact", "note"];
+function groupByType(memories) {
+  const groups = {};
+  for (const m of memories) {
+    const title = m.type === "rule" ? "Rules" : m.type === "decision" ? "Key Decisions" : m.type === "fact" ? "Project Facts" : "Notes";
+    (groups[title] ??= []).push(m);
+  }
+  const order = ["Rules", "Key Decisions", "Project Facts", "Notes"];
+  return order.filter((t) => groups[t]?.length).map((title) => ({ title, memories: groups[title] }));
+}
+function formatMemoriesAsMarkdown(memories) {
+  const sections = groupByType(memories);
+  if (sections.length === 0) return "";
+  return sections.map(({ title, memories: mems }) => {
+    const items = mems.map((m) => `- ${m.content}`).join("\n");
+    return `## ${title}
+
+${items}`;
+  }).join("\n\n");
+}
+function formatCursorMdc(memories) {
+  const body = formatMemoriesAsMarkdown(memories);
+  const frontmatter = [
+    "---",
+    "description: Project memories and rules from memories.sh",
+    "globs:",
+    "alwaysApply: true",
+    "---"
+  ].join("\n");
+  return `${frontmatter}
+
+# Project Memories
+
+${body}`;
+}
+function formatWindsurf(memories) {
+  const full = formatMemoriesAsMarkdown(memories);
+  const LIMIT = 6e3;
+  if (full.length <= LIMIT) return full;
+  const truncated = full.slice(0, LIMIT);
+  const lastNewline = truncated.lastIndexOf("\n");
+  return lastNewline > 0 ? truncated.slice(0, lastNewline) + "\n\n> _Truncated to fit Windsurf 6000 char limit._" : truncated;
+}
+var TARGETS = [
+  {
+    name: "cursor",
+    defaultPath: ".cursor/rules/memories.mdc",
+    description: "Cursor rules file (.cursor/rules/memories.mdc)",
+    format: formatCursorMdc
+  },
+  {
+    name: "claude",
+    defaultPath: "CLAUDE.md",
+    description: "Claude Code instructions (CLAUDE.md)",
+    format: (m) => `# Project Memories
+
+${formatMemoriesAsMarkdown(m)}`
+  },
+  {
+    name: "agents",
+    defaultPath: "AGENTS.md",
+    description: "AGENTS.md for Amp, Codex, Goose, Kilo, Kiro, OpenCode",
+    format: (m) => `# Project Memories
+
+${formatMemoriesAsMarkdown(m)}`
+  },
+  {
+    name: "copilot",
+    defaultPath: ".github/copilot-instructions.md",
+    description: "GitHub Copilot instructions (.github/copilot-instructions.md)",
+    format: (m) => `# Project Memories
+
+${formatMemoriesAsMarkdown(m)}`
+  },
+  {
+    name: "windsurf",
+    defaultPath: ".windsurf/rules/memories.md",
+    description: "Windsurf rules (.windsurf/rules/memories.md)",
+    format: formatWindsurf
+  },
+  {
+    name: "cline",
+    defaultPath: ".clinerules/memories.md",
+    description: "Cline rules (.clinerules/memories.md)",
+    format: (m) => `# Project Memories
+
+${formatMemoriesAsMarkdown(m)}`
+  },
+  {
+    name: "roo",
+    defaultPath: ".roo/rules/memories.md",
+    description: "Roo rules (.roo/rules/memories.md)",
+    format: (m) => `# Project Memories
+
+${formatMemoriesAsMarkdown(m)}`
+  },
+  {
+    name: "gemini",
+    defaultPath: "GEMINI.md",
+    description: "Gemini instructions (GEMINI.md)",
+    format: (m) => `# Project Memories
+
+${formatMemoriesAsMarkdown(m)}`
+  }
+];
+function makeFooter() {
+  return `
+
+<!-- ${MARKER} at ${(/* @__PURE__ */ new Date()).toISOString()} -->`;
+}
+async function hasOurMarker(filePath) {
+  try {
+    const content = await readFile4(filePath, "utf-8");
+    return content.includes(MARKER);
+  } catch {
+    return false;
+  }
+}
+var TRACK_BY_DEFAULT = /* @__PURE__ */ new Set(["CLAUDE.md", "AGENTS.md", "GEMINI.md", ".github/copilot-instructions.md"]);
+async function checkGitignore(filePath) {
+  if (TRACK_BY_DEFAULT.has(filePath)) return;
+  const gitignorePath = resolve(".gitignore");
+  try {
+    const content = existsSync4(gitignorePath) ? await readFile4(gitignorePath, "utf-8") : "";
+    const lines = content.split("\n");
+    const parentDir = filePath.split("/")[0];
+    if (lines.some((l) => l.trim() === filePath || l.trim() === parentDir || l.trim() === `${parentDir}/`)) {
+      return;
+    }
+    console.log(chalk10.dim(`  hint: add "${filePath}" to .gitignore if you don't want it tracked`));
+  } catch {
+  }
+}
+async function writeTarget(target, memories, opts) {
+  const outPath = resolve(opts.output ?? target.defaultPath);
+  const content = target.format(memories) + makeFooter();
+  if (opts.dryRun) {
+    console.log(chalk10.dim(`\u2500\u2500 ${target.name} \u2192 ${outPath} \u2500\u2500`));
+    console.log(content);
+    console.log();
+    return;
+  }
+  if (existsSync4(outPath)) {
+    const ours = await hasOurMarker(outPath);
+    if (!ours && !opts.force) {
+      console.error(
+        chalk10.yellow("\u26A0") + ` ${outPath} exists and was not generated by memories.sh. Use ${chalk10.bold("--force")} to overwrite.`
+      );
+      return;
+    }
+  }
+  await mkdir3(dirname(outPath), { recursive: true });
+  await writeFile4(outPath, content, "utf-8");
+  console.log(chalk10.green("\u2713") + ` Wrote ${target.name} \u2192 ${chalk10.dim(outPath)}`);
+  await checkGitignore(opts.output ?? target.defaultPath);
+}
+async function fetchMemories(types) {
+  const projectId = getProjectId() ?? void 0;
+  return listMemories({
+    limit: 1e4,
+    types,
+    projectId
+  });
+}
+function parseTypes(raw) {
+  if (!raw) return ["rule", "decision", "fact"];
+  const types = raw.split(",").map((s) => s.trim());
+  for (const t of types) {
+    if (!VALID_TYPES6.includes(t)) {
+      console.error(chalk10.red("\u2717") + ` Invalid type "${t}". Valid: ${VALID_TYPES6.join(", ")}`);
+      process.exit(1);
+    }
+  }
+  return types;
+}
+function getDbPath2() {
+  const dataDir = process.env.MEMORIES_DATA_DIR ?? join4(homedir3(), ".config", "memories");
+  return join4(dataDir, "local.db");
+}
+async function runWatch(targets, memories, opts) {
+  const dbPath = getDbPath2();
+  if (!existsSync4(dbPath)) {
+    console.error(chalk10.red("\u2717") + " Database not found. Run: memories init");
+    process.exit(1);
+  }
+  console.log(chalk10.dim(`Watching ${dbPath} for changes... (Ctrl+C to stop)
+`));
+  const mems = await memories();
+  if (mems.length > 0) {
+    for (const target of targets) {
+      await writeTarget(target, mems, { force: opts.force ?? true });
+    }
+  }
+  let timeout = null;
+  fsWatch(dbPath, () => {
+    if (timeout) clearTimeout(timeout);
+    timeout = setTimeout(async () => {
+      try {
+        const mems2 = await memories();
+        if (mems2.length > 0) {
+          for (const target of targets) {
+            await writeTarget(target, mems2, { force: true });
+          }
+        }
+      } catch (err) {
+        console.error(chalk10.red("\u2717") + " Watch error:", err.message);
+      }
+    }, 500);
+  });
+  await new Promise(() => {
+  });
+}
+var generateCommand = new Command13("generate").description("Generate IDE rule/instruction files from memories").option("--types <types>", "Comma-separated types to include (default: rule,decision,fact)").option("--dry-run", "Preview without writing").option("--force", "Overwrite files not generated by memories.sh").option("-w, --watch", "Watch for memory changes and auto-regenerate").action(async (opts) => {
+  try {
+    if (!process.stdin.isTTY) {
+      generateCommand.outputHelp();
+      return;
+    }
+    const selected = await checkbox({
+      message: "Select targets to generate",
+      choices: TARGETS.map((t) => ({
+        name: `${t.name} ${chalk10.dim(`\u2192 ${t.defaultPath}`)}`,
+        value: t.name,
+        checked: true
+      }))
+    });
+    if (selected.length === 0) {
+      console.log(chalk10.dim("No targets selected."));
+      return;
+    }
+    const types = parseTypes(opts.types);
+    const memories = await fetchMemories(types);
+    if (memories.length === 0) {
+      console.error(chalk10.dim('No memories found. Add some with: memories add --rule "Your rule"'));
+      return;
+    }
+    const selectedSet = new Set(selected);
+    for (const target of TARGETS.filter((t) => selectedSet.has(t.name))) {
+      await writeTarget(target, memories, opts);
+    }
+    if (opts.watch) {
+      await runWatch(TARGETS, () => fetchMemories(types), opts);
+    }
+  } catch (error) {
+    if (error.name === "ExitPromptError") return;
+    console.error(chalk10.red("\u2717") + " Failed to generate:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+for (const target of TARGETS) {
+  generateCommand.addCommand(
+    new Command13(target.name).description(target.description).option("-o, --output <path>", "Override output path").option("--types <types>", "Comma-separated types to include (default: rule,decision,fact)").option("--dry-run", "Preview without writing").option("--force", "Overwrite files not generated by memories.sh").action(async (opts) => {
+      try {
+        const types = parseTypes(opts.types);
+        const memories = await fetchMemories(types);
+        if (memories.length === 0) {
+          console.error(chalk10.dim('No memories found. Add some with: memories add --rule "Your rule"'));
+          return;
+        }
+        await writeTarget(target, memories, opts);
+      } catch (error) {
+        console.error(chalk10.red("\u2717") + ` Failed to generate ${target.name}:`, error instanceof Error ? error.message : "Unknown error");
+        process.exit(1);
+      }
+    })
+  );
+}
+generateCommand.addCommand(
+  new Command13("all").description("Generate rule files for all supported targets").option("--types <types>", "Comma-separated types to include (default: rule,decision,fact)").option("--dry-run", "Preview without writing").option("--force", "Overwrite files not generated by memories.sh").option("-w, --watch", "Watch for memory changes and auto-regenerate").action(async (opts) => {
+    try {
+      const types = parseTypes(opts.types);
+      if (opts.watch) {
+        await runWatch(TARGETS, () => fetchMemories(types), opts);
+        return;
+      }
+      const memories = await fetchMemories(types);
+      if (memories.length === 0) {
+        console.error(chalk10.dim('No memories found. Add some with: memories add --rule "Your rule"'));
+        return;
+      }
+      for (const target of TARGETS) {
+        await writeTarget(target, memories, opts);
+      }
+    } catch (error) {
+      console.error(chalk10.red("\u2717") + " Failed to generate:", error instanceof Error ? error.message : "Unknown error");
+      process.exit(1);
+    }
+  })
+);
+
+// src/commands/edit.ts
+import { Command as Command14 } from "commander";
+import chalk11 from "chalk";
+import { execFileSync as execFileSync2 } from "child_process";
+import { writeFileSync, readFileSync, unlinkSync as unlinkSync2 } from "fs";
+import { tmpdir } from "os";
+import { join as join5 } from "path";
+import { nanoid as nanoid3 } from "nanoid";
+import { select } from "@inquirer/prompts";
+var VALID_TYPES7 = ["rule", "decision", "fact", "note"];
+function truncate2(str, max) {
+  if (str.length <= max) return str;
+  return str.slice(0, max - 1) + "\u2026";
+}
+async function pickMemory() {
+  const projectId = getProjectId() ?? void 0;
+  const memories = await listMemories({ limit: 100, projectId });
+  if (memories.length === 0) {
+    console.error(chalk11.dim("No memories found."));
+    process.exit(0);
+  }
+  const id = await select({
+    message: "Select a memory to edit",
+    choices: memories.map((m) => ({
+      name: `${chalk11.dim(m.type.padEnd(9))} ${truncate2(m.content, 60)} ${chalk11.dim(m.id)}`,
+      value: m.id
+    }))
+  });
+  return id;
+}
+var editCommand = new Command14("edit").description("Edit an existing memory").argument("[id]", "Memory ID to edit (interactive picker if omitted)").option("-c, --content <content>", "New content (skips editor)").option("-t, --tags <tags>", "New comma-separated tags").option("--type <type>", "New memory type: rule, decision, fact, note").action(async (id, opts) => {
+  try {
+    if (!id) {
+      if (!process.stdin.isTTY) {
+        console.error(chalk11.red("\u2717") + " Memory ID required in non-interactive mode");
+        process.exit(1);
+      }
+      id = await pickMemory();
+    }
+    const db = await getDb();
+    const result = await db.execute({
+      sql: `SELECT * FROM memories WHERE id = ? AND deleted_at IS NULL`,
+      args: [id]
+    });
+    if (result.rows.length === 0) {
+      console.error(chalk11.red("\u2717") + ` Memory ${chalk11.dim(id)} not found`);
+      process.exit(1);
+    }
+    const memory = result.rows[0];
+    if (opts.type && !VALID_TYPES7.includes(opts.type)) {
+      console.error(chalk11.red("\u2717") + ` Invalid type "${opts.type}". Valid: ${VALID_TYPES7.join(", ")}`);
+      process.exit(1);
+    }
+    let newContent = opts.content;
+    if (newContent === void 0 && opts.tags === void 0 && opts.type === void 0) {
+      const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+      const tmpFile = join5(tmpdir(), `memories-edit-${nanoid3(6)}.md`);
+      writeFileSync(tmpFile, memory.content, "utf-8");
+      try {
+        execFileSync2(editor, [tmpFile], { stdio: "inherit" });
+        newContent = readFileSync(tmpFile, "utf-8").trimEnd();
+      } finally {
+        try {
+          unlinkSync2(tmpFile);
+        } catch {
+        }
+      }
+      if (newContent === memory.content) {
+        console.log(chalk11.dim("No changes made."));
+        return;
+      }
+    }
+    const updates = {};
+    if (newContent !== void 0) updates.content = newContent;
+    if (opts.tags !== void 0) updates.tags = opts.tags.split(",").map((s) => s.trim()).filter(Boolean);
+    if (opts.type !== void 0) updates.type = opts.type;
+    const updated = await updateMemory(id, updates);
+    if (!updated) {
+      console.error(chalk11.red("\u2717") + ` Failed to update memory ${chalk11.dim(id)}`);
+      process.exit(1);
+    }
+    const changes = [];
+    if (updates.content !== void 0) changes.push("content");
+    if (updates.tags !== void 0) changes.push("tags");
+    if (updates.type !== void 0) changes.push(`type\u2192${updates.type}`);
+    console.log(chalk11.green("\u2713") + ` Updated ${chalk11.dim(id)} (${changes.join(", ")})`);
+  } catch (error) {
+    if (error.name === "ExitPromptError") return;
+    console.error(chalk11.red("\u2717") + " Failed to edit memory:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/stats.ts
+import { Command as Command15 } from "commander";
+import chalk12 from "chalk";
+var statsCommand = new Command15("stats").description("Show memory statistics").option("--json", "Output as JSON").action(async (opts) => {
+  try {
+    const db = await getDb();
+    const projectId = getProjectId();
+    const result = await db.execute({
+      sql: `SELECT type, scope, COUNT(*) as count FROM memories WHERE deleted_at IS NULL GROUP BY type, scope ORDER BY type, scope`,
+      args: []
+    });
+    const totalResult = await db.execute({
+      sql: `SELECT COUNT(*) as total FROM memories WHERE deleted_at IS NULL`,
+      args: []
+    });
+    const total = Number(totalResult.rows[0]?.total ?? 0);
+    const deletedResult = await db.execute({
+      sql: `SELECT COUNT(*) as deleted FROM memories WHERE deleted_at IS NOT NULL`,
+      args: []
+    });
+    const deleted = Number(deletedResult.rows[0]?.deleted ?? 0);
+    const projectCount = projectId ? Number(
+      (await db.execute({
+        sql: `SELECT COUNT(*) as count FROM memories WHERE deleted_at IS NULL AND scope = 'project' AND project_id = ?`,
+        args: [projectId]
+      })).rows[0]?.count ?? 0
+    ) : null;
+    const rows = result.rows;
+    if (opts.json) {
+      const data = {
+        total,
+        deleted,
+        project_id: projectId,
+        project_count: projectCount,
+        breakdown: rows.map((r) => ({ type: r.type, scope: r.scope, count: Number(r.count) }))
+      };
+      console.log(JSON.stringify(data, null, 2));
+      return;
+    }
+    console.log(chalk12.bold("Memory Statistics\n"));
+    if (projectId) {
+      console.log(`  Project: ${chalk12.dim(projectId)}`);
+    }
+    console.log(`  Total:   ${chalk12.bold(String(total))} active, ${chalk12.dim(String(deleted))} deleted
+`);
+    if (rows.length === 0) {
+      console.log(chalk12.dim('  No memories yet. Add one with: memories add "Your memory"'));
+      return;
+    }
+    const typeWidths = { rule: 8, decision: 8, fact: 8, note: 8 };
+    console.log(
+      `  ${chalk12.dim("Type".padEnd(12))}${chalk12.dim("Scope".padEnd(10))}${chalk12.dim("Count")}`
+    );
+    console.log(chalk12.dim("  " + "\u2500".repeat(30)));
+    for (const row of rows) {
+      const type = row.type.padEnd(12);
+      const scope = row.scope.padEnd(10);
+      console.log(`  ${type}${scope}${Number(row.count)}`);
+    }
+  } catch (error) {
+    console.error(chalk12.red("\u2717") + " Failed to get stats:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/doctor.ts
+import { Command as Command16 } from "commander";
+import chalk13 from "chalk";
+import { existsSync as existsSync5 } from "fs";
+import { join as join6 } from "path";
+var doctorCommand = new Command16("doctor").description("Check memories health and diagnose issues").option("--fix", "Attempt to fix issues found").action(async (opts) => {
+  try {
+    console.log(chalk13.bold("memories doctor\n"));
+    const checks = [
+      {
+        name: "Database file",
+        run: async () => {
+          const dbPath = join6(getConfigDir(), "local.db");
+          if (existsSync5(dbPath)) {
+            return { ok: true, message: `Found at ${dbPath}` };
+          }
+          return { ok: false, message: `Not found at ${dbPath}. Run: memories init` };
+        }
+      },
+      {
+        name: "Database connection",
+        run: async () => {
+          try {
+            const db = await getDb();
+            await db.execute("SELECT 1");
+            return { ok: true, message: "Connected successfully" };
+          } catch (e) {
+            return { ok: false, message: `Connection failed: ${e.message}` };
+          }
+        }
+      },
+      {
+        name: "Schema integrity",
+        run: async () => {
+          const db = await getDb();
+          const result = await db.execute("PRAGMA integrity_check");
+          const status = String(result.rows[0]?.integrity_check ?? "unknown");
+          return status === "ok" ? { ok: true, message: "PRAGMA integrity_check: ok" } : { ok: false, message: `Integrity check failed: ${status}` };
+        }
+      },
+      {
+        name: "FTS index",
+        run: async () => {
+          const db = await getDb();
+          try {
+            await db.execute(
+              "SELECT rowid FROM memories_fts LIMIT 1"
+            );
+            const leaked = await db.execute(`
+                SELECT COUNT(*) as count FROM memories m
+                JOIN memories_fts fts ON m.rowid = fts.rowid
+                WHERE memories_fts MATCH '"*"' AND m.deleted_at IS NOT NULL
+              `);
+            const leakedCount = Number(leaked.rows[0]?.count ?? 0);
+            if (leakedCount > 0) {
+              return {
+                ok: false,
+                message: `${leakedCount} soft-deleted records still searchable via FTS`
+              };
+            }
+            const active = await db.execute(
+              "SELECT COUNT(*) as count FROM memories WHERE deleted_at IS NULL"
+            );
+            return { ok: true, message: `FTS operational, ${Number(active.rows[0]?.count ?? 0)} active memories indexed` };
+          } catch {
+            return { ok: false, message: "FTS table missing or corrupted" };
+          }
+        }
+      },
+      {
+        name: "Git project detection",
+        run: async () => {
+          const projectId = getProjectId();
+          if (projectId) {
+            return { ok: true, message: `Detected: ${projectId}` };
+          }
+          return { ok: true, message: "Not in a git repo (global-only mode)" };
+        }
+      },
+      {
+        name: "Orphaned project memories",
+        run: async () => {
+          const db = await getDb();
+          const result = await db.execute(
+            "SELECT DISTINCT project_id FROM memories WHERE scope = 'project' AND deleted_at IS NULL AND project_id IS NOT NULL"
+          );
+          const projectIds = result.rows.map((r) => String(r.project_id));
+          if (projectIds.length === 0) {
+            return { ok: true, message: "No project memories found" };
+          }
+          return { ok: true, message: `${projectIds.length} project(s) with memories: ${projectIds.join(", ")}` };
+        }
+      },
+      {
+        name: "Soft-deleted records",
+        run: async () => {
+          const db = await getDb();
+          const result = await db.execute(
+            "SELECT COUNT(*) as count FROM memories WHERE deleted_at IS NOT NULL"
+          );
+          const count = Number(result.rows[0]?.count ?? 0);
+          if (count === 0) {
+            return { ok: true, message: "No soft-deleted records" };
+          }
+          return { ok: true, message: `${count} soft-deleted records (run 'memories doctor --fix' to purge)` };
+        }
+      }
+    ];
+    let hasIssues = false;
+    for (const check of checks) {
+      const { ok, message } = await check.run();
+      const icon = ok ? chalk13.green("\u2713") : chalk13.red("\u2717");
+      console.log(`  ${icon} ${chalk13.bold(check.name)}: ${message}`);
+      if (!ok) hasIssues = true;
+    }
+    if (opts.fix) {
+      console.log(chalk13.bold("\nRunning fixes...\n"));
+      const db = await getDb();
+      const purged = await db.execute(
+        "DELETE FROM memories WHERE deleted_at IS NOT NULL"
+      );
+      console.log(`  ${chalk13.green("\u2713")} Purged ${purged.rowsAffected} soft-deleted records`);
+      try {
+        await db.execute("INSERT INTO memories_fts(memories_fts) VALUES('rebuild')");
+        console.log(`  ${chalk13.green("\u2713")} Rebuilt FTS index`);
+      } catch {
+        console.log(`  ${chalk13.yellow("\u26A0")} Could not rebuild FTS index`);
+      }
+    }
+    console.log();
+    if (hasIssues) {
+      console.log(chalk13.yellow("Some issues detected.") + (opts.fix ? "" : " Run with --fix to attempt repairs."));
+    } else {
+      console.log(chalk13.green("All checks passed."));
+    }
+  } catch (error) {
+    console.error(chalk13.red("\u2717") + " Doctor failed:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/hook.ts
+import { Command as Command17 } from "commander";
+import chalk14 from "chalk";
+import { readFile as readFile5, writeFile as writeFile5, chmod } from "fs/promises";
+import { existsSync as existsSync6, readFileSync as readFileSync2 } from "fs";
+import { execFileSync as execFileSync3 } from "child_process";
+import { join as join7 } from "path";
+var HOOK_MARKER_START = "# >>> memories.sh hook >>>";
+var HOOK_MARKER_END = "# <<< memories.sh hook <<<";
+var HOOK_SNIPPET = `
+${HOOK_MARKER_START}
+# Auto-generate IDE rule files from memories
+if command -v memories &> /dev/null; then
+  memories generate all --force 2>/dev/null || true
+  git add -A -- .cursor/rules/memories.mdc CLAUDE.md AGENTS.md .github/copilot-instructions.md .windsurf/rules/memories.md .clinerules/memories.md .roo/rules/memories.md GEMINI.md 2>/dev/null || true
+fi
+${HOOK_MARKER_END}`;
+function getGitDir() {
+  try {
+    return execFileSync3("git", ["rev-parse", "--git-dir"], { encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function getHookLocation(hookName) {
+  const gitDir = getGitDir();
+  if (!gitDir) return null;
+  const huskyPath = join7(".husky", hookName);
+  if (existsSync6(".husky") && !existsSync6(join7(".husky", "_"))) {
+    return { path: huskyPath, type: "husky" };
+  }
+  const huskyLegacyPath = join7(".husky", "_", hookName);
+  if (existsSync6(join7(".husky", "_"))) {
+    return { path: huskyLegacyPath, type: "husky" };
+  }
+  if (existsSync6(huskyPath)) {
+    return { path: huskyPath, type: "husky" };
+  }
+  return { path: join7(gitDir, "hooks", hookName), type: "git" };
+}
+function detectLintStaged() {
+  try {
+    if (!existsSync6("package.json")) return false;
+    const pkg = JSON.parse(readFileSync2("package.json", "utf-8"));
+    return !!(pkg["lint-staged"] || pkg.devDependencies?.["lint-staged"] || pkg.dependencies?.["lint-staged"]);
+  } catch {
+    return false;
+  }
+}
+var hookCommand = new Command17("hook").description("Manage git hooks for auto-generating rule files");
+hookCommand.addCommand(
+  new Command17("install").description("Install pre-commit hook to auto-generate rule files").option("--hook <name>", "Hook name (default: pre-commit)", "pre-commit").action(async (opts) => {
+    try {
+      const location = getHookLocation(opts.hook);
+      if (!location) {
+        console.error(chalk14.red("\u2717") + " Not in a git repository");
+        process.exit(1);
+      }
+      const hookPath = location.path;
+      if (existsSync6(hookPath)) {
+        const content = await readFile5(hookPath, "utf-8");
+        if (content.includes(HOOK_MARKER_START)) {
+          console.log(chalk14.dim("Hook already installed. Use 'memories hook uninstall' first to reinstall."));
+          return;
+        }
+        await writeFile5(hookPath, content.trimEnd() + "\n" + HOOK_SNIPPET + "\n", "utf-8");
+      } else {
+        await writeFile5(hookPath, "#!/bin/sh\n" + HOOK_SNIPPET + "\n", "utf-8");
+      }
+      await chmod(hookPath, 493);
+      const locationLabel = location.type === "husky" ? "Husky" : ".git/hooks";
+      console.log(chalk14.green("\u2713") + ` Installed memories hook in ${chalk14.dim(opts.hook)} (${locationLabel})`);
+      console.log(chalk14.dim("  Rule files will auto-generate on each commit."));
+      if (detectLintStaged()) {
+        console.log(
+          chalk14.dim("\n  lint-staged detected. You can also add to your lint-staged config:") + chalk14.dim('\n  "*.md": "memories generate all --force"')
+        );
+      }
+    } catch (error) {
+      console.error(chalk14.red("\u2717") + " Failed to install hook:", error instanceof Error ? error.message : "Unknown error");
+      process.exit(1);
+    }
+  })
+);
+hookCommand.addCommand(
+  new Command17("uninstall").description("Remove the memories pre-commit hook").option("--hook <name>", "Hook name (default: pre-commit)", "pre-commit").action(async (opts) => {
+    try {
+      const location = getHookLocation(opts.hook);
+      if (!location) {
+        console.error(chalk14.red("\u2717") + " Not in a git repository");
+        process.exit(1);
+      }
+      const hookPath = location.path;
+      if (!existsSync6(hookPath)) {
+        console.log(chalk14.dim("No hook file found."));
+        return;
+      }
+      const content = await readFile5(hookPath, "utf-8");
+      if (!content.includes(HOOK_MARKER_START)) {
+        console.log(chalk14.dim("No memories hook found in " + opts.hook));
+        return;
+      }
+      const regex = new RegExp(
+        `\\n?${escapeRegex(HOOK_MARKER_START)}[\\s\\S]*?${escapeRegex(HOOK_MARKER_END)}\\n?`
+      );
+      const cleaned = content.replace(regex, "\n");
+      if (cleaned.trim() === "#!/bin/sh" || cleaned.trim() === "") {
+        const { unlink } = await import("fs/promises");
+        await unlink(hookPath);
+        console.log(chalk14.green("\u2713") + ` Removed ${chalk14.dim(opts.hook)} hook (was memories-only)`);
+      } else {
+        await writeFile5(hookPath, cleaned, "utf-8");
+        console.log(chalk14.green("\u2713") + ` Removed memories section from ${chalk14.dim(opts.hook)}`);
+      }
+    } catch (error) {
+      console.error(chalk14.red("\u2717") + " Failed to uninstall hook:", error instanceof Error ? error.message : "Unknown error");
+      process.exit(1);
+    }
+  })
+);
+hookCommand.addCommand(
+  new Command17("status").description("Check if the memories hook is installed").option("--hook <name>", "Hook name (default: pre-commit)", "pre-commit").action(async (opts) => {
+    try {
+      const hookPath = getHookLocation(opts.hook)?.path;
+      if (!hookPath) {
+        console.error(chalk14.red("\u2717") + " Not in a git repository");
+        process.exit(1);
+      }
+      if (!existsSync6(hookPath)) {
+        console.log(chalk14.dim("Not installed") + ` \u2014 no ${opts.hook} hook found`);
+        return;
+      }
+      const content = await readFile5(hookPath, "utf-8");
+      if (content.includes(HOOK_MARKER_START)) {
+        console.log(chalk14.green("\u2713") + ` Installed in ${chalk14.dim(hookPath)}`);
+      } else {
+        console.log(chalk14.dim("Not installed") + ` \u2014 ${opts.hook} exists but has no memories section`);
+      }
+    } catch (error) {
+      console.error(chalk14.red("\u2717") + " Failed to check hook:", error instanceof Error ? error.message : "Unknown error");
+      process.exit(1);
+    }
+  })
+);
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// src/commands/ingest.ts
+import { Command as Command18 } from "commander";
+import chalk15 from "chalk";
+import { readFile as readFile6 } from "fs/promises";
+import { existsSync as existsSync7 } from "fs";
+var SOURCES = [
+  { name: "cursor", paths: [".cursor/rules/memories.mdc", ".cursorrules"], description: "Cursor rules" },
+  { name: "claude", paths: ["CLAUDE.md"], description: "Claude Code instructions" },
+  { name: "agents", paths: ["AGENTS.md"], description: "AGENTS.md" },
+  { name: "copilot", paths: [".github/copilot-instructions.md"], description: "GitHub Copilot instructions" },
+  { name: "windsurf", paths: [".windsurf/rules/memories.md", ".windsurfrules"], description: "Windsurf rules" },
+  { name: "cline", paths: [".clinerules/memories.md", ".clinerules"], description: "Cline rules" },
+  { name: "roo", paths: [".roo/rules/memories.md"], description: "Roo rules" },
+  { name: "gemini", paths: ["GEMINI.md"], description: "Gemini instructions" }
+];
+var MARKER2 = "Generated by memories.sh";
+var VALID_TYPES8 = ["rule", "decision", "fact", "note"];
+function inferType(line) {
+  const lower = line.toLowerCase();
+  if (lower.includes("always") || lower.includes("never") || lower.includes("must") || lower.includes("prefer")) {
+    return "rule";
+  }
+  if (lower.includes("chose") || lower.includes("decided") || lower.includes("because") || lower.includes("instead of")) {
+    return "decision";
+  }
+  if (lower.match(/\b(is|are|has|uses|runs on|version|limit)\b/)) {
+    return "fact";
+  }
+  return "rule";
+}
+function extractMemories(content) {
+  const memories = [];
+  const stripped = content.replace(/^---[\s\S]*?---\n*/m, "");
+  const clean = stripped.replace(/<!--.*?-->/g, "").trim();
+  for (const line of clean.split("\n")) {
+    const trimmed = line.trim();
+    const bulletMatch = trimmed.match(/^[-*]\s+(.+)$/);
+    if (bulletMatch) {
+      const text = bulletMatch[1].trim();
+      if (text.length > 10 && text.length < 500) {
+        memories.push({ content: text, type: inferType(text) });
+      }
+      continue;
+    }
+    const numberedMatch = trimmed.match(/^\d+[.)]\s+(.+)$/);
+    if (numberedMatch) {
+      const text = numberedMatch[1].trim();
+      if (text.length > 10 && text.length < 500) {
+        memories.push({ content: text, type: inferType(text) });
+      }
+      continue;
+    }
+    if (trimmed.length > 20 && trimmed.length < 500 && !trimmed.startsWith("#") && !trimmed.startsWith(">")) {
+      memories.push({ content: trimmed, type: inferType(trimmed) });
+    }
+  }
+  return memories;
+}
+function normalize(s) {
+  return s.toLowerCase().replace(/\s+/g, " ").replace(/[.,;:!?]+$/, "").trim();
+}
+var ingestCommand = new Command18("ingest").description("Import memories from existing IDE rule files").argument("[source]", "Source to import from (cursor, claude, agents, copilot, windsurf, cline, roo, gemini, or file path)").option("--type <type>", "Override type for all imported memories").option("--dry-run", "Preview without importing").option("--all", "Scan all known IDE rule file locations").option("--no-dedup", "Skip duplicate detection").action(async (source, opts) => {
+  try {
+    if (opts.type && !VALID_TYPES8.includes(opts.type)) {
+      console.error(chalk15.red("\u2717") + ` Invalid type "${opts.type}". Valid types: ${VALID_TYPES8.join(", ")}`);
+      process.exit(1);
+    }
+    const filesToProcess = [];
+    if (opts.all) {
+      for (const src of SOURCES) {
+        for (const p of src.paths) {
+          if (existsSync7(p)) {
+            filesToProcess.push({ name: src.name, path: p });
+          }
+        }
+      }
+    } else if (source) {
+      const known = SOURCES.find((s) => s.name === source);
+      if (known) {
+        for (const p of known.paths) {
+          if (existsSync7(p)) {
+            filesToProcess.push({ name: known.name, path: p });
+            break;
+          }
+        }
+        if (filesToProcess.length === 0) {
+          console.error(chalk15.red("\u2717") + ` No ${known.description} file found at: ${known.paths.join(", ")}`);
+          process.exit(1);
+        }
+      } else if (existsSync7(source)) {
+        filesToProcess.push({ name: "file", path: source });
+      } else {
+        console.error(chalk15.red("\u2717") + ` Unknown source "${source}". Valid: ${SOURCES.map((s) => s.name).join(", ")}, or a file path`);
+        process.exit(1);
+      }
+    } else {
+      console.error(chalk15.red("\u2717") + " Specify a source or use --all");
+      process.exit(1);
+    }
+    if (filesToProcess.length === 0) {
+      console.log(chalk15.dim("No IDE rule files found."));
+      return;
+    }
+    const existingSet = /* @__PURE__ */ new Set();
+    if (opts.dedup !== false) {
+      const db = await getDb();
+      const result = await db.execute("SELECT content FROM memories WHERE deleted_at IS NULL");
+      for (const row of result.rows) {
+        existingSet.add(normalize(String(row.content)));
+      }
+    }
+    let totalImported = 0;
+    let totalSkipped = 0;
+    for (const file of filesToProcess) {
+      const content = await readFile6(file.path, "utf-8");
+      if (content.includes(MARKER2)) {
+        console.log(chalk15.dim(`  Skipping ${file.path} (generated by memories.sh)`));
+        continue;
+      }
+      const memories = extractMemories(content);
+      if (memories.length === 0) {
+        console.log(chalk15.dim(`  No importable memories found in ${file.path}`));
+        continue;
+      }
+      console.log(chalk15.bold(`
+  ${file.name}`) + chalk15.dim(` (${file.path}) \u2014 ${memories.length} items`));
+      for (const mem of memories) {
+        const type = opts.type ?? mem.type;
+        if (opts.dedup !== false && existingSet.has(normalize(mem.content))) {
+          if (opts.dryRun) {
+            console.log(`    ${chalk15.dim("skip")}      ${chalk15.dim(mem.content)}`);
+          }
+          totalSkipped++;
+          continue;
+        }
+        if (opts.dryRun) {
+          const typeColor = type === "rule" ? chalk15.blue : type === "decision" ? chalk15.yellow : type === "fact" ? chalk15.green : chalk15.dim;
+          console.log(`    ${typeColor(type.padEnd(9))} ${mem.content}`);
+        } else {
+          await addMemory(mem.content, { type });
+          existingSet.add(normalize(mem.content));
+          totalImported++;
+        }
+      }
+    }
+    if (opts.dryRun) {
+      const skipMsg = totalSkipped > 0 ? ` (${totalSkipped} duplicates skipped)` : "";
+      console.log(chalk15.dim(`
+  Dry run \u2014 no memories imported.${skipMsg} Remove --dry-run to import.`));
+    } else {
+      const skipMsg = totalSkipped > 0 ? chalk15.dim(` (${totalSkipped} duplicates skipped)`) : "";
+      console.log(chalk15.green("\n\u2713") + ` Imported ${totalImported} memories` + skipMsg);
+    }
+  } catch (error) {
+    console.error(chalk15.red("\u2717") + " Failed to ingest:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+
+// src/commands/diff.ts
+import { Command as Command19 } from "commander";
+import chalk16 from "chalk";
+import { readFile as readFile7 } from "fs/promises";
+import { existsSync as existsSync8 } from "fs";
+import { resolve as resolve2 } from "path";
+var MARKER3 = "Generated by memories.sh";
+var VALID_TYPES9 = ["rule", "decision", "fact", "note"];
+var TARGETS2 = [
+  { name: "cursor", defaultPath: ".cursor/rules/memories.mdc" },
+  { name: "claude", defaultPath: "CLAUDE.md" },
+  { name: "agents", defaultPath: "AGENTS.md" },
+  { name: "copilot", defaultPath: ".github/copilot-instructions.md" },
+  { name: "windsurf", defaultPath: ".windsurf/rules/memories.md" },
+  { name: "cline", defaultPath: ".clinerules/memories.md" },
+  { name: "roo", defaultPath: ".roo/rules/memories.md" },
+  { name: "gemini", defaultPath: "GEMINI.md" }
+];
+function extractFileMemories(content) {
+  const memories = /* @__PURE__ */ new Set();
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("- ") && trimmed.length > 2) {
+      memories.add(trimmed.slice(2));
+    }
+  }
+  return memories;
+}
+function extractTimestamp(content) {
+  const match = content.match(/Generated by memories\.sh at (.+?)\s*-->/);
+  return match ? match[1] : null;
+}
+function parseTypes2(raw) {
+  if (!raw) return ["rule", "decision", "fact"];
+  const types = raw.split(",").map((s) => s.trim());
+  for (const t of types) {
+    if (!VALID_TYPES9.includes(t)) {
+      console.error(chalk16.red("\u2717") + ` Invalid type "${t}". Valid: ${VALID_TYPES9.join(", ")}`);
+      process.exit(1);
+    }
+  }
+  return types;
+}
+async function fetchMemories2(types) {
+  const projectId = getProjectId() ?? void 0;
+  return listMemories({ limit: 1e4, types, projectId });
+}
+async function diffTarget(target, currentMemories, outputPath) {
+  const filePath = resolve2(outputPath ?? target.defaultPath);
+  if (!existsSync8(filePath)) {
+    return {
+      added: currentMemories.map((m) => m.content),
+      removed: [],
+      unchanged: 0,
+      filePath,
+      exists: false,
+      isOurs: false,
+      generatedAt: null
+    };
+  }
+  const content = await readFile7(filePath, "utf-8");
+  const isOurs = content.includes(MARKER3);
+  const generatedAt = extractTimestamp(content);
+  const fileMemories = extractFileMemories(content);
+  const currentSet = new Set(currentMemories.map((m) => m.content));
+  const added = [...currentSet].filter((c) => !fileMemories.has(c));
+  const removed = [...fileMemories].filter((c) => !currentSet.has(c));
+  const unchanged = [...currentSet].filter((c) => fileMemories.has(c)).length;
+  return { added, removed, unchanged, filePath, exists: true, isOurs, generatedAt };
+}
+var diffCommand = new Command19("diff").description("Show what changed since last generate (are IDE rule files stale?)").argument("[target]", `Target to check (${TARGETS2.map((t) => t.name).join(", ")}, or all)`).option("--types <types>", "Comma-separated types to include (default: rule,decision,fact)").action(async (target, opts) => {
+  try {
+    const types = parseTypes2(opts.types);
+    const memories = await fetchMemories2(types);
+    const targetsToCheck = target && target !== "all" ? TARGETS2.filter((t) => t.name === target) : TARGETS2;
+    if (target && target !== "all" && targetsToCheck.length === 0) {
+      console.error(chalk16.red("\u2717") + ` Unknown target "${target}". Valid: ${TARGETS2.map((t) => t.name).join(", ")}`);
+      process.exit(1);
+    }
+    let anyStale = false;
+    for (const t of targetsToCheck) {
+      const result = await diffTarget(t, memories);
+      if (!result.exists && !target) continue;
+      const hasChanges = result.added.length > 0 || result.removed.length > 0;
+      if (!result.exists) {
+        console.log(chalk16.bold(`
+  ${t.name}`) + chalk16.dim(` \u2192 ${result.filePath}`));
+        console.log(chalk16.yellow("    Not generated yet.") + chalk16.dim(` Run: memories generate ${t.name}`));
+        anyStale = true;
+        continue;
+      }
+      if (!result.isOurs) {
+        console.log(chalk16.bold(`
+  ${t.name}`) + chalk16.dim(` \u2192 ${result.filePath}`));
+        console.log(chalk16.dim("    Not managed by memories.sh (no marker found)"));
+        continue;
+      }
+      if (!hasChanges) {
+        if (target) {
+          console.log(chalk16.bold(`
+  ${t.name}`) + chalk16.dim(` \u2192 ${result.filePath}`));
+          const since = result.generatedAt ? chalk16.dim(` (generated ${formatRelative(result.generatedAt)})`) : "";
+          console.log(chalk16.green("    Up to date.") + since);
+        }
+        continue;
+      }
+      anyStale = true;
+      console.log(chalk16.bold(`
+  ${t.name}`) + chalk16.dim(` \u2192 ${result.filePath}`));
+      if (result.generatedAt) {
+        console.log(chalk16.dim(`    Generated ${formatRelative(result.generatedAt)}`));
+      }
+      for (const a of result.added) {
+        console.log(chalk16.green(`    + ${a}`));
+      }
+      for (const r of result.removed) {
+        console.log(chalk16.red(`    - ${r}`));
+      }
+      if (result.unchanged > 0) {
+        console.log(chalk16.dim(`    ${result.unchanged} unchanged`));
+      }
+    }
+    if (!anyStale) {
+      if (target) {
+      } else {
+        console.log(chalk16.green("\n  All generated files are up to date."));
+      }
+    } else {
+      console.log(chalk16.dim(`
+  Run ${chalk16.bold("memories generate")} to update stale files.`));
+    }
+  } catch (error) {
+    console.error(chalk16.red("\u2717") + " Diff failed:", error instanceof Error ? error.message : "Unknown error");
+    process.exit(1);
+  }
+});
+function formatRelative(isoDate) {
+  const then = new Date(isoDate);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - then.getTime();
+  if (diffMs < 0) return "just now";
+  const seconds = Math.floor(diffMs / 1e3);
+  if (seconds < 60) return "just now";
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours}h ago`;
+  const days = Math.floor(hours / 24);
+  return `${days}d ago`;
+}
+
+// src/commands/tag.ts
+import { Command as Command20 } from "commander";
+import chalk17 from "chalk";
+var VALID_TYPES10 = ["rule", "decision", "fact", "note"];
+function buildWhere(filters) {
+  const conditions = ["deleted_at IS NULL"];
+  const args = [];
+  const projectId = getProjectId();
+  if (filters.type) {
+    if (!VALID_TYPES10.includes(filters.type)) {
+      throw new Error(`Invalid type "${filters.type}". Valid: ${VALID_TYPES10.join(", ")}`);
+    }
+    conditions.push("type = ?");
+    args.push(filters.type);
+  }
+  if (filters.scope === "global") {
+    conditions.push("scope = 'global'");
+  } else if (filters.scope === "project") {
+    if (!projectId) throw new Error("Not in a git repo \u2014 cannot filter by project scope.");
+    conditions.push("scope = 'project' AND project_id = ?");
+    args.push(projectId);
+  }
+  return { where: conditions.join(" AND "), args };
+}
+function parseTags(raw) {
+  if (!raw) return /* @__PURE__ */ new Set();
+  return new Set(raw.split(",").map((t) => t.trim()).filter(Boolean));
+}
+var tagCommand = new Command20("tag").description("Bulk tag/untag operations on memories");
+tagCommand.addCommand(
+  new Command20("add").description("Add a tag to matching memories").argument("<tag>", "Tag to add").option("--type <type>", "Filter by memory type (rule, decision, fact, note)").option("--scope <scope>", "Filter by scope (global, project)").option("--dry-run", "Preview without modifying").action(async (tag, opts) => {
+    try {
+      const db = await getDb();
+      const { where, args } = buildWhere(opts);
+      const result = await db.execute({ sql: `SELECT id, tags FROM memories WHERE ${where}`, args });
+      let updated = 0;
+      let skipped = 0;
+      for (const row of result.rows) {
+        const existing = parseTags(row.tags);
+        if (existing.has(tag)) {
+          skipped++;
+          continue;
+        }
+        existing.add(tag);
+        const newTags = [...existing].join(",");
+        if (!opts.dryRun) {
+          await db.execute({
+            sql: "UPDATE memories SET tags = ?, updated_at = datetime('now') WHERE id = ?",
+            args: [newTags, row.id]
+          });
+        }
+        updated++;
+      }
+      if (opts.dryRun) {
+        console.log(chalk17.dim(`Dry run \u2014 would tag ${updated} memories with "${tag}" (${skipped} already tagged)`));
+      } else {
+        console.log(chalk17.green("\u2713") + ` Tagged ${updated} memories with "${tag}"` + (skipped > 0 ? chalk17.dim(` (${skipped} already tagged)`) : ""));
+      }
+    } catch (error) {
+      console.error(chalk17.red("\u2717") + ` Failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+      process.exit(1);
+    }
+  })
+);
+tagCommand.addCommand(
+  new Command20("remove").description("Remove a tag from matching memories").argument("<tag>", "Tag to remove").option("--type <type>", "Filter by memory type (rule, decision, fact, note)").option("--scope <scope>", "Filter by scope (global, project)").option("--dry-run", "Preview without modifying").action(async (tag, opts) => {
+    try {
+      const db = await getDb();
+      const { where, args } = buildWhere(opts);
+      const result = await db.execute({
+        sql: `SELECT id, tags FROM memories WHERE ${where} AND tags LIKE ?`,
+        args: [...args, `%${tag}%`]
+      });
+      let updated = 0;
+      for (const row of result.rows) {
+        const existing = parseTags(row.tags);
+        if (!existing.has(tag)) continue;
+        existing.delete(tag);
+        const newTags = existing.size > 0 ? [...existing].join(",") : null;
+        if (!opts.dryRun) {
+          await db.execute({
+            sql: "UPDATE memories SET tags = ?, updated_at = datetime('now') WHERE id = ?",
+            args: [newTags, row.id]
+          });
+        }
+        updated++;
+      }
+      if (opts.dryRun) {
+        console.log(chalk17.dim(`Dry run \u2014 would remove "${tag}" from ${updated} memories`));
+      } else {
+        console.log(chalk17.green("\u2713") + ` Removed "${tag}" from ${updated} memories`);
+      }
+    } catch (error) {
+      console.error(chalk17.red("\u2717") + ` Failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+      process.exit(1);
+    }
+  })
+);
+tagCommand.addCommand(
+  new Command20("list").description("List all tags in use with counts").option("--type <type>", "Filter by memory type").option("--scope <scope>", "Filter by scope (global, project)").action(async (opts) => {
+    try {
+      const db = await getDb();
+      const { where, args } = buildWhere(opts);
+      const result = await db.execute({
+        sql: `SELECT tags FROM memories WHERE ${where} AND tags IS NOT NULL AND tags != ''`,
+        args
+      });
+      const counts = /* @__PURE__ */ new Map();
+      for (const row of result.rows) {
+        for (const tag of parseTags(row.tags)) {
+          counts.set(tag, (counts.get(tag) ?? 0) + 1);
+        }
+      }
+      if (counts.size === 0) {
+        console.log(chalk17.dim("No tags found."));
+        return;
+      }
+      const sorted = [...counts.entries()].sort((a, b) => b[1] - a[1]);
+      for (const [tag, count] of sorted) {
+        console.log(`  ${chalk17.bold(tag)} ${chalk17.dim(`(${count})`)}`);
+      }
+    } catch (error) {
+      console.error(chalk17.red("\u2717") + ` Failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+      process.exit(1);
+    }
+  })
+);
+
+// src/index.ts
+var program = new Command21().name("memories").description("A local-first memory layer for AI agents").version("0.1.0");
+program.addCommand(initCommand);
+program.addCommand(addCommand);
+program.addCommand(recallCommand);
+program.addCommand(promptCommand);
+program.addCommand(searchCommand);
+program.addCommand(listCommand);
+program.addCommand(forgetCommand);
+program.addCommand(exportCommand);
+program.addCommand(importCommand);
+program.addCommand(configCommand);
+program.addCommand(serveCommand);
+program.addCommand(syncCommand);
+program.addCommand(generateCommand);
+program.addCommand(editCommand);
+program.addCommand(statsCommand);
+program.addCommand(doctorCommand);
+program.addCommand(hookCommand);
+program.addCommand(ingestCommand);
+program.addCommand(diffCommand);
+program.addCommand(tagCommand);
+program.parse();