march-cli 0.1.21 → 0.1.22

package/src/memory/markdown-tools.mjs

@@ -1,103 +1,103 @@
-import { defineTool } from "@earendil-works/pi-coding-agent";
-import { Type } from "typebox";
-import { toolText } from "../agent/tool-result.mjs";
-
-export function createMarkdownMemoryTools(store) {
-  if (!store) return [];
-  return [
-    defineTool({
-      name: "memory_search",
-      label: "Memory Search",
-      description:
-        "Search the Markdown memory vault using ripgrep. This is literal text search over memory Markdown files, not semantic search and not March's internal tags-only memory hint recall. Use it when memory hints are insufficient or you need to find a memory by phrase, term, or detail.",
-      parameters: Type.Object({
-        query: Type.String({ description: "Ripgrep query to search in Markdown memory files" }),
-        limit: Type.Optional(Type.Number({ description: "Maximum matching lines to return. Default: 20" })),
-      }),
-      execute: async (_toolCallId, params) => {
-        const results = store.searchRipgrep(params.query, { limit: params.limit ?? 20 });
-        if (results.length === 0) return toolText(formatMemorySearchMiss(params.query));
-        return toolText(results.map((result) => result.line).join("\n"), { results });
-      },
-    }),
-
-    defineTool({
-      name: "memory_open",
-      label: "Memory Open",
-      description: "Open a Markdown memory by id or by path. Use this after memory hint or memory_search when you need the full memory body. To edit an existing memory, use the returned path with edit_file for targeted edits.",
-      parameters: Type.Object({
-        id: Type.Optional(Type.String({ description: "Memory id from memory hint, e.g. mem_..." })),
-        path: Type.Optional(Type.String({ description: "Path returned by memory_search" })),
-      }),
-      execute: async (_toolCallId, params) => {
-        try {
-          const identifier = params.id || params.path;
-          const opened = store.open(identifier);
-          return toolText(
-            `path: ${opened.path}\nUse edit_file with this path for targeted edits.\n\n---\n${opened.content}`,
-            opened,
-          );
-        } catch (err) {
-          return toolText(`Error: ${err.message}`, { error: true });
-        }
-      },
-    }),
-
-    defineTool({
-      name: "memory_save",
-      label: "Memory Save",
-      description:
-        "Create a Markdown memory or update whole fields on an existing memory. For targeted edits to an existing memory body or frontmatter, use memory_open to get the path, then edit_file. Before creating a new memory, merge related updates into an existing memory when they share the same topic or decision thread. New memories require name, description, body, and at least one tag because memory hints only use tags. When updating by id, omitted fields keep their existing values; passing tags replaces the full tag list.",
-      parameters: Type.Object({
-        id: Type.Optional(Type.String({ description: "Existing memory id to update. Omit to create a new memory." })),
-        name: Type.Optional(Type.String({ description: "Memory name. Required when creating." })),
-        description: Type.Optional(Type.String({ description: "Short natural-language summary shown in memory hint. Required when creating." })),
-        body: Type.Optional(Type.String({ description: "Markdown memory body. Required when creating." })),
-        tags: Type.Optional(Type.Array(Type.String(), { description: "Tags used for memory hint. Required and non-empty when creating; replaces tags when updating. Prefer stable retrieval keys: project name, technology, feature/domain, user/person, and decision topic. Use lowercase kebab-case when possible. Use shared tags to keep related facts discoverable and merge them into one memory when they belong to the same topic. Examples: ['march-cli', 'tooling', 'permissions'], ['memory', 'sqlite-index']." })),
-      }),
-      execute: async (_toolCallId, params) => {
-        try {
-          const entry = store.save(params);
-          return toolText(
-            `Saved ${entry.id}\npath: ${entry.path}\ntags: ${entry.tags.join(", ")}`,
-            { memory: entry },
-          );
-        } catch (err) {
-          return toolText(`Error: ${err.message}`, { error: true });
-        }
-      },
-    }),
-
-    defineTool({
-      name: "memory_delete",
-      label: "Memory Delete",
-      description: "Soft-delete a Markdown memory by id or path. This marks status as deleted so memory hint and memory_search exclude it; the file remains on disk for audit/recovery.",
-      parameters: Type.Object({
-        id: Type.Optional(Type.String({ description: "Memory id to delete, e.g. mem_..." })),
-        path: Type.Optional(Type.String({ description: "Memory file path to delete" })),
-      }),
-      execute: async (_toolCallId, params) => {
-        try {
-          const identifier = params.id || params.path;
-          const result = store.delete(identifier);
-          if (result.alreadyDeleted) return toolText(`Memory ${result.id} is already deleted.\npath: ${result.path}`, { memory: result });
-          return toolText(`Deleted ${result.id}\npath: ${result.path}`, { memory: result });
-        } catch (err) {
-          return toolText(`Error: ${err.message}`, { error: true });
-        }
-      },
-    }),
-  ];
-}
-
-function formatMemorySearchMiss(query) {
-  const text = String(query ?? "");
-  const lines = [
-    `No memory files matched "${text}".`,
-    "memory_search is literal ripgrep over Markdown files; it is not semantic search and does not use memory-hint hints.",
-  ];
-  if (/^mem_[a-z0-9_\-]+$/i.test(text.trim())) {
-    lines.push("This looks like a memory id. Use memory_open({ id }) to open it directly.");
-  }
-  return lines.join("\n");
-}
+import { defineTool } from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import { toolText } from "../agent/tool-result.mjs";
+
+export function createMarkdownMemoryTools(store) {
+  if (!store) return [];
+  return [
+    defineTool({
+      name: "memory_search",
+      label: "Memory Search",
+      description:
+        "Search the Markdown memory vault using ripgrep. This is literal text search over memory Markdown files, not semantic search and not March's internal tags-only memory hint recall. Use it when memory hints are insufficient or you need to find a memory by phrase, term, or detail.",
+      parameters: Type.Object({
+        query: Type.String({ description: "Ripgrep query to search in Markdown memory files" }),
+        limit: Type.Optional(Type.Number({ description: "Maximum matching lines to return. Default: 20" })),
+      }),
+      execute: async (_toolCallId, params) => {
+        const results = store.searchRipgrep(params.query, { limit: params.limit ?? 20 });
+        if (results.length === 0) return toolText(formatMemorySearchMiss(params.query));
+        return toolText(results.map((result) => result.line).join("\n"), { results });
+      },
+    }),
+
+    defineTool({
+      name: "memory_open",
+      label: "Memory Open",
+      description: "Open a Markdown memory by id or by path. Use this after memory hint or memory_search when you need the full memory body. To edit an existing memory, use the returned path with edit_file for targeted edits.",
+      parameters: Type.Object({
+        id: Type.Optional(Type.String({ description: "Memory id from memory hint, e.g. mem_..." })),
+        path: Type.Optional(Type.String({ description: "Path returned by memory_search" })),
+      }),
+      execute: async (_toolCallId, params) => {
+        try {
+          const identifier = params.id || params.path;
+          const opened = store.open(identifier);
+          return toolText(
+            `path: ${opened.path}\nUse edit_file with this path for targeted edits.\n\n---\n${opened.content}`,
+            opened,
+          );
+        } catch (err) {
+          return toolText(`Error: ${err.message}`, { error: true });
+        }
+      },
+    }),
+
+    defineTool({
+      name: "memory_save",
+      label: "Memory Save",
+      description:
+        "Create a Markdown memory or update whole fields on an existing memory. For targeted edits to an existing memory body or frontmatter, use memory_open to get the path, then edit_file. Before creating a new memory, merge related updates into an existing memory when they share the same topic or decision thread. New memories require name, description, body, and at least one tag because memory hints only use tags. When updating by id, omitted fields keep their existing values; passing tags replaces the full tag list.",
+      parameters: Type.Object({
+        id: Type.Optional(Type.String({ description: "Existing memory id to update. Omit to create a new memory." })),
+        name: Type.Optional(Type.String({ description: "Memory name. Required when creating." })),
+        description: Type.Optional(Type.String({ description: "Short natural-language summary shown in memory hint. Required when creating." })),
+        body: Type.Optional(Type.String({ description: "Markdown memory body. Required when creating." })),
+        tags: Type.Optional(Type.Array(Type.String(), { description: "Tags used for memory hint. Required and non-empty when creating; replaces tags when updating. Prefer stable retrieval keys: project name, technology, feature/domain, user/person, and decision topic. Use lowercase kebab-case when possible. Use shared tags to keep related facts discoverable and merge them into one memory when they belong to the same topic. Examples: ['march-cli', 'tooling', 'permissions'], ['memory', 'sqlite-index']." })),
+      }),
+      execute: async (_toolCallId, params) => {
+        try {
+          const entry = store.save(params);
+          return toolText(
+            `Saved ${entry.id}\npath: ${entry.path}\ntags: ${entry.tags.join(", ")}`,
+            { memory: entry },
+          );
+        } catch (err) {
+          return toolText(`Error: ${err.message}`, { error: true });
+        }
+      },
+    }),
+
+    defineTool({
+      name: "memory_delete",
+      label: "Memory Delete",
+      description: "Soft-delete a Markdown memory by id or path. This marks status as deleted so memory hint and memory_search exclude it; the file remains on disk for audit/recovery.",
+      parameters: Type.Object({
+        id: Type.Optional(Type.String({ description: "Memory id to delete, e.g. mem_..." })),
+        path: Type.Optional(Type.String({ description: "Memory file path to delete" })),
+      }),
+      execute: async (_toolCallId, params) => {
+        try {
+          const identifier = params.id || params.path;
+          const result = store.delete(identifier);
+          if (result.alreadyDeleted) return toolText(`Memory ${result.id} is already deleted.\npath: ${result.path}`, { memory: result });
+          return toolText(`Deleted ${result.id}\npath: ${result.path}`, { memory: result });
+        } catch (err) {
+          return toolText(`Error: ${err.message}`, { error: true });
+        }
+      },
+    }),
+  ];
+}
+
+function formatMemorySearchMiss(query) {
+  const text = String(query ?? "");
+  const lines = [
+    `No memory files matched "${text}".`,
+    "memory_search is literal ripgrep over Markdown files; it is not semantic search and does not use memory-hint hints.",
+  ];
+  if (/^mem_[a-z0-9_\-]+$/i.test(text.trim())) {
+    lines.push("This looks like a memory id. Use memory_open({ id }) to open it directly.");
+  }
+  return lines.join("\n");
+}

package/src/memory/search.mjs

@@ -1,142 +1,142 @@
-export class SearchIndexer {
-  constructor(db) {
-    this.db = db;
-    this.#ensureSchema();
-  }
-
-  #ensureSchema() {
-    this.db.exec(`
-      CREATE VIRTUAL TABLE IF NOT EXISTS search_fts USING fts5(
-        node_uuid,
-        namespace,
-        content,
-        tokenize = 'porter unicode61'
-      );
-    `);
-  }
-
-  /**
-   * Index a memory's content for full-text search.
-   * Replaces any existing entry for the same (node_uuid, namespace).
-   */
-  index(nodeUuid, content, namespace = "") {
-    this.remove(nodeUuid, namespace);
-    this.db.prepare(
-      "INSERT INTO search_fts (node_uuid, namespace, content) VALUES (?, ?, ?)",
-    ).run(nodeUuid, namespace, content);
-  }
-
-  /**
-   * Remove a document from the FTS index.
-   */
-  remove(nodeUuid, namespace = "") {
-    this.db.prepare(
-      "DELETE FROM search_fts WHERE node_uuid = ? AND namespace = ?",
-    ).run(nodeUuid, namespace);
-  }
-
-  /**
-   * Full-text search with ranking.
-   * Returns matching node UUIDs, ranked by relevance.
-   */
-  search(query, { namespace = "", limit = 20, offset = 0 } = {}) {
-    // Sanitize FTS5 query: escape special chars, wrap in quotes for phrase matching
-    const sanitized = query.replace(/["*()]/g, "").trim();
-    if (!sanitized) return [];
-
-    const ftsQuery = sanitized.split(/\s+/).map(w => `"${w}"`).join(" OR ");
-
-    let sql;
-    let params;
-    if (namespace) {
-      sql = `
-        SELECT node_uuid, namespace, content,
-               rank AS score,
-               snippet(search_fts, 1, '<mark>', '</mark>', '...', 32) AS snippet
-        FROM search_fts
-        WHERE search_fts MATCH ? AND namespace = ?
-        ORDER BY rank
-        LIMIT ? OFFSET ?
-      `;
-      params = [ftsQuery, namespace, limit, offset];
-    } else {
-      sql = `
-        SELECT node_uuid, namespace, content,
-               rank AS score,
-               snippet(search_fts, 1, '<mark>', '</mark>', '...', 32) AS snippet
-        FROM search_fts
-        WHERE search_fts MATCH ?
-        ORDER BY rank
-        LIMIT ? OFFSET ?
-      `;
-      params = [ftsQuery, limit, offset];
-    }
-
-    return this.db.prepare(sql).all(...params);
-  }
-
-  /**
-   * Quick count of indexed documents.
-   */
-  count(namespace = "") {
-    if (namespace) {
-      return this.db.prepare("SELECT COUNT(*) AS cnt FROM search_fts WHERE namespace = ?").get(namespace).cnt;
-    }
-    return this.db.prepare("SELECT COUNT(*) AS cnt FROM search_fts").get().cnt;
-  }
-
-  /**
-   * Delete all entries for a namespace.
-   */
-  clearNamespace(namespace) {
-    const result = this.db.prepare("DELETE FROM search_fts WHERE namespace = ?").run(namespace);
-    return result.changes;
-  }
-
-  /**
-   * Rebuild the FTS index from the search_documents table.
-   */
-  rebuildFromDocuments() {
-    this.db.exec("DELETE FROM search_fts");
-    const docs = this.db.prepare("SELECT * FROM search_documents").all();
-    const insert = this.db.prepare(
-      "INSERT INTO search_fts (node_uuid, namespace, content) VALUES (?, ?, ?)",
-    );
-    for (const doc of docs) {
-      insert.run(doc.node_uuid, doc.namespace, doc.content);
-    }
-    return docs.length;
-  }
-
-  /**
-   * Suggest completions based on prefix matching.
-   */
-  suggest(prefix, { namespace = "", limit = 8 } = {}) {
-    const sanitized = prefix.replace(/[*"]/g, "").trim();
-    if (!sanitized || sanitized.length < 2) return [];
-
-    let sql;
-    let params;
-    if (namespace) {
-      sql = `
-        SELECT DISTINCT content
-        FROM search_fts
-        WHERE search_fts MATCH ? AND namespace = ?
-        ORDER BY rank
-        LIMIT ?
-      `;
-      params = [`"${sanitized}"*`, namespace, limit];
-    } else {
-      sql = `
-        SELECT DISTINCT content
-        FROM search_fts
-        WHERE search_fts MATCH ?
-        ORDER BY rank
-        LIMIT ?
-      `;
-      params = [`"${sanitized}"*`, limit];
-    }
-
-    return this.db.prepare(sql).all(...params).map(r => r.content);
-  }
-}
+export class SearchIndexer {
+  constructor(db) {
+    this.db = db;
+    this.#ensureSchema();
+  }
+
+  #ensureSchema() {
+    this.db.exec(`
+      CREATE VIRTUAL TABLE IF NOT EXISTS search_fts USING fts5(
+        node_uuid,
+        namespace,
+        content,
+        tokenize = 'porter unicode61'
+      );
+    `);
+  }
+
+  /**
+   * Index a memory's content for full-text search.
+   * Replaces any existing entry for the same (node_uuid, namespace).
+   */
+  index(nodeUuid, content, namespace = "") {
+    this.remove(nodeUuid, namespace);
+    this.db.prepare(
+      "INSERT INTO search_fts (node_uuid, namespace, content) VALUES (?, ?, ?)",
+    ).run(nodeUuid, namespace, content);
+  }
+
+  /**
+   * Remove a document from the FTS index.
+   */
+  remove(nodeUuid, namespace = "") {
+    this.db.prepare(
+      "DELETE FROM search_fts WHERE node_uuid = ? AND namespace = ?",
+    ).run(nodeUuid, namespace);
+  }
+
+  /**
+   * Full-text search with ranking.
+   * Returns matching node UUIDs, ranked by relevance.
+   */
+  search(query, { namespace = "", limit = 20, offset = 0 } = {}) {
+    // Sanitize FTS5 query: escape special chars, wrap in quotes for phrase matching
+    const sanitized = query.replace(/["*()]/g, "").trim();
+    if (!sanitized) return [];
+
+    const ftsQuery = sanitized.split(/\s+/).map(w => `"${w}"`).join(" OR ");
+
+    let sql;
+    let params;
+    if (namespace) {
+      sql = `
+        SELECT node_uuid, namespace, content,
+               rank AS score,
+               snippet(search_fts, 1, '<mark>', '</mark>', '...', 32) AS snippet
+        FROM search_fts
+        WHERE search_fts MATCH ? AND namespace = ?
+        ORDER BY rank
+        LIMIT ? OFFSET ?
+      `;
+      params = [ftsQuery, namespace, limit, offset];
+    } else {
+      sql = `
+        SELECT node_uuid, namespace, content,
+               rank AS score,
+               snippet(search_fts, 1, '<mark>', '</mark>', '...', 32) AS snippet
+        FROM search_fts
+        WHERE search_fts MATCH ?
+        ORDER BY rank
+        LIMIT ? OFFSET ?
+      `;
+      params = [ftsQuery, limit, offset];
+    }
+
+    return this.db.prepare(sql).all(...params);
+  }
+
+  /**
+   * Quick count of indexed documents.
+   */
+  count(namespace = "") {
+    if (namespace) {
+      return this.db.prepare("SELECT COUNT(*) AS cnt FROM search_fts WHERE namespace = ?").get(namespace).cnt;
+    }
+    return this.db.prepare("SELECT COUNT(*) AS cnt FROM search_fts").get().cnt;
+  }
+
+  /**
+   * Delete all entries for a namespace.
+   */
+  clearNamespace(namespace) {
+    const result = this.db.prepare("DELETE FROM search_fts WHERE namespace = ?").run(namespace);
+    return result.changes;
+  }
+
+  /**
+   * Rebuild the FTS index from the search_documents table.
+   */
+  rebuildFromDocuments() {
+    this.db.exec("DELETE FROM search_fts");
+    const docs = this.db.prepare("SELECT * FROM search_documents").all();
+    const insert = this.db.prepare(
+      "INSERT INTO search_fts (node_uuid, namespace, content) VALUES (?, ?, ?)",
+    );
+    for (const doc of docs) {
+      insert.run(doc.node_uuid, doc.namespace, doc.content);
+    }
+    return docs.length;
+  }
+
+  /**
+   * Suggest completions based on prefix matching.
+   */
+  suggest(prefix, { namespace = "", limit = 8 } = {}) {
+    const sanitized = prefix.replace(/[*"]/g, "").trim();
+    if (!sanitized || sanitized.length < 2) return [];
+
+    let sql;
+    let params;
+    if (namespace) {
+      sql = `
+        SELECT DISTINCT content
+        FROM search_fts
+        WHERE search_fts MATCH ? AND namespace = ?
+        ORDER BY rank
+        LIMIT ?
+      `;
+      params = [`"${sanitized}"*`, namespace, limit];
+    } else {
+      sql = `
+        SELECT DISTINCT content
+        FROM search_fts
+        WHERE search_fts MATCH ?
+        ORDER BY rank
+        LIMIT ?
+      `;
+      params = [`"${sanitized}"*`, limit];
+    }
+
+    return this.db.prepare(sql).all(...params).map(r => r.content);
+  }
+}

package/src/memory/snapshot.mjs

@@ -1,86 +1,86 @@
-export class ChangesetStore {
-  constructor(db) {
-    this.db = db;
-    this.#ensureSchema();
-  }
-
-  #ensureSchema() {
-    this.db.exec(`
-      CREATE TABLE IF NOT EXISTS changesets (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        memory_id INTEGER NOT NULL REFERENCES memories(id),
-        node_uuid TEXT NOT NULL REFERENCES nodes(uuid),
-        before_content TEXT,
-        after_content TEXT,
-        created_at TEXT NOT NULL DEFAULT (datetime('now'))
-      );
-      CREATE INDEX IF NOT EXISTS idx_changesets_node ON changesets(node_uuid);
-      CREATE INDEX IF NOT EXISTS idx_changesets_memory ON changesets(memory_id);
-    `);
-  }
-
-  /**
-   * Record a before/after snapshot for a memory update.
-   * @param {number} memoryId - the NEW memory id
-   * @param {string} nodeUuid
-   * @param {string|null} beforeContent - previous content (null if creation)
-   * @param {string} afterContent - new content
-   */
-  record({ memoryId, nodeUuid, beforeContent, afterContent }) {
-    const result = this.db.prepare(
-      "INSERT INTO changesets (memory_id, node_uuid, before_content, after_content) VALUES (?, ?, ?, ?)",
-    ).run(memoryId, nodeUuid, beforeContent ?? null, afterContent);
-    return { id: Number(result.lastInsertRowid), memory_id: memoryId, node_uuid: nodeUuid };
-  }
-
-  /**
-   * Get all changesets for a node, most recent first.
-   */
-  getHistory(nodeUuid, limit = 50) {
-    return this.db.prepare(
-      "SELECT * FROM changesets WHERE node_uuid = ? ORDER BY id DESC LIMIT ?",
-    ).all(nodeUuid, limit);
-  }
-
-  /**
-   * Get the most recent changesets across all nodes.
-   */
-  getRecent(limit = 30) {
-    return this.db.prepare(
-      "SELECT * FROM changesets ORDER BY id DESC LIMIT ?",
-    ).all(limit);
-  }
-
-  /**
-   * Get a specific changeset by id.
-   */
-  getById(id) {
-    return this.db.prepare("SELECT * FROM changesets WHERE id = ?").get(id);
-  }
-
-  /**
-   * Get the diff summary for a changeset — useful for display.
-   */
-  diff(changeset) {
-    const before = changeset.before_content ?? "";
-    const after = changeset.after_content ?? "";
-    if (!before) return { type: "create", linesAdded: after.split("\n").length };
-    if (!after) return { type: "delete", linesRemoved: before.split("\n").length };
-
-    const beforeLines = before.split("\n");
-    const afterLines = after.split("\n");
-    const added = afterLines.filter((l) => !before.includes(l)).length;
-    const removed = beforeLines.filter((l) => !after.includes(l)).length;
-    return { type: "update", linesAdded: Math.max(0, afterLines.length - beforeLines.length), linesRemoved: Math.max(0, beforeLines.length - afterLines.length), changedLines: added + removed };
-  }
-
-  /**
-   * Delete changesets older than the given number of days.
-   */
-  pruneOlderThan(days) {
-    const result = this.db.prepare(
-      "DELETE FROM changesets WHERE created_at < datetime('now', ?)",
-    ).run(`-${days} days`);
-    return result.changes;
-  }
-}
+export class ChangesetStore {
+  constructor(db) {
+    this.db = db;
+    this.#ensureSchema();
+  }
+
+  #ensureSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS changesets (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        memory_id INTEGER NOT NULL REFERENCES memories(id),
+        node_uuid TEXT NOT NULL REFERENCES nodes(uuid),
+        before_content TEXT,
+        after_content TEXT,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+      CREATE INDEX IF NOT EXISTS idx_changesets_node ON changesets(node_uuid);
+      CREATE INDEX IF NOT EXISTS idx_changesets_memory ON changesets(memory_id);
+    `);
+  }
+
+  /**
+   * Record a before/after snapshot for a memory update.
+   * @param {number} memoryId - the NEW memory id
+   * @param {string} nodeUuid
+   * @param {string|null} beforeContent - previous content (null if creation)
+   * @param {string} afterContent - new content
+   */
+  record({ memoryId, nodeUuid, beforeContent, afterContent }) {
+    const result = this.db.prepare(
+      "INSERT INTO changesets (memory_id, node_uuid, before_content, after_content) VALUES (?, ?, ?, ?)",
+    ).run(memoryId, nodeUuid, beforeContent ?? null, afterContent);
+    return { id: Number(result.lastInsertRowid), memory_id: memoryId, node_uuid: nodeUuid };
+  }
+
+  /**
+   * Get all changesets for a node, most recent first.
+   */
+  getHistory(nodeUuid, limit = 50) {
+    return this.db.prepare(
+      "SELECT * FROM changesets WHERE node_uuid = ? ORDER BY id DESC LIMIT ?",
+    ).all(nodeUuid, limit);
+  }
+
+  /**
+   * Get the most recent changesets across all nodes.
+   */
+  getRecent(limit = 30) {
+    return this.db.prepare(
+      "SELECT * FROM changesets ORDER BY id DESC LIMIT ?",
+    ).all(limit);
+  }
+
+  /**
+   * Get a specific changeset by id.
+   */
+  getById(id) {
+    return this.db.prepare("SELECT * FROM changesets WHERE id = ?").get(id);
+  }
+
+  /**
+   * Get the diff summary for a changeset — useful for display.
+   */
+  diff(changeset) {
+    const before = changeset.before_content ?? "";
+    const after = changeset.after_content ?? "";
+    if (!before) return { type: "create", linesAdded: after.split("\n").length };
+    if (!after) return { type: "delete", linesRemoved: before.split("\n").length };
+
+    const beforeLines = before.split("\n");
+    const afterLines = after.split("\n");
+    const added = afterLines.filter((l) => !before.includes(l)).length;
+    const removed = beforeLines.filter((l) => !after.includes(l)).length;
+    return { type: "update", linesAdded: Math.max(0, afterLines.length - beforeLines.length), linesRemoved: Math.max(0, beforeLines.length - afterLines.length), changedLines: added + removed };
+  }
+
+  /**
+   * Delete changesets older than the given number of days.
+   */
+  pruneOlderThan(days) {
+    const result = this.db.prepare(
+      "DELETE FROM changesets WHERE created_at < datetime('now', ?)",
+    ).run(`-${days} days`);
+    return result.changes;
+  }
+}