codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/architecture-rules.js

@@ -0,0 +1,275 @@
+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 architecture_rules_exports = {};
+__export(architecture_rules_exports, {
+  DEFAULT_SUITE: () => DEFAULT_SUITE,
+  RuleError: () => RuleError,
+  breachWords: () => import_architecture_rule2.breachWords,
+  breaks: () => import_architecture_rule2.breaks,
+  checkEdges: () => import_architecture_rule2.checkEdges,
+  combineRules: () => combineRules,
+  edgesIfLoaded: () => edgesIfLoaded,
+  findRule: () => findRule,
+  grepReads: () => import_architecture_rule2.grepReads,
+  inPattern: () => import_architecture_rule2.inPattern,
+  moveRulesFromConfig: () => moveRulesFromConfig,
+  parseArchitectureRule: () => import_architecture_rule2.parseArchitectureRule,
+  proposedRule: () => proposedRule,
+  removeRule: () => removeRule,
+  ruleStatement: () => import_architecture_rule2.ruleStatement,
+  ruleWords: () => import_architecture_rule2.ruleWords,
+  rulebookProblems: () => rulebookProblems,
+  rulesInConfig: () => rulesInConfig,
+  rulesOf: () => rulesOf,
+  rulesView: () => rulesView,
+  setRule: () => setRule
+});
+module.exports = __toCommonJS(architecture_rules_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_project_config_service = require("./project-config-service");
+var import_architecture_rule = require("./architecture-rule");
+var import_grep_entry = require("../../shared/lib/grep-entry");
+var import_confined_fs = require("./confined-fs");
+var import_node_child_process = require("node:child_process");
+var import_symbol_entry = require("../../shared/lib/symbol-entry");
+var import_rulebook = require("./rulebook");
+var import_database = require("./database");
+var import_importers = require("./importers");
+var import_architecture_rule2 = require("./architecture-rule");
+class RuleError extends Error {
+  constructor(message, status = 400) {
+    super(message);
+    this.status = status;
+  }
+  status;
+}
+const DEFAULT_SUITE = "architecture";
+const CONFIG_WHERE = ".codetrellis/config.json";
+function rulesInConfig(projectRoot) {
+  return ((0, import_project_config_service.getProjectConfig)(projectRoot).rules ?? []).map((r) => (0, import_architecture_rule.parseArchitectureRule)(r).rule).filter((r) => r !== null);
+}
+function combineRules(fromSuites, fromConfig) {
+  const ids = new Set(fromSuites.map((r) => r.id));
+  return [...fromSuites, ...fromConfig.filter((r) => !ids.has(r.id))];
+}
+function rulesOf(projectRoot) {
+  return combineRules((0, import_rulebook.readRulebook)(projectRoot).suites.flatMap((s) => s.rules), rulesInConfig(projectRoot));
+}
+function rulebookProblems(projectRoot) {
+  return (0, import_rulebook.readRulebook)(projectRoot).problems;
+}
+const whereOf = (rule) => rule.suite ? (0, import_rulebook.suiteFile)(rule.suite) : CONFIG_WHERE;
+function suiteRules(projectRoot, suite) {
+  return (0, import_rulebook.readRulebook)(projectRoot).suites.find((s) => s.name === suite)?.rules ?? [];
+}
+function proposedRule(projectRoot, raw, by, now = Date.now()) {
+  const existing = rulesOf(projectRoot).find((r) => r.id === raw.id) ?? null;
+  const suite = raw.suite === void 0 || raw.suite === "" ? existing?.suite ?? DEFAULT_SUITE : raw.suite;
+  if (!(0, import_rulebook.isSuiteName)(suite)) throw new RuleError("suite must be a short name, like payments");
+  const strength = raw.strength ?? existing?.strength ?? "warn";
+  const { rule: parsed, problems } = (0, import_architecture_rule.parseArchitectureRule)({ ...raw, strength, since: existing?.since ?? new Date(now).toISOString(), by });
+  if (!parsed) throw new RuleError(problems.join("; "));
+  return { rule: { ...parsed, suite }, existing };
+}
+function findRule(projectRoot, id) {
+  return rulesOf(projectRoot).find((r) => r.id === id) ?? null;
+}
+function ruleOf(projectRoot, id) {
+  const rule = rulesOf(projectRoot).find((r) => r.id === id);
+  if (!rule) throw new RuleError(`No architecture rule "${id}" in this project`, 404);
+  return rule;
+}
+function setRule(projectRoot, raw, by, now = Date.now()) {
+  const { rule, existing } = proposedRule(projectRoot, raw, by, now);
+  const suite = rule.suite;
+  (0, import_rulebook.writeSuite)(projectRoot, suite, suiteRules(projectRoot, suite).filter((r) => r.id !== rule.id).concat(rule));
+  if (existing?.suite && existing.suite !== suite) {
+    (0, import_rulebook.writeSuite)(projectRoot, existing.suite, suiteRules(projectRoot, existing.suite).filter((r) => r.id !== rule.id));
+  }
+  if (rulesInConfig(projectRoot).some((r) => r.id === rule.id)) {
+    (0, import_project_config_service.updateProjectConfig)(projectRoot, { rules: rulesInConfig(projectRoot).filter((r) => r.id !== rule.id) });
+  }
+  return rule;
+}
+function removeRule(projectRoot, id) {
+  const rule = ruleOf(projectRoot, id);
+  if (rule.suite) (0, import_rulebook.writeSuite)(projectRoot, rule.suite, suiteRules(projectRoot, rule.suite).filter((r) => r.id !== id));
+  if (rulesInConfig(projectRoot).some((r) => r.id === id)) {
+    (0, import_project_config_service.updateProjectConfig)(projectRoot, { rules: rulesInConfig(projectRoot).filter((r) => r.id !== id) });
+  }
+}
+function moveRulesFromConfig(projectRoot) {
+  const inConfig = rulesInConfig(projectRoot);
+  if (inConfig.length === 0) return [];
+  const taken = new Set((0, import_rulebook.readRulebook)(projectRoot).suites.flatMap((s) => s.rules.map((r) => r.id)));
+  const moving = inConfig.filter((r) => !taken.has(r.id)).map((r) => ({ ...r, suite: DEFAULT_SUITE }));
+  if (moving.length) (0, import_rulebook.writeSuite)(projectRoot, DEFAULT_SUITE, [...suiteRules(projectRoot, DEFAULT_SUITE), ...moving]);
+  (0, import_project_config_service.updateProjectConfig)(projectRoot, { rules: [] });
+  return moving.map((r) => r.id);
+}
+function rulesView(projectRoot, edges) {
+  return rulesOf(projectRoot).map((rule) => {
+    const breaches = edges && rule.strength !== "guide" && rule.kind !== "agent" ? (0, import_architecture_rule.checkEdges)([rule], edges) : null;
+    return {
+      rule,
+      where: whereOf(rule),
+      words: (0, import_architecture_rule.ruleWords)(rule),
+      breaches,
+      breachWords: rule.strength === "guide" ? "A guide: shown to agents whose work touches it, never checked" : rule.kind === "agent" ? "Judged by an agent review, against its words: no code checks it, and with no review it is a guide" : breaches === null ? "Open this project to see what breaks it today" : breaches.length === 0 ? "Nothing breaks this today" : `${breaches.length} ${breakers(rule, breaches.length)} this today`
+    };
+  });
+}
+function breakers(rule, n) {
+  const [one, many] = rule.kind === "grep" ? rule.must ? ["file breaks", "files break"] : ["line breaks", "lines break"] : ["import breaks", "imports break"];
+  return n === 1 ? one : many;
+}
+function edgesIfLoaded(projectRoot, loadedRoot, edges, packages = packageEdgesOfGraph, alsoRules = []) {
+  if (!loadedRoot) return null;
+  const real = (p) => {
+    try {
+      return import_node_fs.default.realpathSync(p);
+    } catch {
+      return import_node_path.default.resolve(p);
+    }
+  };
+  if (real(loadedRoot) !== real(projectRoot)) return null;
+  const rules = [...rulesOf(projectRoot), ...alsoRules];
+  return [...edges(), ...packages(), ...symbolEdgesOfGraph(projectRoot, rules), ...callEdgesOfGraph(rules), ...fileFactsOfGraph(rules), ...grepEdgesOfTree(projectRoot, rules)].map((e) => ({ from: e.sourceRelative, to: e.targetRelative }));
+}
+const MAX_GREP_FILES = 2e4;
+const MAX_GREP_BYTES = 1024 * 1024;
+function grepEdgesOfTree(projectRoot, rules) {
+  const grep = rules.filter((r) => r.kind === "grep" && r.strength !== "guide");
+  if (grep.length === 0) return [];
+  let files;
+  try {
+    files = (0, import_node_child_process.execFileSync)("git", ["ls-files", "-z", "--cached", "--others", "--exclude-standard"], { cwd: projectRoot, encoding: "utf8", maxBuffer: 64 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] }).split("\0").filter(Boolean);
+  } catch {
+    files = [...(0, import_database.getAllFileHashes)().keys()].map((abs) => import_node_path.default.relative(projectRoot, abs).split(import_node_path.default.sep).join("/")).filter((rel) => !rel.startsWith(".."));
+  }
+  const out = [];
+  for (const rel of [...new Set(files)].slice(0, MAX_GREP_FILES)) {
+    const reading = grep.filter((r) => (0, import_architecture_rule.grepReads)(r, rel));
+    if (reading.length === 0) continue;
+    let text;
+    try {
+      if (import_node_fs.default.statSync((0, import_confined_fs.resolveWithin)(projectRoot, rel)).size > MAX_GREP_BYTES) continue;
+      text = (0, import_confined_fs.readFileWithin)(projectRoot, rel).toString("utf-8");
+    } catch {
+      continue;
+    }
+    for (const rule of reading) for (const e of (0, import_grep_entry.grepEntries)(rule, text)) out.push({ sourceRelative: rel, targetRelative: e });
+  }
+  return out;
+}
+function fileFactsOfGraph(rules) {
+  if (!rules.some((r) => r.kind === "folder")) return [];
+  try {
+    return (0, import_database.getFileFacts)();
+  } catch {
+    return [];
+  }
+}
+function callEdgesOfGraph(rules) {
+  if (!rules.some((r) => r.kind === "calls")) return [];
+  try {
+    return (0, import_database.getCallEdges)();
+  } catch {
+    return [];
+  }
+}
+function symbolEdgesOfGraph(projectRoot, rules) {
+  const out = [];
+  const done = /* @__PURE__ */ new Set();
+  for (const rule of rules) {
+    if (rule.kind !== "symbol" || done.has(`${rule.match ?? ""}:${rule.mayNotImport}`)) continue;
+    done.add(`${rule.match ?? ""}:${rule.mayNotImport}`);
+    if (rule.match) {
+      out.push(...matchedSymbolEdges(rule));
+      continue;
+    }
+    const sym = (0, import_symbol_entry.splitSymbol)(rule.mayNotImport);
+    if (!sym) continue;
+    try {
+      for (const i of (0, import_importers.importersOf)(import_node_path.default.join(projectRoot, sym.file), [sym.name])) out.push({ sourceRelative: i.relativePath, targetRelative: rule.mayNotImport });
+    } catch {
+    }
+  }
+  return out;
+}
+function matchedSymbolEdges(rule) {
+  const out = [];
+  try {
+    const byFile = /* @__PURE__ */ new Map();
+    for (const s of (0, import_importers.exportedSymbols)()) {
+      if (!(0, import_architecture_rule.targetMatches)(rule, (0, import_symbol_entry.symbolEntry)(s.rel, s.name))) continue;
+      const f = byFile.get(s.path) ?? { rel: s.rel, names: [] };
+      f.names.push(s.name);
+      byFile.set(s.path, f);
+    }
+    for (const [abs, f] of byFile) {
+      for (const i of (0, import_importers.importersOf)(abs, f.names)) {
+        for (const name of i.names.filter((n) => f.names.includes(n))) out.push({ sourceRelative: i.relativePath, targetRelative: (0, import_symbol_entry.symbolEntry)(f.rel, name) });
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+function packageEdgesOfGraph() {
+  try {
+    return (0, import_database.getPackageEdges)();
+  } catch {
+    return [];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_SUITE,
+  RuleError,
+  breachWords,
+  breaks,
+  checkEdges,
+  combineRules,
+  edgesIfLoaded,
+  findRule,
+  grepReads,
+  inPattern,
+  moveRulesFromConfig,
+  parseArchitectureRule,
+  proposedRule,
+  removeRule,
+  ruleStatement,
+  ruleWords,
+  rulebookProblems,
+  rulesInConfig,
+  rulesOf,
+  rulesView,
+  setRule
+});

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

@@ -0,0 +1,181 @@
+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_content_service_exports = {};
+__export(artefact_content_service_exports, {
+  absolutePathOf: () => absolutePathOf,
+  isAttachmentUid: () => isAttachmentUid,
+  readServableCapped: () => readServableCapped,
+  resolveServable: () => resolveServable,
+  serveFile: () => serveFile,
+  serveReportAsset: () => serveReportAsset,
+  viewContentType: () => viewContentType
+});
+module.exports = __toCommonJS(artefact_content_service_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_database = require("./database");
+var import_confined_fs = require("./confined-fs");
+var import_trusted_roots = require("./trusted-roots");
+var import_task_attachments_service = require("./task-attachments-service");
+var import_artefact_service = require("./artefact-service");
+var import_html_view_policy = require("./html-view-policy");
+var import_cloud_files = require("./cloud-files");
+const VIEW_TYPES = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  svg: "image/svg+xml",
+  mp4: "video/mp4",
+  webm: "video/webm",
+  mov: "video/quicktime",
+  pdf: "application/pdf",
+  csv: "text/csv; charset=utf-8",
+  md: "text/plain; charset=utf-8",
+  txt: "text/plain; charset=utf-8",
+  log: "text/plain; charset=utf-8",
+  json: "text/plain; charset=utf-8",
+  xml: "text/plain; charset=utf-8",
+  html: "text/plain; charset=utf-8",
+  htm: "text/plain; charset=utf-8",
+  xlsx: "application/octet-stream",
+  xls: "application/octet-stream",
+  xlsm: "application/octet-stream",
+  docx: "application/octet-stream",
+  pptx: "application/octet-stream"
+};
+function viewContentType(rel) {
+  return VIEW_TYPES[import_node_path.default.extname(rel).slice(1).toLowerCase()] ?? null;
+}
+function isAttachmentUid(uid) {
+  return typeof uid === "string" && /^[A-Za-z0-9-]{8,64}$/.test(uid);
+}
+async function resolveServable(uid) {
+  if (!isAttachmentUid(uid)) return null;
+  const db = (0, import_database.getDb)();
+  const row = db.exec(`SELECT value, target_uid, role FROM attachments WHERE uid = ?`, [uid])[0]?.values[0];
+  if (!row) return null;
+  const value = row[0];
+  const itemUid = row[1];
+  let trustedRoot = null;
+  const projectPath = db.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];
+  if (projectPath) {
+    try {
+      trustedRoot = (0, import_trusted_roots.resolveTrustedProjectRoot)(projectPath, "attachment project");
+    } catch {
+      trustedRoot = null;
+    }
+  }
+  const location = (0, import_task_attachments_service.resolveAttachmentLocation)(value, itemUid, trustedRoot);
+  const contentType = location ? viewContentType(location.rel) : null;
+  if (!location || !contentType) return null;
+  if (row[2]) await (0, import_artefact_service.refreshArtefactHashes)(itemUid).catch(() => []);
+  return { root: location.root, rel: location.rel, contentType, itemUid };
+}
+function readServableCapped(file, cap) {
+  if ((0, import_cloud_files.isPlaceholder)((0, import_confined_fs.resolveWithin)(file.root, file.rel, "attachment"))) return Promise.reject(new import_cloud_files.NotOnDeviceError(file.rel));
+  const { stream, size } = (0, import_confined_fs.openReadStreamWithin)(file.root, file.rel, {}, "attachment");
+  if (size > cap) {
+    stream.destroy();
+    return Promise.resolve(null);
+  }
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let read = 0;
+    stream.on("data", (chunk) => {
+      const c = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+      read += c.length;
+      if (read > cap) {
+        stream.destroy();
+        resolve(null);
+        return;
+      }
+      chunks.push(c);
+    });
+    stream.on("error", reject);
+    stream.on("end", () => resolve(Buffer.concat(chunks)));
+  });
+}
+function absolutePathOf(file) {
+  return (0, import_confined_fs.resolveWithin)(file.root, file.rel, "attachment");
+}
+function serveFile(file, rangeHeader) {
+  let range;
+  const m = (rangeHeader ?? "").match(/^bytes=(\d+)-(\d*)$/);
+  if (m) range = { start: Number(m[1]), end: m[2] ? Number(m[2]) : void 0 };
+  let opened;
+  try {
+    if ((0, import_cloud_files.isPlaceholder)((0, import_confined_fs.resolveWithin)(file.root, file.rel, "attachment"))) {
+      return { status: 409, headers: {}, stream: null, error: "The file is not on this device yet: it is still only in the cloud" };
+    }
+    opened = (0, import_confined_fs.openReadStreamWithin)(file.root, file.rel, range ?? {}, "attachment");
+  } catch {
+    return { status: 404, headers: {}, stream: null, error: "The file is not there, or is not a regular file in the project" };
+  }
+  const { stream, size } = opened;
+  const headers = {
+    "Content-Type": file.contentType,
+    "X-Content-Type-Options": "nosniff",
+    // Files change (a recorded output is edited), so nothing is cached.
+    "Cache-Control": "no-store",
+    // Harmless for <img>/<video>; stops a file opened directly from running
+    // script in this origin.
+    "Content-Security-Policy": "default-src 'none'; style-src 'unsafe-inline'; sandbox",
+    "Accept-Ranges": "bytes"
+  };
+  if (!range) {
+    headers["Content-Length"] = String(size);
+    return { status: 200, headers, stream };
+  }
+  const end = Math.min(range.end ?? size - 1, size - 1);
+  if (range.start > end) {
+    stream.destroy();
+    return { status: 416, headers: { "Content-Range": `bytes */${size}` }, stream: null, error: "Range not satisfiable" };
+  }
+  headers["Content-Range"] = `bytes ${range.start}-${end}/${size}`;
+  headers["Content-Length"] = String(end - range.start + 1);
+  return { status: 206, headers, stream };
+}
+async function serveReportAsset(uid, urlPath, scripts) {
+  const report = isAttachmentUid(uid) ? await resolveServable(uid) : null;
+  if (!report) return { status: 404, headers: {}, stream: null, error: "Not part of this report" };
+  return (0, import_html_view_policy.serveReportFile)(report, urlPath, scripts);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  absolutePathOf,
+  isAttachmentUid,
+  readServableCapped,
+  resolveServable,
+  serveFile,
+  serveReportAsset,
+  viewContentType
+});