codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/tests/test-results.js

@@ -0,0 +1,234 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var test_results_exports = {};
+__export(test_results_exports, {
+  MAX_REPORT_BYTES: () => MAX_REPORT_BYTES,
+  TestReportError: () => TestReportError,
+  ingestTestReport: () => ingestTestReport,
+  listTestReports: () => listTestReports,
+  listTestResults: () => listTestResults,
+  setReportListener: () => setReportListener,
+  testResultsAt: () => testResultsAt,
+  testsSummary: () => testsSummary
+});
+module.exports = __toCommonJS(test_results_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = __toESM(require("node:crypto"));
+var import_database = require("../database");
+var import_persistence = require("../persistence");
+var import_confined_fs = require("../confined-fs");
+var import_junit = require("./junit");
+var import_retention = require("../retention");
+const MAX_REPORT_BYTES = 20 * 1024 * 1024;
+class TestReportError extends Error {
+  constructor(status, message) {
+    super(message);
+    this.status = status;
+  }
+  status;
+}
+const keyOf = (c) => JSON.stringify([c.suite ?? "", c.classname ?? "", c.name]);
+function reportRow(r) {
+  return {
+    id: Number(r[0]),
+    path: String(r[1]),
+    tests: Number(r[2]),
+    passed: Number(r[3]),
+    failed: Number(r[4]),
+    errors: Number(r[5]),
+    skipped: Number(r[6]),
+    ranAt: Number(r[7]),
+    reportedAt: Number(r[8]),
+    reportedBy: String(r[9]),
+    reportedByType: String(r[10])
+  };
+}
+const REPORT_COLS = "id, path, tests, passed, failed, errors, skipped, ran_at, reported_at, reported_by, reported_by_type";
+function ingestTestReport(projectRoot, candidate, by, now = Date.now()) {
+  let target;
+  try {
+    target = (0, import_confined_fs.resolveWithin)(projectRoot, import_node_path.default.isAbsolute(candidate) ? candidate : import_node_path.default.join(projectRoot, candidate), "test report");
+  } catch (err) {
+    if (err instanceof import_confined_fs.ConfinementError) throw new TestReportError(400, `${candidate} is not a file inside this project.`);
+    throw err;
+  }
+  let st;
+  try {
+    st = import_node_fs.default.statSync(target);
+  } catch {
+    throw new TestReportError(404, `${candidate} does not exist.`);
+  }
+  if (!st.isFile()) throw new TestReportError(400, `${candidate} is not a file.`);
+  if (st.size > MAX_REPORT_BYTES) throw new TestReportError(413, `${candidate} is larger than a test report can be (20 MB).`);
+  let buf;
+  try {
+    buf = (0, import_confined_fs.readFileWithin)(projectRoot, target, "test report");
+  } catch (err) {
+    if (err instanceof import_confined_fs.ConfinementError) throw new TestReportError(400, `${candidate} could not be read: ${err.message}`);
+    throw err;
+  }
+  const parsed = (0, import_junit.parseJUnit)(buf.toString("utf8"));
+  if (!parsed) throw new TestReportError(422, `${candidate} is not a JUnit report. Most runners write one: vitest --reporter=junit, jest-junit, pytest --junitxml, go-junit-report, Playwright's junit reporter.`);
+  const rel = import_node_path.default.relative(projectRoot, target).split(import_node_path.default.sep).join("/");
+  const sha256 = import_node_crypto.default.createHash("sha256").update(buf).digest("hex");
+  const failing = parsed.cases.filter((c) => c.result === "failed" || c.result === "error").slice(0, 20).map((c) => ({ label: (0, import_junit.testLabel)(c), result: c.result, message: c.message }));
+  const db = (0, import_database.getDb)();
+  const ranAt = Math.round(st.mtimeMs);
+  const t = parsed.totals;
+  const known = db.exec(`SELECT ${REPORT_COLS} FROM test_reports WHERE project_root = ? AND sha256 = ?`, [projectRoot, sha256])[0]?.values[0];
+  if (known && ranAt <= reportRow(known).ranAt) return { report: reportRow(known), already: true, failing, truncated: parsed.truncated };
+  if (known) {
+    db.run(
+      "UPDATE test_reports SET path = ?, ran_at = ?, reported_at = ?, reported_by = ?, reported_by_type = ? WHERE id = ?",
+      [rel, ranAt, now, by.author, by.authorType, reportRow(known).id]
+    );
+  } else {
+    db.run(
+      `INSERT INTO test_reports (project_root, path, sha256, tests, passed, failed, errors, skipped, ran_at, reported_at, reported_by, reported_by_type)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [projectRoot, rel, sha256, t.tests, t.passed, t.failed, t.errors, t.skipped, ranAt, now, by.author, by.authorType]
+    );
+  }
+  const id = Number(db.exec("SELECT id FROM test_reports WHERE project_root = ? AND sha256 = ?", [projectRoot, sha256])[0].values[0][0]);
+  const cutoff = (0, import_retention.retentionCutoff)(now);
+  if (cutoff !== null) {
+    db.run(
+      "DELETE FROM test_report_cases WHERE report_id IN (SELECT id FROM test_reports WHERE project_root = ? AND reported_at < ?)",
+      [projectRoot, cutoff]
+    );
+  }
+  for (const c of parsed.cases) {
+    db.run(
+      `INSERT OR REPLACE INTO test_report_cases (report_id, test_key, suite, classname, name, file, result, duration_ms, message)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [id, keyOf(c), c.suite, c.classname, c.name, c.file, c.result, c.durationMs, c.message]
+    );
+  }
+  for (const c of parsed.cases) {
+    db.run(
+      `INSERT INTO test_results (project_root, test_key, suite, classname, name, file, result, duration_ms, message, report_id, ran_at)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+       ON CONFLICT(project_root, test_key) DO UPDATE SET
+         suite = excluded.suite, classname = excluded.classname, name = excluded.name, file = excluded.file,
+         result = excluded.result, duration_ms = excluded.duration_ms, message = excluded.message,
+         report_id = excluded.report_id, ran_at = excluded.ran_at
+       WHERE excluded.ran_at >= test_results.ran_at`,
+      [projectRoot, keyOf(c), c.suite, c.classname, c.name, c.file, c.result, c.durationMs, c.message, id, ranAt]
+    );
+  }
+  (0, import_persistence.markDirty)();
+  const report = reportRow(db.exec(`SELECT ${REPORT_COLS} FROM test_reports WHERE id = ?`, [id])[0].values[0]);
+  try {
+    reportListener?.({ projectRoot, path: rel, ranAt, by, totals: t, cases: parsed.cases });
+  } catch (err) {
+    console.warn("[Tests] sharing the run failed:", err);
+  }
+  return { report, already: false, failing, truncated: parsed.truncated };
+}
+let reportListener;
+function setReportListener(fn) {
+  reportListener = fn;
+}
+function listTestResults(projectRoot, opts = {}) {
+  const rows = (0, import_database.getDb)().exec(
+    `SELECT r.suite, r.classname, r.name, r.file, r.result, r.duration_ms, r.message, r.ran_at, p.path
+       FROM test_results r JOIN test_reports p ON p.id = r.report_id
+      WHERE r.project_root = ?`,
+    [projectRoot]
+  )[0]?.values ?? [];
+  const order = { error: 0, failed: 1, skipped: 2, passed: 3 };
+  const m = opts.match?.toLowerCase();
+  return rows.map((r) => {
+    const c = { suite: r[0], classname: r[1], name: String(r[2]), file: r[3] };
+    return {
+      ...c,
+      label: (0, import_junit.testLabel)(c),
+      result: r[4],
+      durationMs: r[5] ?? null,
+      message: r[6] ?? null,
+      ranAt: Number(r[7]),
+      reportPath: String(r[8])
+    };
+  }).filter((t) => !opts.result || t.result === opts.result).filter((t) => !m || [t.file, t.classname, t.suite].some((v) => v?.toLowerCase().includes(m))).sort((a, b) => order[a.result] - order[b.result] || a.label.localeCompare(b.label)).slice(0, opts.limit ?? 500);
+}
+function testResultsAt(projectRoot, at) {
+  const db = (0, import_database.getDb)();
+  const reports = db.exec(
+    "SELECT id, path, ran_at FROM test_reports WHERE project_root = ? AND reported_at <= ? ORDER BY ran_at, id",
+    [projectRoot, at]
+  )[0]?.values ?? [];
+  const byKey = /* @__PURE__ */ new Map();
+  for (const [id, reportPath, ranAt] of reports) {
+    let rows = db.exec(
+      "SELECT test_key, suite, classname, name, file, result, duration_ms, message FROM test_report_cases WHERE report_id = ?",
+      [id]
+    )[0]?.values ?? [];
+    if (rows.length === 0) {
+      rows = db.exec(
+        "SELECT test_key, suite, classname, name, file, result, duration_ms, message FROM test_results WHERE project_root = ? AND report_id = ?",
+        [projectRoot, id]
+      )[0]?.values ?? [];
+    }
+    for (const r of rows) {
+      const c = { suite: r[1], classname: r[2], name: String(r[3]), file: r[4] };
+      byKey.set(String(r[0]), {
+        ...c,
+        label: (0, import_junit.testLabel)(c),
+        result: r[5],
+        durationMs: r[6] ?? null,
+        message: r[7] ?? null,
+        ranAt: Number(ranAt),
+        reportPath: String(reportPath)
+      });
+    }
+  }
+  return [...byKey.values()];
+}
+function listTestReports(projectRoot, limit = 20) {
+  return ((0, import_database.getDb)().exec(`SELECT ${REPORT_COLS} FROM test_reports WHERE project_root = ? ORDER BY ran_at DESC, id DESC LIMIT ?`, [projectRoot, limit])[0]?.values ?? []).map(reportRow);
+}
+function testsSummary(projectRoot) {
+  const rows = (0, import_database.getDb)().exec("SELECT result, COUNT(*) FROM test_results WHERE project_root = ? GROUP BY result", [projectRoot])[0]?.values ?? [];
+  const n = (r) => Number(rows.find((x) => x[0] === r)?.[1] ?? 0);
+  const tests = rows.reduce((a, r) => a + Number(r[1]), 0);
+  const failing = n("failed") + n("error");
+  const words = tests === 0 ? "No test results yet: an agent hands over a JUnit report with report_tests." : `${tests} test${tests === 1 ? "" : "s"}, ${failing ? `${failing} failing` : "none failing"}${n("skipped") ? `, ${n("skipped")} skipped` : ""}`;
+  return { tests, passed: n("passed"), failing, skipped: n("skipped"), words };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MAX_REPORT_BYTES,
+  TestReportError,
+  ingestTestReport,
+  listTestReports,
+  listTestResults,
+  setReportListener,
+  testResultsAt,
+  testsSummary
+});

package/src/backend/services/tree-watcher.js

@@ -0,0 +1,204 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tree_watcher_exports = {};
+__export(tree_watcher_exports, {
+  usesNativeTreeWatcher: () => usesNativeTreeWatcher,
+  watchTree: () => watchTree
+});
+module.exports = __toCommonJS(tree_watcher_exports);
+var import_node_events = require("node:events");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_chokidar = __toESM(require("chokidar"));
+function usesNativeTreeWatcher(platform = process.platform) {
+  if (process.env.CODETRELLIS_TREE_WATCHER === "chokidar") return false;
+  return platform === "darwin";
+}
+function watchTree(root, opts = {}) {
+  if (!usesNativeTreeWatcher()) {
+    return import_chokidar.default.watch(root, { ignoreInitial: true, persistent: true, ...opts });
+  }
+  return new NativeTreeWatcher(root, opts);
+}
+const COALESCE_MS = 50;
+class NativeTreeWatcher extends import_node_events.EventEmitter {
+  constructor(root, opts) {
+    super();
+    this.root = root;
+    this.opts = opts;
+    try {
+      this.fsw = import_node_fs.default.watch(root, { recursive: true, persistent: true }, (_type, name) => {
+        if (this.closed) return;
+        if (!name) {
+          void this.rescan();
+          return;
+        }
+        this.report(import_node_path.default.join(root, name.toString()));
+      });
+      this.fsw.on("error", (err) => this.emit("error", err));
+    } catch (err) {
+      setImmediate(() => this.emit("error", err));
+    }
+    void this.walk(root, true).then(() => {
+      if (!this.closed) this.emit("ready");
+    });
+  }
+  root;
+  opts;
+  seen = /* @__PURE__ */ new Map();
+  timers = /* @__PURE__ */ new Map();
+  fsw = null;
+  closed = false;
+  skip(p) {
+    if (p !== this.root && this.opts.ignored?.(p)) return true;
+    if (this.opts.depth === void 0) return false;
+    const rel = import_node_path.default.relative(this.root, p);
+    if (!rel || rel.startsWith("..")) return !!rel;
+    return rel.split(import_node_path.default.sep).length - 1 > this.opts.depth;
+  }
+  /** Record what is under `dir`; `quiet` for the first walk (ignoreInitial), else report what is new. */
+  async walk(dir, quiet) {
+    if (this.closed) return;
+    let entries;
+    try {
+      entries = await import_node_fs.default.promises.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const e of entries) {
+      const p = import_node_path.default.join(dir, e.name);
+      if (this.skip(p)) continue;
+      if (e.isDirectory()) {
+        const isNew = !this.seen.has(p);
+        this.seen.set(p, { dir: true });
+        if (isNew && !quiet) this.fire("addDir", p);
+        await this.walk(p, quiet);
+      } else {
+        if (this.seen.has(p)) continue;
+        const st = this.stat(p);
+        if (!st) continue;
+        this.seen.set(p, { dir: false, size: st.size, mtimeMs: st.mtimeMs });
+        if (!quiet) this.fire("add", p);
+      }
+    }
+  }
+  stat(p) {
+    try {
+      return import_node_fs.default.lstatSync(p);
+    } catch {
+      return null;
+    }
+  }
+  report(p) {
+    if (p === this.root || this.skip(p)) return;
+    const wait = this.opts.awaitWriteFinish?.stabilityThreshold ?? COALESCE_MS;
+    const prev = this.timers.get(p);
+    if (prev) clearTimeout(prev);
+    this.timers.set(p, setTimeout(() => {
+      this.timers.delete(p);
+      void this.settle(p);
+    }, wait));
+  }
+  /** Look at `p` and say what changed there. */
+  async settle(p) {
+    if (this.closed) return;
+    const st = this.stat(p);
+    const was = this.seen.get(p);
+    if (!st) {
+      if (!was) return;
+      if (was.dir) this.forgetDir(p);
+      else {
+        this.seen.delete(p);
+        this.fire("unlink", p);
+      }
+      return;
+    }
+    if (st.isDirectory()) {
+      if (was && !was.dir) {
+        this.seen.delete(p);
+        this.fire("unlink", p);
+      }
+      if (!was || !was.dir) {
+        this.seen.set(p, { dir: true });
+        this.fire("addDir", p);
+      }
+      await this.walk(p, false);
+      return;
+    }
+    if (was?.dir) this.forgetDir(p);
+    const now = { dir: false, size: st.size, mtimeMs: st.mtimeMs };
+    this.seen.set(p, now);
+    if (!was || was.dir) this.fire("add", p);
+    else if (was.size !== now.size || was.mtimeMs !== now.mtimeMs) this.fire("change", p);
+  }
+  forgetDir(dir) {
+    const prefix = dir + import_node_path.default.sep;
+    for (const [p, s] of [...this.seen]) {
+      if (!p.startsWith(prefix)) continue;
+      this.seen.delete(p);
+      this.fire(s.dir ? "unlinkDir" : "unlink", p);
+    }
+    this.seen.delete(dir);
+    this.fire("unlinkDir", dir);
+  }
+  /** A flood dropped the names: compare everything recorded with what is there. */
+  async rescan() {
+    for (const p of [...this.seen.keys()]) {
+      if (!import_node_fs.default.existsSync(p)) await this.settle(p);
+    }
+    await this.walk(this.root, false);
+  }
+  fire(event, p) {
+    if (this.closed) return;
+    this.emit(event, p);
+    this.emit("all", event, p);
+  }
+  getWatched() {
+    const out = { [this.root]: [] };
+    for (const [p, s] of this.seen) {
+      if (s.dir) out[p] ??= [];
+      const parent = import_node_path.default.dirname(p);
+      (out[parent] ??= []).push(import_node_path.default.basename(p));
+    }
+    for (const k of Object.keys(out)) out[k].sort();
+    return out;
+  }
+  async close() {
+    this.closed = true;
+    this.fsw?.close();
+    this.fsw = null;
+    for (const t of this.timers.values()) clearTimeout(t);
+    this.timers.clear();
+    this.removeAllListeners();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  usesNativeTreeWatcher,
+  watchTree
+});

package/src/backend/services/trellis-service.js

@@ -0,0 +1,204 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var trellis_service_exports = {};
+__export(trellis_service_exports, {
+  captureCurrentTrellis: () => captureCurrentTrellis,
+  computeTrellisDiff: () => computeTrellisDiff,
+  getSnapshot: () => getSnapshot,
+  listSnapshots: () => listSnapshots,
+  readLiveGraph: () => readLiveGraph
+});
+module.exports = __toCommonJS(trellis_service_exports);
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_git_checkout = require("./git-checkout");
+function readLiveGraph() {
+  const db = (0, import_database.getDb)();
+  let edges = [];
+  try {
+    edges = (0, import_database.getDependencyEdges)();
+  } catch {
+  }
+  const counts = /* @__PURE__ */ new Map();
+  const countRows = db.exec(
+    `SELECT f.relative_path, COUNT(s.id) FROM files f
+     LEFT JOIN symbols s ON s.file_id = f.id AND s.parent_symbol_id IS NULL
+     GROUP BY f.id`
+  );
+  for (const r of countRows[0]?.values ?? []) counts.set(r[0], Number(r[1]) || 0);
+  const filesResult = db.exec(`SELECT relative_path, content_hash, language FROM files`);
+  const files = (filesResult[0]?.values || []).map((r) => ({
+    path: r[0],
+    contentHash: r[1],
+    language: r[2],
+    symbolCount: counts.get(r[0]) ?? 0
+  }));
+  return {
+    files,
+    edges: edges.map((e) => ({ source: e.sourceRelative, target: e.targetRelative, specifiers: e.specifiers }))
+  };
+}
+function captureCurrentTrellis(projectPath, planUid, name) {
+  const db = (0, import_database.getDb)();
+  const { files, edges: edgesData } = readLiveGraph();
+  const gitBranch = (0, import_git_checkout.currentBranch)(projectPath);
+  const snapshotName = name || `Snapshot at ${(/* @__PURE__ */ new Date()).toLocaleString()}`;
+  const now = Date.now();
+  db.run(
+    `INSERT INTO trellis_snapshots (name, snapshot_type, plan_uid, git_branch, files_json, edges_json, created_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    [
+      snapshotName,
+      planUid ? "current" : "checkpoint",
+      planUid || null,
+      gitBranch,
+      JSON.stringify(files),
+      JSON.stringify(edgesData),
+      now
+    ]
+  );
+  const idResult = db.exec(`SELECT last_insert_rowid()`);
+  const id = idResult[0]?.values[0]?.[0] || 0;
+  (0, import_persistence.markDirty)();
+  console.log(`[Trellis] Captured snapshot #${id}: "${snapshotName}" (${files.length} files, ${edgesData.length} edges)`);
+  return {
+    id,
+    name: snapshotName,
+    snapshotType: planUid ? "current" : "checkpoint",
+    planUid: planUid || null,
+    gitBranch,
+    filesJson: JSON.stringify(files),
+    edgesJson: JSON.stringify(edgesData),
+    createdAt: now
+  };
+}
+function getSnapshot(id) {
+  const result = (0, import_database.getDb)().exec(
+    `SELECT t.id, t.name, t.snapshot_type, t.plan_uid, t.git_branch,
+            COALESCE(o.files_json, t.files_json), COALESCE(o.edges_json, t.edges_json), t.created_at
+     FROM trellis_snapshots t LEFT JOIN trellis_snapshots o ON o.id = t.same_as
+     WHERE t.id = ?`,
+    [id]
+  );
+  if (!result[0]?.values[0]) return null;
+  const r = result[0].values[0];
+  return {
+    id: r[0],
+    name: r[1],
+    snapshotType: r[2],
+    planUid: r[3],
+    gitBranch: r[4],
+    filesJson: r[5],
+    edgesJson: r[6],
+    createdAt: r[7],
+    data: {
+      files: JSON.parse(r[5]),
+      edges: JSON.parse(r[6])
+    }
+  };
+}
+function listSnapshots(planUid) {
+  let query = `SELECT id, name, snapshot_type, plan_uid, git_branch, files_json, edges_json, created_at FROM trellis_snapshots
+    WHERE snapshot_type != 'frame'`;
+  const params = [];
+  if (planUid) {
+    query += ` AND plan_uid = ?`;
+    params.push(planUid);
+  }
+  query += ` ORDER BY created_at DESC`;
+  const result = (0, import_database.getDb)().exec(query, params);
+  if (!result[0]) return [];
+  return result[0].values.map((r) => ({
+    id: r[0],
+    name: r[1],
+    snapshotType: r[2],
+    planUid: r[3],
+    gitBranch: r[4],
+    createdAt: r[7],
+    fileCount: JSON.parse(r[5]).length,
+    edgeCount: JSON.parse(r[6]).length
+  }));
+}
+function computeTrellisDiff(snapshotId) {
+  const snapshot = getSnapshot(snapshotId);
+  if (!snapshot) return null;
+  const snapshotFiles = new Map(snapshot.data.files.map((f) => [f.path, f.contentHash]));
+  const snapshotEdges = new Set(snapshot.data.edges.map((e) => `${e.source}->${e.target}`));
+  let liveEdges = [];
+  try {
+    liveEdges = (0, import_database.getDependencyEdges)();
+  } catch {
+  }
+  const liveFiles = /* @__PURE__ */ new Map();
+  const filesResult = (0, import_database.getDb)().exec(`SELECT relative_path, content_hash FROM files`);
+  if (filesResult[0]) {
+    for (const r of filesResult[0].values) {
+      liveFiles.set(r[0], r[1]);
+    }
+  }
+  const liveEdgeSet = new Set(liveEdges.map((e) => `${e.sourceRelative}->${e.targetRelative}`));
+  const addedFiles = [];
+  const removedFiles = [];
+  const modifiedFiles = [];
+  for (const [path, hash] of liveFiles) {
+    const snapshotHash = snapshotFiles.get(path);
+    if (!snapshotHash) {
+      addedFiles.push(path);
+    } else if (snapshotHash !== hash) {
+      modifiedFiles.push(path);
+    }
+  }
+  for (const path of snapshotFiles.keys()) {
+    if (!liveFiles.has(path)) {
+      removedFiles.push(path);
+    }
+  }
+  const addedEdgesArr = [];
+  const removedEdgesArr = [];
+  for (const edge of liveEdgeSet) {
+    if (!snapshotEdges.has(edge)) {
+      const [source, target] = edge.split("->");
+      addedEdgesArr.push({ source, target });
+    }
+  }
+  for (const edge of snapshotEdges) {
+    if (!liveEdgeSet.has(edge)) {
+      const [source, target] = edge.split("->");
+      removedEdgesArr.push({ source, target });
+    }
+  }
+  const totalFiles = snapshotFiles.size;
+  const changedFiles = addedFiles.length + modifiedFiles.length;
+  const progress = totalFiles > 0 ? Math.round(changedFiles / Math.max(totalFiles, changedFiles) * 100) : 0;
+  return {
+    addedFiles,
+    removedFiles,
+    modifiedFiles,
+    addedEdges: addedEdgesArr,
+    removedEdges: removedEdgesArr,
+    progress
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  captureCurrentTrellis,
+  computeTrellisDiff,
+  getSnapshot,
+  listSnapshots,
+  readLiveGraph
+});