codetrellis 0.0.0-stage → 0.3.0

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

@@ -0,0 +1,344 @@
+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 deviation_service_exports = {};
+__export(deviation_service_exports, {
+  DeviationError: () => DeviationError,
+  checkFileDeviation: () => checkFileDeviation,
+  detectDeviations: () => detectDeviations,
+  getDeviations: () => getDeviations,
+  planOfDeviation: () => planOfDeviation,
+  reconcileDeviations: () => reconcileDeviations,
+  resolveDeviation: () => resolveDeviation
+});
+module.exports = __toCommonJS(deviation_service_exports);
+var _lazy___plan_service = __toESM(require("./plan-service"));
+var import_database = require("./database");
+var import_plan_item_service = require("./plan-item-service");
+var import_database2 = require("./database");
+var import_persistence = require("./persistence");
+var import_server = require("../server");
+var import_sensor_bridge_service = require("./sensor-bridge-service");
+function collectExpectations(planUid) {
+  const items = (0, import_plan_item_service.listAllItems)(planUid).filter((i) => i.kind === "action");
+  const files = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    for (const fs of item.fileSpecs ?? []) {
+      files.set(fs.path, {
+        path: fs.path,
+        action: fs.action,
+        label: item.title,
+        status: item.status ?? null
+      });
+    }
+  }
+  return { files, items };
+}
+function getResolvedDeviationPaths(db, planUid) {
+  const result = db.exec(
+    `SELECT file_path FROM deviations
+     WHERE plan_uid = ? AND file_path IS NOT NULL AND resolution != 'pending'`,
+    [planUid]
+  );
+  const paths = /* @__PURE__ */ new Set();
+  if (result[0]) {
+    for (const row of result[0].values) {
+      if (row[0]) paths.add(row[0]);
+    }
+  }
+  return paths;
+}
+function getPendingDeviationPaths(db, planUid) {
+  const result = db.exec(
+    `SELECT file_path FROM deviations
+     WHERE plan_uid = ? AND file_path IS NOT NULL AND resolution = 'pending'`,
+    [planUid]
+  );
+  const paths = /* @__PURE__ */ new Set();
+  if (result[0]) {
+    for (const row of result[0].values) {
+      if (row[0]) paths.add(row[0]);
+    }
+  }
+  return paths;
+}
+function detectDeviations(planUid, changedFiles) {
+  const db = (0, import_database.getDb)();
+  const { files: fileExpectations, items } = collectExpectations(planUid);
+  const deviations = [];
+  const now = Date.now();
+  const resolvedPaths = getResolvedDeviationPaths(db, planUid);
+  const pendingPaths = getPendingDeviationPaths(db, planUid);
+  const alreadyHandled = /* @__PURE__ */ new Set([...resolvedPaths, ...pendingPaths]);
+  for (const [file, exp] of fileExpectations) {
+    if (alreadyHandled.has(file)) continue;
+    const result = db.exec(
+      `SELECT id FROM files WHERE relative_path = ? OR path LIKE ?`,
+      [file, `%/${file}`]
+    );
+    const fileExists = !!result[0]?.values[0];
+    if (exp.action === "create") {
+      if (exp.status === "done" && !fileExists) {
+        deviations.push(createDeviation(
+          db,
+          planUid,
+          "missing_file",
+          "warning",
+          `"${exp.label}" expected to create "${file}" but it doesn't exist`,
+          now,
+          file
+        ));
+        alreadyHandled.add(file);
+      }
+    } else if (exp.action === "delete") {
+      if (exp.status === "done" && fileExists) {
+        deviations.push(createDeviation(
+          db,
+          planUid,
+          "unexpected_file",
+          "warning",
+          `"${exp.label}" expected to delete "${file}" but it still exists`,
+          now,
+          file
+        ));
+        alreadyHandled.add(file);
+      }
+    } else {
+      if (exp.status === "done" && !fileExists) {
+        deviations.push(createDeviation(
+          db,
+          planUid,
+          "missing_file",
+          "warning",
+          `"${exp.label}" expected file "${file}" but it doesn't exist`,
+          now,
+          file
+        ));
+        alreadyHandled.add(file);
+      }
+    }
+  }
+  if (changedFiles && changedFiles.length > 0) {
+    const expectedPaths = [...fileExpectations.keys()];
+    for (const file of changedFiles) {
+      if (alreadyHandled.has(file)) continue;
+      const isExpected = expectedPaths.some(
+        (p) => file === p || file.endsWith("/" + p) || p.endsWith("/" + file)
+      );
+      const wasResolved = [...resolvedPaths].some(
+        (p) => file === p || file.endsWith("/" + p) || p.endsWith("/" + file)
+      );
+      if (!isExpected && !wasResolved) {
+        deviations.push(createDeviation(
+          db,
+          planUid,
+          "unexpected_file",
+          "info",
+          `File "${file}" changed since baseline but is not in any plan item`,
+          now,
+          file
+        ));
+        alreadyHandled.add(file);
+      }
+    }
+  }
+  let edges = [];
+  try {
+    edges = (0, import_database2.getDependencyEdges)();
+  } catch {
+  }
+  const edgeSet = new Set(edges.map((e) => `${e.sourceRelative}->${e.targetRelative}`));
+  for (const item of items) {
+    if (item.status !== "done") continue;
+    for (const conn of item.newConnections ?? []) {
+      if (!edgeSet.has(`${conn.from}->${conn.to}`)) {
+        deviations.push(createDeviation(
+          db,
+          planUid,
+          "missing_import",
+          "info",
+          `Expected import ${conn.from} \u2192 ${conn.to} not found`,
+          now
+        ));
+      }
+    }
+  }
+  for (const dev of deviations) {
+    (0, import_server.broadcast)("deviation-detected", { deviation: dev });
+  }
+  return deviations;
+}
+function checkFileDeviation(relativePath) {
+  const db = (0, import_database.getDb)();
+  const plansResult = db.exec(`SELECT uid FROM plans WHERE status IN ('in_progress', 'approved')`);
+  if (!plansResult[0]) return;
+  for (const row of plansResult[0].values) {
+    const planUid = row[0];
+    const { files } = collectExpectations(planUid);
+    const resolvedPaths = getResolvedDeviationPaths(db, planUid);
+    const pendingPaths = getPendingDeviationPaths(db, planUid);
+    if (resolvedPaths.has(relativePath) || pendingPaths.has(relativePath)) continue;
+    const isExpected = [...files.keys()].some(
+      (f) => relativePath.includes(f) || f.includes(relativePath)
+    );
+    if (!isExpected) {
+      createDeviation(
+        db,
+        planUid,
+        "unexpected_file",
+        "info",
+        `File "${relativePath}" was modified but is not listed in any plan item`,
+        Date.now(),
+        relativePath
+      );
+      (0, import_server.broadcast)("deviation-detected", {
+        deviation: {
+          planUid,
+          deviationType: "unexpected_file",
+          severity: "info",
+          description: `File "${relativePath}" modified outside of plan`
+        }
+      });
+    }
+  }
+}
+function createDeviation(db, planUid, deviationType, severity, description, now, filePath) {
+  db.run(
+    `INSERT INTO deviations (plan_uid, deviation_type, severity, description, resolution, detected_at, file_path)
+     VALUES (?, ?, ?, ?, 'pending', ?, ?)`,
+    [planUid, deviationType, severity, description, now, filePath ?? null]
+  );
+  const idResult = db.exec(`SELECT last_insert_rowid()`);
+  const id = idResult[0]?.values[0]?.[0] || 0;
+  (0, import_persistence.markDirty)();
+  const deviation = { id, planUid, deviationType, severity, description, resolution: "pending", detectedAt: now, resolvedAt: null, filePath: filePath ?? null };
+  try {
+    const { getPlan: getPlanLazy } = _lazy___plan_service;
+    const plan = getPlanLazy(planUid);
+    if (plan?.projectPath) {
+      (0, import_sensor_bridge_service.onDeviationDetected)(deviation, plan.projectPath);
+    }
+  } catch {
+  }
+  return deviation;
+}
+function getDeviations(planUid) {
+  const result = (0, import_database.getDb)().exec(
+    `SELECT id, plan_uid, deviation_type, severity, description, resolution, detected_at, resolved_at, file_path,
+            resolved_by, resolved_by_type
+     FROM deviations WHERE plan_uid = ? ORDER BY detected_at DESC`,
+    [planUid]
+  );
+  if (!result[0]) return [];
+  return result[0].values.map((r) => ({
+    id: r[0],
+    planUid: r[1],
+    deviationType: r[2],
+    severity: r[3],
+    description: r[4],
+    resolution: r[5],
+    detectedAt: r[6],
+    resolvedAt: r[7],
+    filePath: r[8] ?? null,
+    resolvedBy: r[9] ?? null,
+    resolvedByType: r[10] ?? null
+  }));
+}
+class DeviationError extends Error {
+}
+function planOfDeviation(id) {
+  const row = (0, import_database.getDb)().exec(`SELECT plan_uid FROM deviations WHERE id = ?`, [id])[0]?.values[0];
+  return row ? row[0] : null;
+}
+const RESOLUTIONS = ["accepted", "reverted", "ignored"];
+function reconcileDeviations(planUid, requested, by) {
+  const own = new Set(getDeviations(planUid).map((d) => d.id));
+  const problems = [];
+  for (const d of requested) {
+    if (typeof d.id !== "number" || !own.has(d.id)) problems.push(`${String(d.id)} is not a deviation on this plan`);
+    if (!RESOLUTIONS.includes(d.action)) problems.push(`"${String(d.action)}" is not one of ${RESOLUTIONS.join(", ")}`);
+  }
+  if (problems.length) throw new DeviationError(`Nothing resolved: ${problems.join("; ")}.`);
+  for (const d of requested) resolveDeviation(d.id, d.action, by);
+  return requested.length;
+}
+const RECONCILED_ITEM_TITLE = "Reconciled changes";
+function resolveDeviation(deviationId, resolution, by = { actor: "codetrellis", actorType: "system" }) {
+  const db = (0, import_database.getDb)();
+  const now = Date.now();
+  db.run(
+    `UPDATE deviations SET resolution = ?, resolved_at = ?, resolved_by = ?, resolved_by_type = ? WHERE id = ?`,
+    [resolution, now, by.actor, by.actorType, deviationId]
+  );
+  (0, import_persistence.markDirty)();
+  if (resolution === "accepted") {
+    const devResult = db.exec(
+      `SELECT plan_uid, deviation_type, file_path FROM deviations WHERE id = ?`,
+      [deviationId]
+    );
+    if (!devResult[0]?.values[0]) return;
+    const [planUid, devType, filePath] = devResult[0].values[0];
+    if (!filePath || devType !== "unexpected_file" && devType !== "missing_file") return;
+    const items = (0, import_plan_item_service.listAllItems)(planUid).filter((i) => i.kind === "action");
+    const reconciledItem = items.find((i) => i.title === RECONCILED_ITEM_TITLE);
+    if (reconciledItem) {
+      const existingSpecs = reconciledItem.fileSpecs ?? [];
+      const already = existingSpecs.some((fs) => fs.path === filePath);
+      if (!already) {
+        (0, import_plan_item_service.updateItem)(reconciledItem.uid, {
+          fileSpecs: [...existingSpecs, { path: filePath, action: "modify" }],
+          // The plan changes because someone accepted the drift: in their name.
+          author: by.actor,
+          authorType: by.actorType,
+          changeSummary: `Accepted deviation: ${filePath}`
+        });
+      }
+    } else {
+      (0, import_plan_item_service.createItem)({
+        planUid,
+        kind: "action",
+        title: RECONCILED_ITEM_TITLE,
+        body: "Files accepted from drift detection \u2014 originally not in the plan but confirmed as intentional.",
+        fileSpecs: [{ path: filePath, action: "modify" }],
+        status: "done",
+        author: by.actor,
+        authorType: by.actorType
+      });
+    }
+    (0, import_server.broadcast)("plan-item-changed", { planUid });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DeviationError,
+  checkFileDeviation,
+  detectDeviations,
+  getDeviations,
+  planOfDeviation,
+  reconcileDeviations,
+  resolveDeviation
+});

package/src/backend/services/diff-engine.js

@@ -0,0 +1,168 @@
+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 diff_engine_exports = {};
+__export(diff_engine_exports, {
+  baselineLabel: () => baselineLabel,
+  captureSnapshot: () => captureSnapshot,
+  clearBaseline: () => clearBaseline,
+  computeDiff: () => computeDiff,
+  diffSnapshots: () => diffSnapshots,
+  getBaseline: () => getBaseline,
+  restoreBaseline: () => restoreBaseline,
+  setBaseline: () => setBaseline,
+  setBaselineStore: () => setBaselineStore
+});
+module.exports = __toCommonJS(diff_engine_exports);
+function baselineLabel(b) {
+  if (!b.shortCommitHash) return "working tree";
+  return b.dirty ? `${b.shortCommitHash} + uncommitted changes` : b.shortCommitHash;
+}
+let baselineSnapshot = null;
+let store = null;
+function setBaselineStore(next) {
+  store = next;
+}
+function captureSnapshot(fileData, depEdges) {
+  const files = /* @__PURE__ */ new Map();
+  for (const f of fileData) {
+    files.set(f.path, { hash: f.hash, symbolCount: f.symbolCount });
+  }
+  const edges = /* @__PURE__ */ new Set();
+  for (const e of depEdges) {
+    edges.add(`${e.sourceRelative}->${e.targetRelative}`);
+  }
+  return { timestamp: Date.now(), files, edges };
+}
+function setBaseline(snapshot, metadata) {
+  baselineSnapshot = {
+    ...snapshot,
+    commitHash: metadata?.commitHash ?? snapshot.commitHash ?? null,
+    shortCommitHash: metadata?.shortCommitHash ?? snapshot.shortCommitHash ?? null,
+    source: metadata?.source ?? "scan",
+    dirty: metadata?.dirty ?? false,
+    projectPath: metadata?.projectPath ?? null,
+    capturedAt: Date.now()
+  };
+  console.log(`[Diff] Baseline set (${baselineSnapshot.source}): ${snapshot.files.size} files, ${snapshot.edges.size} edges`);
+  if (store && baselineSnapshot.projectPath) {
+    try {
+      store.save(baselineSnapshot);
+    } catch (err) {
+      console.warn(`[Diff] Baseline not saved: ${err.message}`);
+    }
+  }
+}
+function clearBaseline() {
+  const projectPath = baselineSnapshot?.projectPath;
+  baselineSnapshot = null;
+  if (store && projectPath) {
+    try {
+      store.remove(projectPath);
+    } catch (err) {
+      console.warn(`[Diff] Stored baseline not removed: ${err.message}`);
+    }
+  }
+}
+function restoreBaseline(projectPath) {
+  if (!store) return null;
+  let stored = null;
+  try {
+    stored = store.load(projectPath);
+  } catch (err) {
+    console.warn(`[Diff] Stored baseline unreadable: ${err.message}`);
+  }
+  if (!stored) return null;
+  baselineSnapshot = stored;
+  console.log(`[Diff] Baseline restored (${stored.source}): ${stored.files.size} files, ${stored.edges.size} edges`);
+  return stored;
+}
+function getBaseline() {
+  return baselineSnapshot;
+}
+function diffSnapshots(before, current) {
+  const baselineSnapshot2 = before;
+  const addedFiles = [];
+  const removedFiles = [];
+  const modifiedFiles = [];
+  for (const [path, data] of current.files) {
+    const baseline = baselineSnapshot2.files.get(path);
+    if (!baseline) {
+      addedFiles.push(path);
+    } else if (baseline.hash !== data.hash) {
+      modifiedFiles.push(path);
+    }
+  }
+  for (const path of baselineSnapshot2.files.keys()) {
+    if (!current.files.has(path)) {
+      removedFiles.push(path);
+    }
+  }
+  const addedEdges = [];
+  const removedEdges = [];
+  for (const edge of current.edges) {
+    if (!baselineSnapshot2.edges.has(edge)) {
+      const [source, target] = edge.split("->");
+      addedEdges.push({ source, target });
+    }
+  }
+  for (const edge of baselineSnapshot2.edges) {
+    if (!current.edges.has(edge)) {
+      const [source, target] = edge.split("->");
+      removedEdges.push({ source, target });
+    }
+  }
+  const changedFiles = /* @__PURE__ */ new Set([...addedFiles, ...modifiedFiles]);
+  const blastRadius = [];
+  for (const edge of current.edges) {
+    const [source, target] = edge.split("->");
+    if (changedFiles.has(target) && !changedFiles.has(source)) {
+      blastRadius.push(source);
+    }
+  }
+  return {
+    addedFiles,
+    removedFiles,
+    modifiedFiles,
+    addedEdges,
+    removedEdges,
+    blastRadius: [...new Set(blastRadius)],
+    summary: {
+      added: addedFiles.length,
+      removed: removedFiles.length,
+      modified: modifiedFiles.length,
+      edgesAdded: addedEdges.length,
+      edgesRemoved: removedEdges.length
+    }
+  };
+}
+function computeDiff(current) {
+  if (!baselineSnapshot) return null;
+  return diffSnapshots(baselineSnapshot, current);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  baselineLabel,
+  captureSnapshot,
+  clearBaseline,
+  computeDiff,
+  diffSnapshots,
+  getBaseline,
+  restoreBaseline,
+  setBaseline,
+  setBaselineStore
+});