codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/criterion-loop-service.js

@@ -0,0 +1,411 @@
+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 criterion_loop_service_exports = {};
+__export(criterion_loop_service_exports, {
+  checkCriterion: () => checkCriterion,
+  describeSinceLast: () => describeSinceLast,
+  getWorklist: () => getWorklist,
+  listCheckRuns: () => listCheckRuns,
+  runCheckRun: () => runCheckRun,
+  submitChecked: () => submitChecked,
+  testsOlderThanCode: () => testsOlderThanCode
+});
+module.exports = __toCommonJS(criterion_loop_service_exports);
+var import_test_results = require("./tests/test-results");
+var import_agent_event_log = require("./agent-event-log");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = require("node:crypto");
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var criteria = __toESM(require("./criteria-service"));
+var import_artefact_service = require("./artefact-service");
+var import_criterion_checks = require("./criterion-checks");
+var import_plan_item_service = require("./plan-item-service");
+var import_plan_review_service = require("./plan-review-service");
+var import_project_config_service = require("./project-config-service");
+var import_confined_fs = require("./confined-fs");
+var import_references = require("../../shared/lib/references");
+var import_sensor_bridge_service = require("./sensor-bridge-service");
+const rows = (sql, params = []) => (0, import_database.getDb)().exec(sql, params)[0]?.values ?? [];
+function rootOf(itemUid) {
+  try {
+    return (0, import_artefact_service.projectRootForItem)(itemUid);
+  } catch {
+    return null;
+  }
+}
+function itemStartedAt(item) {
+  const started = rows(
+    `SELECT MIN(created_at) FROM plan_events
+     WHERE item_uid = ? AND event_type = 'status_changed' AND after_state LIKE '%in_progress%'`,
+    [item.uid]
+  )[0]?.[0];
+  if (typeof started === "number") return started;
+  const created = typeof item.createdAt === "number" ? item.createdAt : Date.parse(String(item.createdAt));
+  return Number.isFinite(created) ? created : 0;
+}
+function materialsReadSince(itemUid, since) {
+  const read = /* @__PURE__ */ new Set();
+  for (const r of rows(
+    `SELECT after_state FROM plan_events WHERE item_uid = ? AND event_type = 'material_read' AND created_at >= ?`,
+    [itemUid, since]
+  )) {
+    try {
+      const uid = JSON.parse(String(r[0])).attachmentUid;
+      if (typeof uid === "string") read.add(uid);
+    } catch {
+    }
+  }
+  return read;
+}
+function lastTargetChangeAt(item, root) {
+  if (!root) return null;
+  let newest = null;
+  for (const spec of item.fileSpecs ?? []) {
+    if (!spec?.path) continue;
+    const rel = item.scopePath && !import_node_path.default.isAbsolute(spec.path) ? import_node_path.default.join(item.scopePath, spec.path) : spec.path;
+    try {
+      const st = import_node_fs.default.lstatSync((0, import_confined_fs.resolveWithin)(root, rel, "target"));
+      if (st.isFile()) newest = Math.max(newest ?? 0, Math.round(st.mtimeMs));
+    } catch {
+    }
+  }
+  return newest;
+}
+function codeVerdicts(planUid) {
+  const projectPath = rows(`SELECT project_path FROM plans WHERE uid = ?`, [planUid])[0]?.[0];
+  if (typeof projectPath !== "string" || !projectPath) return { unavailable: "the plan has no project" };
+  try {
+    const r = (0, import_plan_review_service.reviewPlan)({ planUid, projectPath });
+    if (!r.ok) return { unavailable: r.error };
+    const verdicts = new Map(r.review.items.map((i) => [i.uid, { verdict: i.verdict, missing: i.missing }]));
+    if ((0, import_project_config_service.getEffectiveSensorConfig)(projectPath).awareness.holdSignOffOnHighSignals) {
+      verdicts.openHighSignals = (r.review.otherWork?.entries ?? []).filter((e) => e.outcome === "open" && e.severity === "high").map((e) => ({ heading: e.heading, words: [...e.sides.map((s) => s.words), e.merge].filter(Boolean).join(" ") }));
+    }
+    return verdicts;
+  } catch (err) {
+    return { unavailable: err.message };
+  }
+}
+function evidenceFacts(criterion, offered) {
+  const list = offered ? offered.map((e) => ({ attachmentUid: e.attachmentUid, locator: e.locator ?? null })) : criterion.latestSubmission.map((e) => ({ attachmentUid: e.attachmentUid, locator: e.locator }));
+  return list.map((e) => {
+    const artefact = e.attachmentUid ? (0, import_artefact_service.getArtefact)(e.attachmentUid) : null;
+    return {
+      attachmentUid: e.attachmentUid,
+      locator: e.locator,
+      // Evidence from another item is a claim about somewhere else.
+      artefact: artefact && artefact.itemUid === criterion.itemUid ? artefact : null
+    };
+  });
+}
+function check(criterion, item, offered, verdicts) {
+  const root = rootOf(item.uid);
+  let code;
+  let openHighSignals;
+  if (criterion.kind === "code") {
+    const v = verdicts();
+    code = "unavailable" in v && typeof v.unavailable === "string" ? { unavailable: v.unavailable } : v.get(item.uid) ?? { unavailable: "the item is not in the plan review" };
+    if (v instanceof Map) openHighSignals = v.openHighSignals;
+  }
+  const startedAt = itemStartedAt(item);
+  return (0, import_criterion_checks.runChecks)({
+    criterion: { uid: criterion.uid, itemUid: criterion.itemUid, kind: criterion.kind },
+    root,
+    itemStartedAt: startedAt,
+    lastTargetChangeAt: lastTargetChangeAt(item, root),
+    evidence: evidenceFacts(criterion, offered),
+    itemArtefacts: (0, import_artefact_service.listArtefacts)(item.uid),
+    materialsRead: criterion.kind === "citation" ? materialsReadSince(item.uid, startedAt) : void 0,
+    code,
+    openHighSignals,
+    // B8.1: a JUnit report read by a test check keeps each test's result.
+    onTestReport: criterion.kind === "test" && root ? (a) => {
+      (0, import_test_results.ingestTestReport)(root, a.path, { author: a.recordedBy, authorType: a.recordedByType });
+    } : void 0
+  });
+}
+function once(fn) {
+  let done = false;
+  let value;
+  return () => {
+    if (!done) {
+      value = fn();
+      done = true;
+    }
+    return value;
+  };
+}
+function requireCriterion(uid) {
+  const criterion = criteria.getCriterion(uid);
+  if (!criterion) throw new criteria.CriterionError("Criterion not found", 404);
+  const item = (0, import_plan_item_service.getItem)(criterion.itemUid);
+  if (!item) throw new criteria.CriterionError("Item not found", 404);
+  return { criterion, item };
+}
+async function checkCriterion(uid, offered) {
+  const { criterion: before, item } = requireCriterion(uid);
+  await (0, import_artefact_service.refreshArtefactHashes)(before.itemUid).catch(() => []);
+  const criterion = criteria.getCriterion(uid);
+  return check(criterion, item, offered, once(() => codeVerdicts(item.planUid)));
+}
+async function testsOlderThanCode(itemUid) {
+  const out = [];
+  for (const c of criteria.listCriteria(itemUid)) {
+    if (c.kind !== "test") continue;
+    const r = await checkCriterion(c.uid).catch(() => null);
+    const older = r?.findings.find((f) => f.status === "fail" && f.reason === "tests_older");
+    if (older) out.push({ criterionUid: c.uid, text: c.text, why: older.message });
+  }
+  return out;
+}
+async function submitChecked(uid, input, actor) {
+  const result = await checkCriterion(uid, input.evidence ?? []);
+  if (!result.ok) {
+    const failures = result.findings.filter((f) => f.status === "fail").map((f) => `- ${f.message}`);
+    throw new criteria.CriterionError(
+      `Not submitted \u2014 fix these and check again (check_criterion), then submit:
+${failures.join("\n")}`,
+      422
+    );
+  }
+  const criterion = criteria.submitCriterion(uid, input, actor);
+  if (criterion.state === "submitted") {
+    const item = (0, import_plan_item_service.getItem)(criterion.itemUid);
+    if (item) {
+      (0, import_sensor_bridge_service.postCriterionNotice)({
+        planUid: item.planUid,
+        itemUid: item.uid,
+        criterionUid: criterion.uid,
+        reason: "submitted",
+        message: `${actor.author} submitted "${criterion.text}" on ${item.title} \u2014 approve it or send it back.`
+      });
+    }
+  }
+  return { criterion, check: result };
+}
+function pathOf(attachmentUid) {
+  return attachmentUid ? (0, import_artefact_service.getArtefact)(attachmentUid)?.path ?? null : null;
+}
+function changedEvidenceFiles(c) {
+  const recorded = c.latestSignoff?.evidenceHashes ?? {};
+  const uids = Object.keys(recorded);
+  const now = (0, import_artefact_service.currentHashes)(uids);
+  return uids.filter((u) => recorded[u] !== now[u]).map((u) => pathOf(u) ?? u);
+}
+function refOf(item) {
+  return (0, import_references.formatReference)(item.kind === "object" ? "page" : "task", item.uid);
+}
+const REASON_ORDER = { sent_back: 0, stale: 1, failing: 2, open: 3 };
+async function getWorklist(planUid) {
+  const items = (0, import_plan_item_service.listAllItems)(planUid);
+  const verdicts = once(() => codeVerdicts(planUid));
+  const entries = [];
+  let waitingForPerson = 0;
+  let met = 0;
+  let total = 0;
+  for (const [itemIndex, item] of items.entries()) {
+    await (0, import_artefact_service.refreshArtefactHashes)(item.uid).catch(() => []);
+    for (const c of criteria.listCriteria(item.uid)) {
+      total++;
+      const base = {
+        criterionUid: c.uid,
+        itemUid: item.uid,
+        itemTitle: item.title,
+        itemRef: refOf(item),
+        text: c.text,
+        kind: c.kind,
+        policy: c.policy
+      };
+      const anchors = c.latestSubmission.filter((e) => e.attachmentUid || e.locator).map((e) => ({ attachmentUid: e.attachmentUid, path: pathOf(e.attachmentUid), locator: e.locator }));
+      const order = itemIndex * 1e4 + c.sortOrder;
+      if (c.state === "met") {
+        met++;
+        continue;
+      }
+      if (c.state === "sent_back") {
+        const at = c.latestSignoff?.anchor;
+        const pointed = at ? [{ attachmentUid: at.attachmentUid, path: pathOf(at.attachmentUid), locator: at.locator }] : [];
+        entries.push({
+          ...base,
+          reason: "sent_back",
+          note: c.latestSignoff?.note ?? null,
+          anchors: [...pointed, ...anchors],
+          details: [],
+          order
+        });
+      } else if (c.state === "stale") {
+        const files = changedEvidenceFiles(c);
+        entries.push({
+          ...base,
+          reason: "stale",
+          note: null,
+          anchors,
+          details: files.map((f) => `${f} changed after it was approved`),
+          order
+        });
+      } else if (c.state === "submitted") {
+        const result = check(c, item, void 0, verdicts);
+        if (result.ok) {
+          waitingForPerson++;
+          continue;
+        }
+        entries.push({
+          ...base,
+          reason: "failing",
+          note: null,
+          anchors,
+          details: result.findings.filter((f) => f.status === "fail").map((f) => f.message),
+          order
+        });
+      } else {
+        entries.push({ ...base, reason: "open", note: null, anchors: [], details: [], order });
+      }
+    }
+  }
+  entries.sort((a, b) => REASON_ORDER[a.reason] - REASON_ORDER[b.reason] || a.order - b.order);
+  return {
+    planUid,
+    entries: entries.map(({ order: _order, ...e }) => e),
+    waitingForPerson,
+    met,
+    total
+  };
+}
+const when = (ms) => new Date(ms).toISOString().slice(0, 16).replace("T", " ");
+function toRun(r) {
+  const parse = (v, fallback) => {
+    try {
+      return typeof v === "string" ? JSON.parse(v) : fallback;
+    } catch {
+      return fallback;
+    }
+  };
+  return {
+    uid: r[0],
+    planUid: r[1],
+    trigger: r[2],
+    by: r[3],
+    byType: r[4],
+    outcomes: parse(r[5], []),
+    sinceLast: parse(r[6], []),
+    startedAt: r[7],
+    finishedAt: r[8]
+  };
+}
+const RUN_COLS = "uid, plan_uid, trigger, by_actor, by_type, outcomes, since_last, started_at, finished_at";
+function listCheckRuns(planUid, limit = 10) {
+  return rows(
+    `SELECT ${RUN_COLS} FROM check_runs WHERE plan_uid = ? ORDER BY started_at DESC, rowid DESC LIMIT ?`,
+    [planUid, limit]
+  ).map(toRun);
+}
+function describeSinceLast(outcomes, previousRuns) {
+  const previous = previousRuns[0];
+  if (!previous) return ["First check run on this plan."];
+  const before = /* @__PURE__ */ new Map();
+  for (const run of previousRuns) {
+    for (const o of run.outcomes) if (!before.has(o.criterionUid)) before.set(o.criterionUid, o);
+  }
+  const since = `since ${when(previous.startedAt)}`;
+  const lines = [];
+  const wentStale = outcomes.filter((o) => o.state === "stale" && before.get(o.criterionUid) && before.get(o.criterionUid).state !== "stale");
+  if (wentStale.length) {
+    const files = [...new Set(wentStale.flatMap((o) => o.changedFiles))];
+    lines.push(`${wentStale.length} went stale ${since}${files.length ? ` \u2014 ${files.join(", ")} changed` : ""}.`);
+  }
+  const nowFailing = outcomes.filter((o) => !o.ok && before.get(o.criterionUid)?.ok);
+  if (nowFailing.length) {
+    lines.push(`${nowFailing.length} now fail${nowFailing.length === 1 ? "s" : ""} ${nowFailing.length === 1 ? "its" : "their"} checks: ${nowFailing.map((o) => `"${o.text}"`).join(", ")}.`);
+  }
+  const fixed = outcomes.filter((o) => o.ok && before.get(o.criterionUid) && !before.get(o.criterionUid).ok);
+  if (fixed.length) lines.push(`${fixed.length} pass${fixed.length === 1 ? "es" : ""} again.`);
+  const newlyMet = outcomes.filter((o) => o.state === "met" && before.get(o.criterionUid) && before.get(o.criterionUid).state !== "met");
+  if (newlyMet.length) lines.push(`${newlyMet.length} met ${since}.`);
+  const added = outcomes.filter((o) => !before.has(o.criterionUid));
+  if (added.length) lines.push(`${added.length} new since the last run.`);
+  if (lines.length === 0) lines.push(`Nothing changed ${since}.`);
+  return lines;
+}
+async function runCheckRun(input) {
+  const startedAt = Date.now();
+  const scope = input.itemUids ? new Set(input.itemUids) : null;
+  const items = (0, import_plan_item_service.listAllItems)(input.planUid).filter((i) => !scope || scope.has(i.uid));
+  const verdicts = once(() => codeVerdicts(input.planUid));
+  const outcomes = [];
+  for (const item of items) {
+    await (0, import_artefact_service.refreshArtefactHashes)(item.uid).catch(() => []);
+    for (const c of criteria.listCriteria(item.uid)) {
+      const result = check(c, item, void 0, verdicts);
+      outcomes.push({
+        criterionUid: c.uid,
+        itemUid: item.uid,
+        text: c.text,
+        state: c.state,
+        ok: result.ok,
+        failures: result.findings.filter((f) => f.status === "fail").map((f) => f.message),
+        changedFiles: c.state === "stale" ? changedEvidenceFiles(c) : []
+      });
+    }
+  }
+  const sinceLast = describeSinceLast(outcomes, listCheckRuns(input.planUid, 20));
+  const uid = (0, import_node_crypto.randomUUID)();
+  const finishedAt = Math.max(Date.now(), startedAt);
+  (0, import_database.getDb)().run(
+    `INSERT INTO check_runs (uid, plan_uid, trigger, by_actor, by_type, scope, outcomes, since_last, started_at, finished_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      uid,
+      input.planUid,
+      input.trigger,
+      input.by,
+      input.byType,
+      scope ? JSON.stringify([...scope]) : null,
+      JSON.stringify(outcomes),
+      JSON.stringify(sinceLast),
+      startedAt,
+      finishedAt
+    ]
+  );
+  (0, import_persistence.markDirty)();
+  if (outcomes.length) {
+    (0, import_agent_event_log.recordCheckRun)({ runUid: uid, planUid: input.planUid, trigger: input.trigger, by: input.by, byType: input.byType, outcomes });
+  }
+  return { uid, planUid: input.planUid, trigger: input.trigger, by: input.by, byType: input.byType, startedAt, finishedAt, outcomes, sinceLast };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkCriterion,
+  describeSinceLast,
+  getWorklist,
+  listCheckRuns,
+  runCheckRun,
+  submitChecked,
+  testsOlderThanCode
+});

package/src/backend/services/cross-system-service.js

@@ -0,0 +1,231 @@
+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 cross_system_service_exports = {};
+__export(cross_system_service_exports, {
+  getCrossSystemStats: () => getCrossSystemStats,
+  listCrossSystemEdges: () => listCrossSystemEdges,
+  matchEntryEdges: () => matchEntryEdges,
+  recomputeCrossSystemEdges: () => recomputeCrossSystemEdges
+});
+module.exports = __toCommonJS(cross_system_service_exports);
+var import_database = require("./database");
+function recomputeCrossSystemEdges() {
+  const db = (0, import_database.getDb)();
+  let result;
+  try {
+    result = db.exec(`
+      SELECT c.file_id, f.path, f.relative_path, c.kind, c.protocol, c.method, c.url_pattern, c.line,
+             f.language
+      FROM callsites c
+      JOIN files f ON c.file_id = f.id
+    `);
+  } catch {
+    return { added: 0 };
+  }
+  const rows = (result[0]?.values ?? []).map((r) => ({
+    fileId: r[0],
+    filePath: r[1],
+    fileRel: r[2],
+    kind: r[3],
+    protocol: r[4],
+    method: r[5] ?? null,
+    urlPattern: r[6] ?? null,
+    line: r[7] ?? null,
+    language: r[8] ?? null
+  }));
+  const httpRoutes = rows.filter((r) => r.kind === "http_route");
+  const httpCalls = rows.filter((r) => r.kind === "http_call");
+  const routesByKey = /* @__PURE__ */ new Map();
+  for (const r of httpRoutes) {
+    if (!r.method || !r.urlPattern) continue;
+    const key = `${r.method} ${r.urlPattern}`;
+    const bucket = routesByKey.get(key) ?? [];
+    bucket.push(r);
+    routesByKey.set(key, bucket);
+  }
+  const inserts = [];
+  for (const call of httpCalls) {
+    if (!call.method || !call.urlPattern) continue;
+    const exact = [
+      ...routesByKey.get(`${call.method} ${call.urlPattern}`) ?? [],
+      ...routesByKey.get(`ANY ${call.urlPattern}`) ?? []
+    ];
+    if (exact.length > 0) {
+      for (const route of exact) {
+        if (route.fileId === call.fileId) continue;
+        inserts.push({ source: call, target: route, label: `${call.method} ${call.urlPattern}` });
+      }
+      continue;
+    }
+  }
+  const sqlInserts = matchSqlEdges(db, rows);
+  const entryInserts = matchEntryEdges(rows);
+  db.run(`DELETE FROM cross_system_edges`);
+  for (const { source, target, label } of inserts) {
+    db.run(
+      `INSERT INTO cross_system_edges (source_file_id, target_file_id, protocol, label, confidence)
+       VALUES (?, ?, ?, ?, ?)`,
+      [source.fileId, target.fileId, "http", label, 1]
+    );
+  }
+  for (const edge of sqlInserts) {
+    db.run(
+      `INSERT INTO cross_system_edges (source_file_id, target_file_id, protocol, label, confidence)
+       VALUES (?, ?, ?, ?, ?)`,
+      [edge.sourceFileId, edge.targetFileId, "sql", edge.label, edge.confidence]
+    );
+  }
+  for (const edge of entryInserts) {
+    db.run(
+      `INSERT INTO cross_system_edges (source_file_id, target_file_id, protocol, label, confidence)
+       VALUES (?, ?, ?, ?, ?)`,
+      [edge.sourceFileId, edge.targetFileId, edge.protocol, edge.label, 1]
+    );
+  }
+  const total = inserts.length + sqlInserts.length + entryInserts.length;
+  console.log(
+    `[XS] Cross-system edges: ${inserts.length} HTTP pair${inserts.length === 1 ? "" : "s"}, ${sqlInserts.length} SQL reference${sqlInserts.length === 1 ? "" : "s"}, ${entryInserts.length} pair${entryInserts.length === 1 ? "" : "s"} of the team's own kinds matched`
+  );
+  return { added: total };
+}
+function matchEntryEdges(rows) {
+  const sides = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    if (r.kind !== "entry" || !r.urlPattern || r.method !== "SEND" && r.method !== "RECEIVE") continue;
+    let s = sides.get(r.urlPattern);
+    if (!s) sides.set(r.urlPattern, s = { send: /* @__PURE__ */ new Set(), receive: /* @__PURE__ */ new Set() });
+    (r.method === "SEND" ? s.send : s.receive).add(r.fileId);
+  }
+  const out = [];
+  for (const [entry, s] of [...sides].sort(([a], [b]) => a.localeCompare(b))) {
+    const protocol = entry.slice(0, entry.indexOf(":"));
+    for (const from of [...s.send].sort((a, b) => a - b)) {
+      for (const to of [...s.receive].sort((a, b) => a - b)) {
+        if (from !== to) out.push({ sourceFileId: from, targetFileId: to, protocol, label: entry });
+      }
+    }
+  }
+  return out;
+}
+function matchSqlEdges(db, rows) {
+  const refs = rows.filter((r) => r.kind === "sql_query" && r.urlPattern);
+  if (refs.length === 0) return [];
+  let symbolResult;
+  try {
+    symbolResult = db.exec(`
+      SELECT s.name, s.modifiers, f.id
+      FROM symbols s
+      JOIN files f ON s.file_id = f.id
+      WHERE f.language = 'sql'
+    `);
+  } catch {
+    return [];
+  }
+  const definers = /* @__PURE__ */ new Map();
+  for (const row of symbolResult[0]?.values ?? []) {
+    const name = String(row[0] ?? "");
+    let modifiers = [];
+    try {
+      modifiers = JSON.parse(String(row[1] ?? "[]"));
+    } catch {
+    }
+    if (!modifiers.includes("table") && !modifiers.includes("view")) continue;
+    const bare = name.split(".").pop().toLowerCase();
+    const bucket = definers.get(bare) ?? [];
+    bucket.push(row[2]);
+    definers.set(bare, bucket);
+  }
+  if (definers.size === 0) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const edges = [];
+  for (const ref of refs) {
+    const table = ref.urlPattern.toLowerCase();
+    const candidates = definers.get(table);
+    if (!candidates || candidates.length !== 1) continue;
+    const targetFileId = candidates[0];
+    if (targetFileId === ref.fileId) continue;
+    const op = (ref.method ?? "READ").toUpperCase();
+    const key = `${ref.fileId}:${targetFileId}:${op}:${table}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    edges.push({
+      sourceFileId: ref.fileId,
+      targetFileId,
+      label: `${op} ${table}`,
+      confidence: 1
+    });
+  }
+  return edges;
+}
+function listCrossSystemEdges() {
+  const db = (0, import_database.getDb)();
+  let result;
+  try {
+    result = db.exec(`
+      SELECT
+        sf.path, tf.path, sf.relative_path, tf.relative_path,
+        e.protocol, e.label, e.confidence
+      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
+      ORDER BY e.protocol, sf.relative_path
+    `);
+  } catch {
+    return [];
+  }
+  if (!result[0]) return [];
+  return result[0].values.map((r) => ({
+    source: r[0],
+    target: r[1],
+    sourceRelative: r[2],
+    targetRelative: r[3],
+    protocol: r[4],
+    label: r[5],
+    confidence: r[6] ?? 1
+  }));
+}
+function getCrossSystemStats() {
+  const db = (0, import_database.getDb)();
+  const empty = { callsiteCount: 0, routeCount: 0, edgeCount: 0, byProtocol: {} };
+  try {
+    const cs = db.exec(`SELECT COUNT(*), SUM(CASE WHEN kind = 'http_route' THEN 1 ELSE 0 END) FROM callsites`);
+    const callsiteCount = cs[0]?.values[0]?.[0] ?? 0;
+    const routeCount = cs[0]?.values[0]?.[1] ?? 0;
+    const eg = db.exec(`SELECT COUNT(*), protocol FROM cross_system_edges GROUP BY protocol`);
+    const byProtocol = {};
+    let total = 0;
+    if (eg[0]) {
+      for (const row of eg[0].values) {
+        const n = row[0];
+        const p = row[1];
+        byProtocol[p] = n;
+        total += n;
+      }
+    }
+    return { callsiteCount, routeCount, edgeCount: total, byProtocol };
+  } catch {
+    return empty;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getCrossSystemStats,
+  listCrossSystemEdges,
+  matchEntryEdges,
+  recomputeCrossSystemEdges
+});