codetrellis 0.0.0-stage → 0.3.0

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

@@ -0,0 +1,305 @@
+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 artefact_service_exports = {};
+__export(artefact_service_exports, {
+  ARTEFACT_EXTS: () => ARTEFACT_EXTS,
+  ARTEFACT_ROLES: () => ARTEFACT_ROLES,
+  ArtefactError: () => ArtefactError,
+  artefactPathsForProject: () => artefactPathsForProject,
+  currentHashes: () => currentHashes,
+  getArtefact: () => getArtefact,
+  itemsWithArtefactAt: () => itemsWithArtefactAt,
+  listArtefacts: () => listArtefacts,
+  projectRootForItem: () => projectRootForItem,
+  recordArtefact: () => recordArtefact,
+  refreshArtefactHashes: () => refreshArtefactHashes
+});
+module.exports = __toCommonJS(artefact_service_exports);
+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 import_confined_fs = require("./confined-fs");
+var import_trusted_roots = require("./trusted-roots");
+var import_sha256_file = require("../lib/sha256-file");
+var import_cloud_files = require("./cloud-files");
+var import_material_place = require("./material-place");
+const ARTEFACT_ROLES = ["material", "output", "evidence"];
+const ARTEFACT_EXTS = /* @__PURE__ */ new Set([
+  "pdf",
+  "png",
+  "jpg",
+  "jpeg",
+  "gif",
+  "webp",
+  "svg",
+  "mp4",
+  "webm",
+  "mov",
+  "xlsx",
+  "xls",
+  "xlsm",
+  "csv",
+  "docx",
+  "pptx",
+  "md",
+  "txt",
+  "json",
+  "log",
+  "xml",
+  // JUnit reports — the evidence a `test` criterion reads (§8.1)
+  "html",
+  "htm"
+]);
+class ArtefactError extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.status = status;
+  }
+  status;
+}
+const rows = (sql, params = []) => (0, import_database.getDb)().exec(sql, params)[0]?.values ?? [];
+const ARTEFACT_COLS = "uid, target_uid, value, role, sha256, size, mtime, label, recorded_by, recorded_by_type, created_at";
+function toArtefact(r) {
+  return {
+    uid: r[0],
+    itemUid: r[1],
+    path: r[2],
+    role: r[3],
+    sha256: r[4] ?? null,
+    size: r[5] ?? null,
+    mtime: r[6] ?? null,
+    label: r[7] ?? null,
+    recordedBy: r[8] ?? "",
+    recordedByType: r[9] ?? "",
+    createdAt: r[10]
+  };
+}
+function listArtefacts(itemUid) {
+  return rows(
+    `SELECT ${ARTEFACT_COLS} FROM attachments
+     WHERE target_type = 'item' AND target_uid = ? AND role IS NOT NULL ORDER BY created_at`,
+    [itemUid]
+  ).map(toArtefact);
+}
+function getArtefact(uid) {
+  const r = rows(`SELECT ${ARTEFACT_COLS} FROM attachments WHERE uid = ? AND role IS NOT NULL`, [uid])[0];
+  return r ? toArtefact(r) : null;
+}
+function currentHashes(attachmentUids) {
+  const out = {};
+  for (const uid of attachmentUids) {
+    const r = rows(`SELECT sha256 FROM attachments WHERE uid = ?`, [uid])[0];
+    out[uid] = r?.[0] ?? null;
+  }
+  return out;
+}
+function projectRootForItem(itemUid) {
+  const projectPath = rows(
+    `SELECT p.project_path FROM plan_items i JOIN plans p ON p.uid = i.plan_uid WHERE i.uid = ?`,
+    [itemUid]
+  )[0]?.[0];
+  if (!projectPath) throw new ArtefactError("Item not found, or its plan has no project", 404);
+  try {
+    return (0, import_trusted_roots.resolveTrustedProjectRoot)(projectPath, "artefact project");
+  } catch {
+    throw new ArtefactError("This item's project is not open in CodeTrellis \u2014 open it first", 409);
+  }
+}
+function toProjectRelative(root, input) {
+  if (typeof input !== "string" || !input.trim()) throw new ArtefactError("path is required");
+  const trimmed = input.trim();
+  const placed = (0, import_material_place.isPlacePath)(trimmed) ? trimmed : import_node_path.default.isAbsolute(trimmed) ? (0, import_material_place.placeOf)(import_node_path.default.resolve(trimmed), (0, import_confined_fs.canonicalRoot)(root)) ?? (0, import_material_place.placeOf)(import_node_path.default.resolve(trimmed), root) : null;
+  if (placed && (0, import_material_place.isPlacePath)(placed)) {
+    const loc = (0, import_material_place.locateStored)(placed, root);
+    if (!loc) throw new ArtefactError("This project has no plans folder linked on this device \u2014 Settings \u2192 Plans folder");
+    try {
+      (0, import_confined_fs.resolveWithin)(loc.root, loc.rel, "artefact");
+    } catch (err) {
+      if (err instanceof import_confined_fs.ConfinementError) throw new ArtefactError("The path must be a file inside the plans folder, reached without a symbolic link");
+      throw err;
+    }
+    return `${import_material_place.PLANS_PREFIX}${loc.rel.split(import_node_path.default.sep).join("/")}`;
+  }
+  const canonRoot = (0, import_confined_fs.canonicalRoot)(root);
+  let resolved;
+  try {
+    resolved = (0, import_confined_fs.resolveWithin)(canonRoot, input.trim(), "artefact");
+  } catch (err) {
+    if (err instanceof import_confined_fs.ConfinementError) {
+      throw new ArtefactError("The path must be a file inside this item's project, reached without a symbolic link");
+    }
+    throw err;
+  }
+  if (!(0, import_confined_fs.isInside)(canonRoot, resolved) || resolved === canonRoot) {
+    throw new ArtefactError("The path must be a file inside this item's project");
+  }
+  return import_node_path.default.relative(canonRoot, resolved).split(import_node_path.default.sep).join("/");
+}
+async function recordArtefact(input) {
+  if (!ARTEFACT_ROLES.includes(input.role)) {
+    throw new ArtefactError(`role must be one of: ${ARTEFACT_ROLES.join(", ")}`);
+  }
+  const role = input.role;
+  const root = projectRootForItem(input.itemUid);
+  const rel = toProjectRelative(root, input.path);
+  const ext = import_node_path.default.extname(rel).slice(1).toLowerCase();
+  if (!ARTEFACT_EXTS.has(ext)) {
+    throw new ArtefactError(
+      `.${ext || "(none)"} files cannot be recorded as artefacts \u2014 the viewer shows ${[...ARTEFACT_EXTS].join(", ")}`
+    );
+  }
+  let hashed;
+  const at = (0, import_material_place.locateStored)(rel, root) ?? { root, rel };
+  try {
+    hashed = await (0, import_sha256_file.sha256FileWithin)(at.root, at.rel);
+  } catch (err) {
+    if (err instanceof import_cloud_files.NotOnDeviceError) throw new ArtefactError(`${err.message}. Make it available on this device, then record it.`, 409);
+    if (err instanceof import_confined_fs.ConfinementError) throw new ArtefactError("The path must be a regular file inside this item's project, not a link or folder");
+    if (err.code === "ENOENT") throw new ArtefactError(`No file at ${rel}`, 404);
+    throw err;
+  }
+  const db = (0, import_database.getDb)();
+  const existing = rows(
+    `SELECT uid FROM attachments WHERE target_type = 'item' AND target_uid = ? AND value = ? AND kind = 'file_ref'`,
+    [input.itemUid, rel]
+  )[0];
+  const label = input.note?.trim() || import_node_path.default.basename(rel);
+  let uid;
+  if (existing) {
+    uid = existing[0];
+    db.run(
+      `UPDATE attachments SET role = ?, sha256 = ?, size = ?, mtime = ?, label = ?,
+         recorded_by = ?, recorded_by_type = ? WHERE uid = ?`,
+      [
+        role,
+        hashed.sha256,
+        hashed.size,
+        Math.round(hashed.mtimeMs),
+        label,
+        input.actor.author,
+        input.actor.authorType,
+        uid
+      ]
+    );
+  } else {
+    uid = (0, import_node_crypto.randomUUID)();
+    db.run(
+      `INSERT INTO attachments
+         (uid, target_type, target_uid, kind, value, label, content_type, author, author_type, created_at,
+          role, sha256, size, mtime, recorded_by, recorded_by_type)
+       VALUES (?, 'item', ?, 'file_ref', ?, ?, NULL, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        uid,
+        input.itemUid,
+        rel,
+        label,
+        input.actor.author,
+        input.actor.authorType,
+        Date.now(),
+        role,
+        hashed.sha256,
+        hashed.size,
+        Math.round(hashed.mtimeMs),
+        input.actor.author,
+        input.actor.authorType
+      ]
+    );
+  }
+  (0, import_persistence.markDirty)();
+  return getArtefact(uid);
+}
+async function refreshArtefactHashes(itemUid) {
+  const artefacts = listArtefacts(itemUid);
+  if (artefacts.length === 0) return [];
+  let root;
+  try {
+    root = projectRootForItem(itemUid);
+  } catch {
+    return [];
+  }
+  const changed = [];
+  for (const a of artefacts) {
+    let next;
+    try {
+      const at = (0, import_material_place.locateStored)(a.path, root);
+      if (!at) throw new import_confined_fs.ConfinementError("not placed on this device");
+      const abs = (0, import_confined_fs.resolveWithin)(at.root, at.rel, "artefact");
+      const st = import_node_fs.default.lstatSync(abs);
+      if (!st.isFile()) throw new import_confined_fs.ConfinementError("not a file");
+      if (st.size === a.size && Math.round(st.mtimeMs) === a.mtime && a.sha256) continue;
+      const h = await (0, import_sha256_file.sha256FileWithin)(at.root, at.rel);
+      next = { sha256: h.sha256, size: h.size, mtime: Math.round(h.mtimeMs) };
+    } catch (err) {
+      if (err instanceof import_cloud_files.NotOnDeviceError) continue;
+      next = { sha256: null, size: null, mtime: null };
+    }
+    if (next.sha256 !== a.sha256 || next.size !== a.size || next.mtime !== a.mtime) {
+      (0, import_database.getDb)().run(
+        `UPDATE attachments SET sha256 = ?, size = ?, mtime = ? WHERE uid = ?`,
+        [next.sha256, next.size, next.mtime, a.uid]
+      );
+      if (next.sha256 !== a.sha256) changed.push(a.uid);
+    }
+  }
+  if (changed.length) (0, import_persistence.markDirty)();
+  return changed;
+}
+function itemsWithArtefactAt(projectPath, rel) {
+  return rows(
+    `SELECT DISTINCT a.target_uid FROM attachments a
+       JOIN plan_items i ON i.uid = a.target_uid
+       JOIN plans p ON p.uid = i.plan_uid
+     WHERE a.role IS NOT NULL AND a.value = ? AND p.project_path = ?`,
+    [rel, projectPath]
+  ).map((r) => r[0]);
+}
+function artefactPathsForProject(projectPath) {
+  return rows(
+    `SELECT DISTINCT a.value FROM attachments a
+       JOIN plan_items i ON i.uid = a.target_uid
+       JOIN plans p ON p.uid = i.plan_uid
+     WHERE a.role IS NOT NULL AND p.project_path = ?`,
+    [projectPath]
+  ).map((r) => r[0]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ARTEFACT_EXTS,
+  ARTEFACT_ROLES,
+  ArtefactError,
+  artefactPathsForProject,
+  currentHashes,
+  getArtefact,
+  itemsWithArtefactAt,
+  listArtefacts,
+  projectRootForItem,
+  recordArtefact,
+  refreshArtefactHashes
+});

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

@@ -0,0 +1,167 @@
+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 artefact_watcher_exports = {};
+__export(artefact_watcher_exports, {
+  startArtefactWatcherForProject: () => startArtefactWatcherForProject,
+  startArtefactWatching: () => startArtefactWatching,
+  stopArtefactWatchers: () => stopArtefactWatchers,
+  watchPlanArtefacts: () => watchPlanArtefacts
+});
+module.exports = __toCommonJS(artefact_watcher_exports);
+var _lazy____server = __toESM(require("../server"));
+var import_node_path = __toESM(require("node:path"));
+var import_chokidar = __toESM(require("chokidar"));
+var import_artefact_service = require("./artefact-service");
+var import_criteria_service = require("./criteria-service");
+var import_criterion_loop_service = require("./criterion-loop-service");
+var import_sensor_bridge_service = require("./sensor-bridge-service");
+var import_database = require("./database");
+var import_trusted_roots = require("./trusted-roots");
+var awareness = __toESM(require("./awareness-service"));
+var import_material_place = require("./material-place");
+const watches = /* @__PURE__ */ new Map();
+function planUidOf(itemUid) {
+  return (0, import_database.getDb)().exec(`SELECT plan_uid FROM plan_items WHERE uid = ?`, [itemUid])[0]?.values[0]?.[0] ?? null;
+}
+function projectPathOf(itemUid) {
+  return (0, import_database.getDb)().exec(
+    `SELECT p.project_path FROM plan_items i JOIN plans p ON p.uid = i.plan_uid WHERE i.uid = ?`,
+    [itemUid]
+  )[0]?.values[0]?.[0] ?? null;
+}
+async function onArtefactChanged(w, absPath) {
+  const rel = (0, import_material_place.placeOf)(absPath, w.root) ?? import_node_path.default.relative(w.root, absPath).split(import_node_path.default.sep).join("/");
+  let anyChanged = false;
+  try {
+    for (const itemUid of (0, import_artefact_service.itemsWithArtefactAt)(w.projectPath, rel)) {
+      const moved = await onItemArtefactChanged(itemUid, rel);
+      anyChanged ||= moved;
+    }
+  } finally {
+    if (anyChanged) {
+      await awareness.refreshSignals(w.projectPath).catch((err) => console.warn("[Artefacts] Signal refresh failed:", err));
+    }
+  }
+}
+async function onItemArtefactChanged(itemUid, rel) {
+  const wasMet = new Set((0, import_criteria_service.listCriteria)(itemUid).filter((c) => c.state === "met").map((c) => c.uid));
+  const changed = await (0, import_artefact_service.refreshArtefactHashes)(itemUid);
+  if (changed.length === 0) return false;
+  const nowStale = (0, import_criteria_service.listCriteria)(itemUid).filter((c) => c.state === "stale" && wasMet.has(c.uid));
+  try {
+    _lazy____server.broadcast("plan-item-criteria-changed", { planUid: planUidOf(itemUid), itemUid });
+  } catch {
+  }
+  const planUid = planUidOf(itemUid);
+  if (!planUid) return true;
+  try {
+    const run = await (0, import_criterion_loop_service.runCheckRun)({
+      planUid,
+      trigger: "material_changed",
+      by: "codetrellis",
+      byType: "system",
+      itemUids: [itemUid]
+    });
+    _lazy____server.broadcast("plan-check-run", { planUid, runUid: run.uid });
+  } catch (err) {
+    console.warn("[Artefacts] Check run after a change failed:", err);
+  }
+  for (const c of nowStale) {
+    (0, import_sensor_bridge_service.postCriterionNotice)({
+      planUid,
+      itemUid,
+      criterionUid: c.uid,
+      reason: "stale",
+      message: `"${c.text}" was approved, and ${rel} has changed since. Is it still met?`
+    });
+  }
+  return true;
+}
+function startArtefactWatcherForProject(projectPath) {
+  if (watches.has(projectPath)) return;
+  let root;
+  try {
+    root = (0, import_trusted_roots.resolveTrustedProjectRoot)(projectPath, "artefact watcher");
+  } catch {
+    return;
+  }
+  const watcher = import_chokidar.default.watch([], {
+    ignoreInitial: true,
+    persistent: true,
+    awaitWriteFinish: { stabilityThreshold: 200, pollInterval: 50 },
+    followSymlinks: false
+  });
+  const w = { watcher, projectPath, root };
+  watcher.on("all", (event, file) => {
+    if (event !== "change" && event !== "add" && event !== "unlink") return;
+    void onArtefactChanged(w, file).catch((err) => console.warn("[Artefacts] Refresh failed:", err));
+  });
+  watcher.on("error", (err) => console.warn("[Artefacts] Watcher error:", err));
+  for (const rel of (0, import_artefact_service.artefactPathsForProject)(projectPath)) {
+    const at = (0, import_material_place.locateStored)(rel, root);
+    if (at) watcher.add(import_node_path.default.join(at.root, at.rel));
+  }
+  watches.set(projectPath, w);
+}
+function startArtefactWatching(artefact) {
+  const projectPath = projectPathOf(artefact.itemUid);
+  if (!projectPath) return;
+  if (!watches.has(projectPath)) startArtefactWatcherForProject(projectPath);
+  const w = watches.get(projectPath);
+  if (!w) return;
+  try {
+    const at = (0, import_material_place.locateStored)(artefact.path, (0, import_artefact_service.projectRootForItem)(artefact.itemUid));
+    if (at) w.watcher.add(import_node_path.default.join(at.root, at.rel));
+  } catch {
+  }
+}
+function watchPlanArtefacts(projectPath, planUid) {
+  if (!watches.has(projectPath)) startArtefactWatcherForProject(projectPath);
+  const w = watches.get(projectPath);
+  if (!w) return;
+  const values = ((0, import_database.getDb)().exec(
+    `SELECT DISTINCT a.value FROM attachments a JOIN plan_items i ON i.uid = a.target_uid
+     WHERE i.plan_uid = ? AND a.target_type = 'item' AND a.kind = 'file_ref' AND a.role IS NOT NULL`,
+    [planUid]
+  )[0]?.values ?? []).map((r) => String(r[0]));
+  for (const v of values) {
+    const at = (0, import_material_place.locateStored)(v, w.root);
+    if (at) w.watcher.add(import_node_path.default.join(at.root, at.rel));
+  }
+}
+function stopArtefactWatchers() {
+  for (const w of watches.values()) void w.watcher.close();
+  watches.clear();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  startArtefactWatcherForProject,
+  startArtefactWatching,
+  stopArtefactWatchers,
+  watchPlanArtefacts
+});