codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/database.js

@@ -0,0 +1,916 @@
+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 database_exports = {};
+__export(database_exports, {
+  clearAstData: () => clearAstData,
+  exportDatabase: () => exportDatabase,
+  getAllFileHashes: () => getAllFileHashes,
+  getAllGraphEdges: () => getAllGraphEdges,
+  getArchitectureSummary: () => getArchitectureSummary,
+  getCallEdges: () => getCallEdges,
+  getDb: () => getDb,
+  getDbStats: () => getDbStats,
+  getDependencyEdges: () => getDependencyEdges,
+  getFileDependencies: () => getFileDependencies,
+  getFileFacts: () => getFileFacts,
+  getFileHash: () => getFileHash,
+  getFileSymbols: () => getFileSymbols,
+  getFileSymbolsWithMembers: () => getFileSymbolsWithMembers,
+  getImportResolutionContext: () => getImportResolutionContext,
+  getPackageEdges: () => getPackageEdges,
+  hasPatternCallsites: () => hasPatternCallsites,
+  initDatabase: () => initDatabase,
+  removeStaleFiles: () => removeStaleFiles,
+  replacePatternCallsites: () => replacePatternCallsites,
+  resolutionContextRoot: () => resolutionContextRoot,
+  resolveImports: () => resolveImports,
+  resolvePendingImports: () => resolvePendingImports,
+  searchSymbols: () => searchSymbols,
+  setImportResolutionContext: () => setImportResolutionContext,
+  storeParsedFile: () => storeParsedFile
+});
+module.exports = __toCommonJS(database_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_persistence = require("./persistence");
+var import_resolvers = require("./resolvers");
+var import_package_entry = require("../../shared/lib/package-entry");
+var import_call_entry = require("../../shared/lib/call-entry");
+var import_folder_entry = require("../../shared/lib/folder-entry");
+var import_schema_reconciler = require("./schema-reconciler");
+var import_importers = require("./importers");
+var import_db_schema = require("./db-schema");
+const BetterSqlite3 = require("better-sqlite3");
+let bdb = null;
+let db = null;
+function makeShim(conn) {
+  return {
+    run(sql, params) {
+      if (params && params.length) {
+        conn.prepare(sql).run(...params);
+      } else {
+        conn.exec(sql);
+      }
+    },
+    exec(sql, params) {
+      const stmt = conn.prepare(sql);
+      if (!stmt.reader) {
+        stmt.run(...params ?? []);
+        return [];
+      }
+      stmt.raw(true);
+      const values = stmt.all(...params ?? []);
+      if (values.length === 0) return [];
+      const columns = stmt.columns().map((c) => c.name);
+      return [{ columns, values }];
+    },
+    export() {
+      return conn.serialize();
+    },
+    close() {
+      conn.close();
+    }
+  };
+}
+function isDatabaseCorrupt(conn) {
+  try {
+    const result = conn.pragma("quick_check", { simple: true });
+    return result !== "ok";
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return /malformed|not a database|corrupt|disk image|encrypted/i.test(msg);
+  }
+}
+function quarantineCorruptDatabase(dbPath) {
+  const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+  for (const suffix of ["", "-wal", "-shm"]) {
+    const src = `${dbPath}${suffix}`;
+    if (!import_node_fs.default.existsSync(src)) continue;
+    const dest = `${dbPath}.corrupt-${stamp}${suffix}`;
+    try {
+      import_node_fs.default.renameSync(src, dest);
+      console.error(`[DB] Quarantined ${src} -> ${dest}`);
+    } catch {
+      try {
+        import_node_fs.default.unlinkSync(src);
+      } catch {
+      }
+    }
+  }
+}
+async function initDatabase() {
+  if (db) return;
+  (0, import_persistence.ensureDataDir)();
+  const dbPath = import_node_path.default.join((0, import_persistence.getDataDir)(), "data.db");
+  try {
+    bdb = new BetterSqlite3(dbPath);
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`[DB] Could not open data.db (${msg}) \u2014 quarantining and starting fresh`);
+    quarantineCorruptDatabase(dbPath);
+    bdb = new BetterSqlite3(dbPath);
+    console.warn("[DB] Recovered with an empty database \u2014 a scan will rebuild AST data, and plans re-import from .codetrellis/");
+  }
+  if (isDatabaseCorrupt(bdb)) {
+    console.error("[DB] Integrity check FAILED \u2014 quarantining corrupt data.db and rebuilding from scratch");
+    try {
+      bdb.close();
+    } catch {
+    }
+    quarantineCorruptDatabase(dbPath);
+    bdb = new BetterSqlite3(dbPath);
+  }
+  bdb.pragma("journal_mode = WAL");
+  bdb.pragma("synchronous = NORMAL");
+  bdb.pragma("busy_timeout = 5000");
+  db = makeShim(bdb);
+  console.log(`[DB] Opened native SQLite (better-sqlite3) at ${dbPath}`);
+  db.run(import_db_schema.SCHEMA_AST);
+  db.run(import_db_schema.SCHEMA_PLANS_CORE);
+  try {
+    db.run(`ALTER TABLE plans ADD COLUMN base_ref TEXT`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE plans ADD COLUMN target_branch TEXT`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE plans ADD COLUMN target_worktree TEXT`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE plans ADD COLUMN auto_create_branch INTEGER DEFAULT 0`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE tasks ADD COLUMN parent_task_uid TEXT`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE tasks ADD COLUMN body TEXT`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE tasks ADD COLUMN prompt TEXT`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE tasks ADD COLUMN scope_path TEXT`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE tasks ADD COLUMN file_specs TEXT DEFAULT '[]'`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE tasks ADD COLUMN progress_percent INTEGER`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE tasks ADD COLUMN blocked_reason TEXT`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE tasks ADD COLUMN phase_uid TEXT`);
+  } catch {
+  }
+  try {
+    db.run(`CREATE INDEX IF NOT EXISTS idx_tasks_parent ON tasks(parent_task_uid)`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE comments ADD COLUMN kind TEXT`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE comments ADD COLUMN source TEXT`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE comments ADD COLUMN metadata TEXT`);
+  } catch {
+  }
+  db.run(import_db_schema.SCHEMA_ATTACHMENTS);
+  db.run(import_db_schema.SCHEMA_PLAN_ITEMS);
+  try {
+    db.run(`ALTER TABLE plan_items ADD COLUMN skills TEXT NOT NULL DEFAULT '[]'`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE plan_items ADD COLUMN skills_mode TEXT DEFAULT 'inherit'`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE plan_items ADD COLUMN claim_policy TEXT DEFAULT NULL`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE plan_items ADD COLUMN claim_policy_mode TEXT DEFAULT 'inherit'`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE plan_items ADD COLUMN execution_config TEXT DEFAULT NULL`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE plan_items ADD COLUMN execution_config_mode TEXT DEFAULT 'inherit'`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE plan_items ADD COLUMN constraints TEXT DEFAULT NULL`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE plan_items ADD COLUMN constraints_mode TEXT DEFAULT 'inherit'`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE plan_items ADD COLUMN requires_approval INTEGER NOT NULL DEFAULT 0`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE agent_sessions ADD COLUMN capabilities TEXT NOT NULL DEFAULT '[]'`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE agent_sessions ADD COLUMN host_terminal_id TEXT DEFAULT NULL`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE agent_sessions ADD COLUMN brief_item_uid TEXT DEFAULT NULL`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE agent_sessions ADD COLUMN brief_bound_at INTEGER DEFAULT NULL`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE deviations ADD COLUMN file_path TEXT DEFAULT NULL`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE recent_projects ADD COLUMN origin_url TEXT DEFAULT NULL`);
+  } catch {
+  }
+  try {
+    db.run(`CREATE INDEX IF NOT EXISTS idx_recent_projects_origin ON recent_projects(origin_url)`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE plan_items ADD COLUMN visibility TEXT NOT NULL DEFAULT 'shared'`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE plan_items ADD COLUMN visibility_override INTEGER NOT NULL DEFAULT 0`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE plans ADD COLUMN home_repo TEXT DEFAULT NULL`);
+  } catch {
+  }
+  try {
+    db.run(`ALTER TABLE plans ADD COLUMN scope TEXT NOT NULL DEFAULT '[]'`);
+  } catch {
+  }
+  try {
+    db.run(`CREATE INDEX IF NOT EXISTS idx_plans_home_repo ON plans(home_repo)`);
+  } catch {
+  }
+  db.run(import_db_schema.SCHEMA_SYSTEM_DOCS);
+  db.run(import_db_schema.SCHEMA_EXTERNAL_REFS);
+  const reconcile = (0, import_schema_reconciler.reconcileSchemaFromSql)(db, import_db_schema.RECONCILED_SCHEMA_SQL, {
+    skipTables: import_db_schema.EPHEMERAL_TABLES
+  });
+  if (reconcile.columnsAdded.length > 0) {
+    console.log(
+      `[DB] Schema reconciler added ${reconcile.columnsAdded.length} column(s):`,
+      reconcile.columnsAdded.map((c) => `${c.table}.${c.column}`).join(", ")
+    );
+  }
+  if (reconcile.errors.length > 0) {
+    for (const e of reconcile.errors) {
+      console.warn(`[DB] Schema reconciler failed for ${e.table}.${e.column}: ${e.error}`);
+    }
+  }
+  console.log("[DB] SQLite initialized");
+}
+function getDb() {
+  if (!db) throw new Error("Database not initialized");
+  return db;
+}
+function exportDatabase() {
+  return getDb().export();
+}
+function clearAstData() {
+  const d = getDb();
+  d.run("BEGIN");
+  try {
+    try {
+      d.run(`DELETE FROM cross_system_edges`);
+    } catch {
+    }
+    try {
+      d.run(`DELETE FROM callsites`);
+    } catch {
+    }
+    d.run(`DELETE FROM imports`);
+    d.run(`DELETE FROM symbols`);
+    d.run(`DELETE FROM files`);
+    d.run("COMMIT");
+  } catch (err) {
+    try {
+      d.run("ROLLBACK");
+    } catch {
+    }
+    throw err;
+  }
+}
+function storeParsedFile(parsed, projectRoot) {
+  const d = getDb();
+  d.run("BEGIN");
+  try {
+    const relativePath = import_node_path.default.relative(projectRoot, parsed.path);
+    d.run(`DELETE FROM files WHERE path = ?`, [parsed.path]);
+    d.run(
+      `INSERT INTO files (path, relative_path, language, content_hash, last_parsed) VALUES (?, ?, ?, ?, ?)`,
+      [parsed.path, relativePath, parsed.language, parsed.contentHash, Date.now()]
+    );
+    const fileIdResult = d.exec(`SELECT last_insert_rowid() as id`);
+    const fileId = fileIdResult[0]?.values[0]?.[0];
+    for (const sym of parsed.symbols) {
+      insertSymbol(d, fileId, null, sym);
+    }
+    for (const imp of parsed.imports) {
+      d.run(
+        `INSERT INTO imports (file_id, source_path, specifiers, is_default, is_namespace, is_relative, is_reexport) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+        [fileId, imp.source, JSON.stringify(imp.specifiers), imp.isDefault ? 1 : 0, imp.isNamespace ? 1 : 0, imp.isRelative ? 1 : 0, imp.isReexport ? 1 : 0]
+      );
+    }
+    d.run(`DELETE FROM callsites WHERE file_id = ?`, [fileId]);
+    for (const cs of parsed.callsites ?? []) {
+      d.run(
+        `INSERT INTO callsites (file_id, kind, protocol, method, url_pattern, sql_text, line, context, host)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          fileId,
+          cs.kind,
+          cs.protocol,
+          cs.method ?? null,
+          cs.urlPattern ?? null,
+          cs.sqlText ?? null,
+          cs.line ?? null,
+          cs.context ?? null,
+          cs.host ?? null
+        ]
+      );
+    }
+    d.run("COMMIT");
+  } catch (err) {
+    try {
+      d.run("ROLLBACK");
+    } catch {
+    }
+    throw err;
+  }
+}
+function insertSymbol(d, fileId, parentId, sym) {
+  d.run(
+    `INSERT INTO symbols (file_id, parent_symbol_id, name, kind, start_line, end_line, modifiers) VALUES (?, ?, ?, ?, ?, ?, ?)`,
+    [fileId, parentId, sym.name, sym.kind, sym.startLine, sym.endLine, JSON.stringify(sym.modifiers)]
+  );
+  if (sym.children.length > 0) {
+    const symIdResult = d.exec(`SELECT last_insert_rowid() as id`);
+    const symId = symIdResult[0]?.values[0]?.[0];
+    for (const child of sym.children) {
+      insertSymbol(d, fileId, symId, child);
+    }
+  }
+}
+function searchSymbols(query) {
+  const d = getDb();
+  const results = d.exec(
+    `SELECT s.name, s.kind, f.path, f.relative_path, s.start_line, s.end_line
+     FROM symbols s
+     JOIN files f ON s.file_id = f.id
+     WHERE s.name LIKE ?
+     ORDER BY s.name
+     LIMIT 50`,
+    [`%${query}%`]
+  );
+  if (!results[0]) return [];
+  return results[0].values.map((row) => ({
+    name: row[0],
+    kind: row[1],
+    filePath: row[2],
+    relativePath: row[3],
+    startLine: row[4],
+    endLine: row[5]
+  }));
+}
+function getFileSymbolsWithMembers(filePath) {
+  const d = getDb();
+  const results = d.exec(
+    `SELECT CASE WHEN p.name IS NOT NULL THEN p.name || '.' || s.name ELSE s.name END,
+            s.kind, s.start_line, s.end_line, s.modifiers
+     FROM symbols s
+     JOIN files f ON s.file_id = f.id
+     LEFT JOIN symbols p ON s.parent_symbol_id = p.id
+     WHERE f.path = ?
+     ORDER BY s.start_line`,
+    [filePath]
+  );
+  return (results[0]?.values ?? []).map((r) => ({
+    name: r[0],
+    kind: r[1],
+    startLine: r[2],
+    endLine: r[3],
+    modifiers: r[4] ? JSON.parse(r[4]) : []
+  }));
+}
+function getFileSymbols(filePath) {
+  const d = getDb();
+  const results = d.exec(
+    `SELECT s.name, s.kind, s.start_line, s.end_line, s.modifiers
+     FROM symbols s
+     JOIN files f ON s.file_id = f.id
+     WHERE f.path = ? AND s.parent_symbol_id IS NULL
+     ORDER BY s.start_line`,
+    [filePath]
+  );
+  if (!results[0]) return [];
+  return results[0].values.map((row) => ({
+    name: row[0],
+    kind: row[1],
+    startLine: row[2],
+    endLine: row[3],
+    modifiers: JSON.parse(row[4] || "[]")
+  }));
+}
+function getFileHash(filePath) {
+  const d = getDb();
+  const results = d.exec(`SELECT content_hash FROM files WHERE path = ?`, [filePath]);
+  if (!results[0]?.values[0]) return null;
+  return results[0].values[0][0];
+}
+function getAllFileHashes() {
+  const d = getDb();
+  const results = d.exec(`SELECT path, content_hash FROM files`);
+  const map = /* @__PURE__ */ new Map();
+  if (results[0]) {
+    for (const row of results[0].values) {
+      map.set(row[0], row[1]);
+    }
+  }
+  return map;
+}
+function removeStaleFiles(stalePaths) {
+  if (stalePaths.length === 0) return;
+  const d = getDb();
+  d.run("BEGIN");
+  try {
+    for (const p of stalePaths) {
+      try {
+        d.run(
+          `DELETE FROM cross_system_edges WHERE source_file_id IN (SELECT id FROM files WHERE path = ?) OR target_file_id IN (SELECT id FROM files WHERE path = ?)`,
+          [p, p]
+        );
+      } catch {
+      }
+      try {
+        d.run(`DELETE FROM callsites WHERE file_id IN (SELECT id FROM files WHERE path = ?)`, [p]);
+      } catch {
+      }
+      d.run(`DELETE FROM imports WHERE file_id IN (SELECT id FROM files WHERE path = ?)`, [p]);
+      d.run(`DELETE FROM symbols WHERE file_id IN (SELECT id FROM files WHERE path = ?)`, [p]);
+      d.run(`DELETE FROM files WHERE path = ?`, [p]);
+    }
+    d.run("COMMIT");
+  } catch (err) {
+    try {
+      d.run("ROLLBACK");
+    } catch {
+    }
+    throw err;
+  }
+}
+let resolutionContext = null;
+function setImportResolutionContext(projectRoot, aliasMap, systems) {
+  resolutionContext = { projectRoot, aliasMap, systems };
+}
+function resolutionContextRoot() {
+  return resolutionContext?.projectRoot ?? null;
+}
+function getImportResolutionContext(projectRoot) {
+  const ctx = resolutionContext?.projectRoot === projectRoot ? resolutionContext : null;
+  return { aliasMap: ctx?.aliasMap ?? [], systems: ctx?.systems ?? [] };
+}
+function resolvePendingImports(projectRoot) {
+  const ctx = resolutionContext?.projectRoot === projectRoot ? resolutionContext : null;
+  resolveImports(projectRoot, ctx?.aliasMap ?? [], ctx?.systems ?? [], { onlyUnresolved: true });
+}
+function resolveImports(projectRoot, aliasMap = [], systems = [], opts = {}) {
+  const d = getDb();
+  const filesResult = d.exec(`SELECT id, path, language FROM files`);
+  if (!filesResult[0]) return;
+  const filePathSet = /* @__PURE__ */ new Set();
+  const fileLangByPath = /* @__PURE__ */ new Map();
+  for (const row of filesResult[0].values) {
+    const fp = row[1];
+    filePathSet.add(fp);
+    fileLangByPath.set(fp, row[2]);
+  }
+  try {
+    d.run(`ALTER TABLE imports ADD COLUMN resolved_path TEXT`);
+  } catch {
+  }
+  try {
+    d.run(`CREATE INDEX IF NOT EXISTS idx_imports_resolved ON imports(resolved_path)`);
+  } catch {
+  }
+  try {
+    d.run(`ALTER TABLE plan_documents ADD COLUMN order_hint TEXT`);
+  } catch {
+  }
+  try {
+    d.run(`ALTER TABLE plan_documents ADD COLUMN parent_doc_uid TEXT`);
+  } catch {
+  }
+  try {
+    d.run(`CREATE INDEX IF NOT EXISTS idx_plan_docs_parent ON plan_documents(parent_doc_uid)`);
+  } catch {
+  }
+  try {
+    d.run(`
+      CREATE TABLE IF NOT EXISTS plan_phases (
+        uid TEXT PRIMARY KEY,
+        plan_uid TEXT NOT NULL REFERENCES plans(uid),
+        phase_number INTEGER NOT NULL,
+        title TEXT NOT NULL,
+        scope TEXT NOT NULL DEFAULT '',
+        prerequisites TEXT NOT NULL DEFAULT '',
+        git_checkpoint TEXT,
+        acceptance_criteria TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'pending',
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      )
+    `);
+    d.run(`CREATE INDEX IF NOT EXISTS idx_plan_phases_plan ON plan_phases(plan_uid)`);
+    d.run(`CREATE UNIQUE INDEX IF NOT EXISTS idx_plan_phases_unique ON plan_phases(plan_uid, phase_number)`);
+  } catch {
+  }
+  try {
+    d.run(`ALTER TABLE tasks ADD COLUMN phase_uid TEXT`);
+  } catch {
+  }
+  const importsResult = d.exec(
+    `SELECT i.id, i.source_path, f.path, i.is_relative FROM imports i JOIN files f ON i.file_id = f.id` + (opts.onlyUnresolved ? " WHERE i.resolved_path IS NULL" : "")
+  );
+  if (!importsResult[0]) return;
+  let resolved = 0;
+  for (const row of importsResult[0].values) {
+    const importId = row[0];
+    const sourcePath = row[1];
+    const importerPath = row[2];
+    const isRelative = Boolean(row[3]);
+    const language = fileLangByPath.get(importerPath);
+    const resolver = language ? (0, import_resolvers.getResolverForLanguage)(language) : null;
+    const resolvedPath = resolver ? resolver.resolve({
+      importSource: sourcePath,
+      importerPath,
+      projectRoot,
+      knownFiles: filePathSet,
+      aliasMap,
+      systems,
+      isRelative
+    }) : null;
+    if (resolvedPath && resolvedPath !== importerPath) {
+      d.run(`UPDATE imports SET resolved_path = ? WHERE id = ?`, [resolvedPath, importId]);
+      resolved++;
+    }
+  }
+  if (!opts.onlyUnresolved) console.log(`[DB] Resolved ${resolved} import paths`);
+}
+function getDependencyEdges() {
+  const d = getDb();
+  let results;
+  try {
+    results = d.exec(`
+      SELECT f1.path, f2.path, f1.relative_path, f2.relative_path, i.specifiers
+      FROM imports i
+      JOIN files f1 ON i.file_id = f1.id
+      JOIN files f2 ON i.resolved_path = f2.path
+      WHERE i.resolved_path IS NOT NULL
+      ORDER BY f1.path
+    `);
+  } catch {
+    return [];
+  }
+  if (!results[0]) return [];
+  return results[0].values.map((row) => ({
+    source: row[0],
+    target: row[1],
+    sourceRelative: row[2],
+    targetRelative: row[3],
+    specifiers: JSON.parse(row[4] || "[]")
+  }));
+}
+function getFileFacts() {
+  let files;
+  let symbols;
+  try {
+    files = getDb().exec(`SELECT id, relative_path, language FROM files`);
+    symbols = getDb().exec(`SELECT file_id, name, modifiers FROM symbols WHERE parent_symbol_id IS NULL`);
+  } catch {
+    return [];
+  }
+  const byFile = /* @__PURE__ */ new Map();
+  for (const [fileId, name, mods] of symbols[0]?.values ?? []) {
+    const list = byFile.get(Number(fileId)) ?? [];
+    list.push({ name: String(name), modifiers: JSON.parse(mods || "[]") });
+    byFile.set(Number(fileId), list);
+  }
+  return (files[0]?.values ?? []).map(([id, rel, lang]) => ({
+    sourceRelative: String(rel),
+    targetRelative: (0, import_folder_entry.fileFact)(String(rel), (0, import_folder_entry.exportCount)(String(lang ?? ""), byFile.get(Number(id)) ?? []))
+  }));
+}
+function replacePatternCallsites(found) {
+  const d = getDb();
+  let n = 0;
+  d.run("BEGIN");
+  try {
+    for (const f of found) {
+      const row = d.exec(`SELECT id FROM files WHERE path = ?`, [f.path])[0]?.values?.[0];
+      if (!row) continue;
+      const fileId = Number(row[0]);
+      d.run(`DELETE FROM callsites WHERE file_id = ? AND context LIKE 'pattern:%'`, [fileId]);
+      for (const cs of f.callsites) {
+        d.run(
+          `INSERT INTO callsites (file_id, kind, protocol, method, url_pattern, sql_text, line, context, host) VALUES (?,?,?,?,?,?,?,?,?)`,
+          [fileId, cs.kind, cs.protocol, cs.method ?? null, cs.urlPattern ?? null, cs.sqlText ?? null, cs.line ?? null, cs.context ?? null, cs.host ?? null]
+        );
+        n++;
+      }
+    }
+    d.run("COMMIT");
+  } catch (err) {
+    d.run("ROLLBACK");
+    throw err;
+  }
+  return n;
+}
+function hasPatternCallsites() {
+  try {
+    return (getDb().exec(`SELECT 1 FROM callsites WHERE context LIKE 'pattern:%' LIMIT 1`)[0]?.values?.length ?? 0) > 0;
+  } catch {
+    return false;
+  }
+}
+function getCallEdges() {
+  let results;
+  try {
+    results = getDb().exec(`
+      SELECT DISTINCT f.relative_path, c.kind, c.url_pattern, c.host
+      FROM callsites c
+      JOIN files f ON c.file_id = f.id
+      WHERE c.kind IN ('http_call', 'sql_query', 'entry', 'subprocess', 'env_lookup')
+      ORDER BY f.relative_path
+    `);
+  } catch {
+    return [];
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of results[0]?.values ?? []) {
+    const entry = (0, import_call_entry.callEntry)({ kind: String(row[1]), urlPattern: row[2], host: row[3] });
+    const key = `${row[0]}\0${entry}`;
+    if (!entry || seen.has(key)) continue;
+    seen.add(key);
+    out.push({ sourceRelative: String(row[0]), targetRelative: entry });
+  }
+  return out;
+}
+function getPackageEdges() {
+  let results;
+  try {
+    results = getDb().exec(`
+      SELECT DISTINCT f.relative_path, f.language, i.source_path, i.is_relative
+      FROM imports i
+      JOIN files f ON i.file_id = f.id
+      WHERE i.resolved_path IS NULL
+      ORDER BY f.relative_path
+    `);
+  } catch {
+    return [];
+  }
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const row of results[0]?.values ?? []) {
+    const entry = (0, import_package_entry.packageEntry)(String(row[1]), String(row[2]), Number(row[3]) === 1);
+    const key = `${row[0]}\0${entry}`;
+    if (!entry || seen.has(key)) continue;
+    seen.add(key);
+    out.push({ sourceRelative: String(row[0]), targetRelative: entry });
+  }
+  return out;
+}
+function getAllGraphEdges() {
+  const imports = getDependencyEdges().map((e) => ({ ...e, kind: "import" }));
+  const d = getDb();
+  let xs;
+  try {
+    xs = d.exec(`
+      SELECT sf.path, tf.path, sf.relative_path, tf.relative_path, e.protocol, e.label
+      FROM cross_system_edges e
+      JOIN files sf ON e.source_file_id = sf.id
+      JOIN files tf ON e.target_file_id = tf.id
+    `);
+  } catch {
+    return imports;
+  }
+  if (!xs[0]) return imports;
+  const crossSystem = xs[0].values.map((row) => ({
+    source: row[0],
+    target: row[1],
+    sourceRelative: row[2],
+    targetRelative: row[3],
+    specifiers: [],
+    kind: "cross_system",
+    protocol: row[4],
+    label: row[5]
+  }));
+  return [...imports, ...crossSystem];
+}
+function getFileDependencies(filePath) {
+  const d = getDb();
+  const row = d.exec(
+    `SELECT path FROM files WHERE path = ? OR relative_path = ? LIMIT 1`,
+    [filePath, filePath.replace(/^\.\//, "")]
+  );
+  filePath = row[0]?.values[0]?.[0] ?? filePath;
+  const importsResult = d.exec(`
+    SELECT f2.path, f2.relative_path, i.specifiers, i.is_reexport
+    FROM imports i
+    JOIN files f1 ON i.file_id = f1.id
+    JOIN files f2 ON i.resolved_path = f2.path
+    WHERE f1.path = ?
+  `, [filePath]);
+  const importedByResult = d.exec(`
+    SELECT f1.path, f1.relative_path, i.specifiers, i.is_reexport
+    FROM imports i
+    JOIN files f1 ON i.file_id = f1.id
+    WHERE i.resolved_path = ?
+  `, [filePath]);
+  const toDep = (r) => ({
+    path: r[0],
+    relativePath: r[1],
+    specifiers: JSON.parse(r[2] || "[]"),
+    // `export … from` (Phase 32 A2.2): passes the names on rather than using them.
+    ...r[3] === 1 ? { reexport: true } : {}
+  });
+  return {
+    imports: (importsResult[0]?.values || []).map(toDep),
+    importedBy: (importedByResult[0]?.values || []).map(toDep),
+    // Files that reach this one through a barrel's re-exports, and which barrels.
+    throughReexports: (0, import_importers.importersOf)(filePath).filter((i) => i.via.length > 0).map((i) => ({ path: i.path, relativePath: i.relativePath, specifiers: i.names, via: i.via, ...i.possibly ? { possibly: true } : {} }))
+  };
+}
+function getArchitectureSummary() {
+  const d = getDb();
+  const fileCount = d.exec(`SELECT COUNT(*) FROM files`)[0]?.values[0]?.[0] || 0;
+  const symbolCount = d.exec(`SELECT COUNT(*) FROM symbols`)[0]?.values[0]?.[0] || 0;
+  const importCount = d.exec(`SELECT COUNT(*) FROM imports`)[0]?.values[0]?.[0] || 0;
+  const topDirs = [];
+  try {
+    const r = d.exec(`
+      SELECT
+        CASE
+          WHEN INSTR(relative_path, '/') > 0
+          THEN SUBSTR(relative_path, 1, INSTR(relative_path, '/') - 1)
+          ELSE '(root)'
+        END AS dir,
+        COUNT(*) AS cnt
+      FROM files
+      GROUP BY dir
+      ORDER BY cnt DESC
+      LIMIT 15
+    `);
+    for (const row of r[0]?.values ?? []) {
+      topDirs.push({ dir: row[0], fileCount: row[1] });
+    }
+  } catch {
+  }
+  const langs = [];
+  try {
+    const r = d.exec(`SELECT language, COUNT(*) AS cnt FROM files GROUP BY language ORDER BY cnt DESC`);
+    for (const row of r[0]?.values ?? []) {
+      langs.push({ language: row[0], count: row[1] });
+    }
+  } catch {
+  }
+  const kindBreakdown = [];
+  try {
+    const r = d.exec(`SELECT kind, COUNT(*) AS cnt FROM symbols GROUP BY kind ORDER BY cnt DESC`);
+    for (const row of r[0]?.values ?? []) {
+      kindBreakdown.push({ kind: row[0], count: row[1] });
+    }
+  } catch {
+  }
+  const mostImported = [];
+  try {
+    const r = d.exec(`
+      SELECT i.source_path, COUNT(DISTINCT i.file_id) AS cnt
+      FROM imports i
+      GROUP BY i.source_path
+      ORDER BY cnt DESC
+      LIMIT 10
+    `);
+    for (const row of r[0]?.values ?? []) {
+      mostImported.push({ path: row[0], importerCount: row[1] });
+    }
+  } catch {
+  }
+  return {
+    fileCount,
+    symbolCount,
+    importCount,
+    topDirectories: topDirs,
+    languageBreakdown: langs,
+    symbolsByKind: kindBreakdown,
+    mostImported
+  };
+}
+function getDbStats() {
+  const d = getDb();
+  const files = d.exec(`SELECT COUNT(*) FROM files`);
+  const symbols = d.exec(`SELECT COUNT(*) FROM symbols`);
+  const imports = d.exec(`SELECT COUNT(*) FROM imports`);
+  let resolvedImports = 0;
+  try {
+    const resolved = d.exec(`SELECT COUNT(*) FROM imports WHERE resolved_path IS NOT NULL`);
+    resolvedImports = resolved[0]?.values[0]?.[0] || 0;
+  } catch {
+  }
+  return {
+    fileCount: files[0]?.values[0]?.[0] || 0,
+    symbolCount: symbols[0]?.values[0]?.[0] || 0,
+    importCount: imports[0]?.values[0]?.[0] || 0,
+    resolvedImports
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearAstData,
+  exportDatabase,
+  getAllFileHashes,
+  getAllGraphEdges,
+  getArchitectureSummary,
+  getCallEdges,
+  getDb,
+  getDbStats,
+  getDependencyEdges,
+  getFileDependencies,
+  getFileFacts,
+  getFileHash,
+  getFileSymbols,
+  getFileSymbolsWithMembers,
+  getImportResolutionContext,
+  getPackageEdges,
+  hasPatternCallsites,
+  initDatabase,
+  removeStaleFiles,
+  replacePatternCallsites,
+  resolutionContextRoot,
+  resolveImports,
+  resolvePendingImports,
+  searchSymbols,
+  setImportResolutionContext,
+  storeParsedFile
+});