codetrellis 0.0.0-stage → 0.2.0

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

@@ -0,0 +1,150 @@
+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 skills_service_exports = {};
+__export(skills_service_exports, {
+  agentSkills: () => agentSkills,
+  frontMatter: () => frontMatter,
+  listProjectSkills: () => listProjectSkills,
+  readProjectSkill: () => readProjectSkill,
+  skillsNote: () => import_skills_note.skillsNote
+});
+module.exports = __toCommonJS(skills_service_exports);
+var fs = __toESM(require("node:fs"));
+var import_yaml = require("yaml");
+var import_confined_fs = require("./confined-fs");
+var import_skill_model = require("./skill-model");
+var import_skills_note = require("../../shared/lib/skills-note");
+const SKILLS_DIR = ".claude/skills";
+const MAX_SKILL_FILE = 256 * 1024;
+const MAX_DESCRIPTION = 300;
+const MAX_INDEX = 200;
+function oneLine(s) {
+  return s.replace(/[\u0000-\u001f\u007f]+/g, " ").replace(/\s+/g, " ").trim();
+}
+function frontMatter(text) {
+  const m = text.match(/^\uFEFF?---\r?\n([\s\S]*?)\r?\n---\r?(?:\n|$)/);
+  if (!m) return {};
+  try {
+    const meta = (0, import_yaml.parse)(m[1]);
+    return meta && typeof meta === "object" && !Array.isArray(meta) ? meta : {};
+  } catch {
+    return {};
+  }
+}
+function listProjectSkills(projectRoot) {
+  let base;
+  try {
+    base = (0, import_confined_fs.resolveWithin)(projectRoot, SKILLS_DIR, "skills folder");
+    if (!fs.lstatSync(base).isDirectory()) return [];
+  } catch {
+    return [];
+  }
+  const out = [];
+  let entries;
+  try {
+    entries = fs.readdirSync(base, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  for (const ent of entries) {
+    if (!ent.isDirectory() || ent.name.startsWith(".")) continue;
+    const rel = `${SKILLS_DIR}/${ent.name}/SKILL.md`;
+    let text;
+    try {
+      const buf = (0, import_confined_fs.readFileWithin)(projectRoot, rel, "skill");
+      if (buf.length > MAX_SKILL_FILE) continue;
+      text = buf.toString("utf-8");
+    } catch {
+      continue;
+    }
+    const meta = frontMatter(text);
+    const named = typeof meta.name === "string" ? oneLine(meta.name) : "";
+    const name = named && named.length <= import_skill_model.MAX_SKILL_NAME && !named.includes("`") ? named : ent.name;
+    const description = typeof meta.description === "string" ? oneLine(meta.description).slice(0, MAX_DESCRIPTION) : "";
+    out.push({ name, description, path: rel });
+    if (out.length >= MAX_INDEX) break;
+  }
+  return out.sort((a, b) => a.name.localeCompare(b.name));
+}
+function presentIn(root, rel) {
+  try {
+    (0, import_confined_fs.readFileWithin)(root, rel, "skill");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function readProjectSkill(root, name) {
+  const skill = listProjectSkills(root).find((s) => s.name === name);
+  if (!skill) return null;
+  try {
+    const buf = (0, import_confined_fs.readFileWithin)(root, skill.path, "skill");
+    return buf.length > MAX_SKILL_FILE ? null : { skill, text: buf.toString("utf-8") };
+  } catch {
+    return null;
+  }
+}
+function agentSkills(skills, ctx) {
+  const wanted = skills.filter((s) => s.required || s.use === "recommended");
+  if (wanted.length === 0) return [];
+  let index = null;
+  const indexed = (name) => {
+    if (!ctx.projectRoot) return null;
+    index ??= listProjectSkills(ctx.projectRoot);
+    return index.find((p) => p.name === name) ?? null;
+  };
+  return wanted.map((s) => {
+    let where = s.where && s.where.kind !== "link" ? s.where : null;
+    if (!where && s.source === "skill") {
+      const found = indexed(s.name);
+      if (found) where = { kind: "repo", path: found.path };
+    }
+    let missing = null;
+    if (where?.kind === "repo") {
+      const rel = (0, import_skill_model.normaliseRepoPath)(where.path);
+      where = rel ? { kind: "repo", path: rel } : null;
+    }
+    if (where?.kind === "repo") {
+      if (!ctx.projectRoot || !presentIn(ctx.projectRoot, where.path)) {
+        missing = `${where.path} is not in the project`;
+        where = null;
+      } else if (ctx.workstreamRoot && ctx.workstreamRoot !== ctx.projectRoot && !presentIn(ctx.workstreamRoot, where.path)) {
+        missing = `${where.path} is not in your workstream (it is in the project's main checkout): bring your branch up to date with the main branch to get it`;
+      }
+    }
+    return { name: s.name, use: s.required ? "required" : "recommended", why: s.why ?? null, where, missing };
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  agentSkills,
+  frontMatter,
+  listProjectSkills,
+  readProjectSkill,
+  skillsNote
+});

package/src/backend/services/snapshot-compare-service.js

@@ -0,0 +1,397 @@
+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 snapshot_compare_service_exports = {};
+__export(snapshot_compare_service_exports, {
+  canSupplyContent: () => canSupplyContent,
+  comparandBranches: () => comparandBranches,
+  compareSnapshots: () => compareSnapshots,
+  listComparands: () => listComparands,
+  readFileAt: () => readFileAt,
+  resolveComparand: () => resolveComparand
+});
+module.exports = __toCommonJS(snapshot_compare_service_exports);
+var import_node_child_process = require("node:child_process");
+var import_git_safety = require("./git-safety");
+var import_database = require("./database");
+var import_diff_engine = require("./diff-engine");
+var import_trellis_service = require("./trellis-service");
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = require("node:crypto");
+var import_ast_parser = require("./ast-parser");
+var import_resolvers = require("./resolvers");
+var import_commit_edges = require("./commit-edges");
+var import_workstream_service = require("./workstream-service");
+var import_git_refs = require("./git-refs");
+var import_git_safety2 = require("./git-safety");
+var import_trusted_roots = require("./trusted-roots");
+var import_confined_fs = require("./confined-fs");
+var import_node_fs = __toESM(require("node:fs"));
+function liveSnapshot(projectPath) {
+  const hashes = (0, import_database.getAllFileHashes)();
+  const fileData = [...hashes.entries()].map(([absPath, hash]) => ({
+    path: (0, import_trusted_roots.projectRelative)(projectPath, absPath),
+    hash,
+    symbolCount: 0
+  }));
+  return (0, import_diff_engine.captureSnapshot)(fileData, (0, import_database.getDependencyEdges)());
+}
+function checkpointSnapshot(id) {
+  const stored = (0, import_trellis_service.getSnapshot)(id);
+  if (!stored) return null;
+  const files = /* @__PURE__ */ new Map();
+  for (const f of stored.data.files) {
+    files.set(f.path, { hash: f.contentHash, symbolCount: f.symbolCount });
+  }
+  const edges = /* @__PURE__ */ new Set();
+  for (const e of stored.data.edges) edges.add(`${e.source}->${e.target}`);
+  return { timestamp: stored.createdAt, files, edges };
+}
+const PARSEABLE = new Set((0, import_ast_parser.getParseableExtensions)().map((e) => e.toLowerCase()));
+const blobMd5 = /* @__PURE__ */ new Map();
+const BLOB_MD5_CACHE_MAX = 5e4;
+function md5Blobs(projectPath, oids) {
+  const wanted = [...new Set(oids)].filter((o) => !blobMd5.has(o));
+  if (wanted.length === 0) return;
+  let buf;
+  try {
+    buf = (0, import_node_child_process.execFileSync)("git", ["cat-file", "--batch"], {
+      cwd: projectPath,
+      input: wanted.join("\n") + "\n",
+      maxBuffer: 256 * 1024 * 1024
+    });
+  } catch {
+    return;
+  }
+  let i = 0;
+  while (i < buf.length) {
+    const nl = buf.indexOf(10, i);
+    if (nl === -1) break;
+    const header = buf.subarray(i, nl).toString("utf-8");
+    i = nl + 1;
+    const parts = header.split(" ");
+    const size = parts.length >= 3 ? Number(parts[2]) : NaN;
+    if (!Number.isFinite(size)) continue;
+    if (blobMd5.size < BLOB_MD5_CACHE_MAX) {
+      blobMd5.set(parts[0], (0, import_node_crypto.createHash)("md5").update(buf.subarray(i, i + size)).digest("hex"));
+    }
+    i += size + 1;
+  }
+}
+function commitSnapshot(projectPath, ref) {
+  (0, import_git_safety.assertSafeGitRef)(ref, "snapshot comparand");
+  let out;
+  try {
+    out = (0, import_node_child_process.execFileSync)("git", ["ls-tree", "-r", ref], {
+      cwd: projectPath,
+      encoding: "utf-8",
+      maxBuffer: 32 * 1024 * 1024
+    });
+  } catch {
+    return null;
+  }
+  const entries = [];
+  for (const line of out.split("\n")) {
+    const tab = line.indexOf("	");
+    if (tab === -1) continue;
+    const meta = line.slice(0, tab).split(/\s+/);
+    const filePath = line.slice(tab + 1);
+    if (meta[1] !== "blob") continue;
+    if (!PARSEABLE.has(import_node_path.default.extname(filePath).toLowerCase())) continue;
+    entries.push({ filePath, oid: meta[2] });
+  }
+  if (entries.length === 0) return null;
+  md5Blobs(projectPath, entries.map((e) => e.oid));
+  const files = /* @__PURE__ */ new Map();
+  const oids = /* @__PURE__ */ new Map();
+  for (const { filePath, oid } of entries) {
+    const hash = blobMd5.get(oid);
+    if (hash) {
+      files.set(filePath, { hash, symbolCount: 0 });
+      oids.set(filePath, oid);
+    }
+  }
+  if (files.size === 0) return null;
+  return { snapshot: { timestamp: Date.now(), files, edges: /* @__PURE__ */ new Set() }, oids };
+}
+function readBlobs(projectPath, oids) {
+  const out = /* @__PURE__ */ new Map();
+  if (oids.length === 0) return out;
+  let buf;
+  try {
+    buf = (0, import_node_child_process.execFileSync)("git", ["cat-file", "--batch"], { cwd: projectPath, input: oids.join("\n") + "\n", maxBuffer: 256 * 1024 * 1024 });
+  } catch {
+    return out;
+  }
+  let i = 0;
+  while (i < buf.length) {
+    const nl = buf.indexOf(10, i);
+    if (nl === -1) break;
+    const parts = buf.subarray(i, nl).toString("utf-8").split(" ");
+    i = nl + 1;
+    const size = parts.length >= 3 ? Number(parts[2]) : NaN;
+    if (!Number.isFinite(size)) continue;
+    out.set(parts[0], buf.subarray(i, i + size).toString("utf-8"));
+    i += size + 1;
+  }
+  return out;
+}
+function edgeDeps(projectPath) {
+  const { aliasMap, systems } = (0, import_database.getImportResolutionContext)(projectPath);
+  return {
+    readBlobs: (oids) => readBlobs(projectPath, oids),
+    parseImports: (abs, content) => {
+      try {
+        const parsed = (0, import_ast_parser.parseVirtualFile)(abs, content);
+        return parsed ? { language: parsed.language, imports: parsed.imports } : null;
+      } catch {
+        return null;
+      }
+    },
+    resolve: (language, importSource, importerPath, knownFiles, isRelative) => (0, import_resolvers.getResolverForLanguage)(language)?.resolve({ importSource, importerPath, projectRoot: projectPath, knownFiles, aliasMap, systems, isRelative }) ?? null,
+    relative: (abs) => (0, import_trusted_roots.projectRelative)(projectPath, abs)
+  };
+}
+function fromGitObject(spec, label, object, projectPath) {
+  let commit;
+  try {
+    commit = commitSnapshot(projectPath, object);
+  } catch {
+    return null;
+  }
+  if (!commit) return null;
+  const { snapshot, oids } = commit;
+  const edges = (0, import_commit_edges.commitEdges)({ projectPath, files: snapshot.files, oids, live: liveSnapshot(projectPath) }, edgeDeps(projectPath));
+  if (!edges.ok) return { spec, label, snapshot, edgesKnown: false, edgesNote: edges.reason };
+  snapshot.edges = edges.edges;
+  return { spec, label, snapshot, edgesKnown: true };
+}
+function resolveComparand(spec, projectPath) {
+  if (spec === "live") {
+    return { spec, label: "Live", snapshot: liveSnapshot(projectPath), edgesKnown: true };
+  }
+  if (spec === "baseline") {
+    const baseline = (0, import_diff_engine.getBaseline)();
+    if (!baseline) return null;
+    const label = baseline.shortCommitHash ? `Baseline (${baseline.shortCommitHash})` : "Baseline";
+    return { spec, label, snapshot: baseline, edgesKnown: true };
+  }
+  if (spec.startsWith("checkpoint:")) {
+    const id = Number(spec.slice("checkpoint:".length));
+    if (!Number.isInteger(id)) return null;
+    const snapshot = checkpointSnapshot(id);
+    if (!snapshot) return null;
+    const meta = (0, import_trellis_service.listSnapshots)().find((s) => s.id === id);
+    return { spec, label: meta?.name ?? `Checkpoint ${id}`, snapshot, edgesKnown: true };
+  }
+  if (spec.startsWith("commit:")) {
+    const ref = spec.slice("commit:".length);
+    const label = ref.startsWith("refs/") ? (0, import_git_refs.sideLabel)(projectPath, spec, []) : `Commit ${ref}`;
+    return fromGitObject(spec, label, ref, projectPath);
+  }
+  if (spec.startsWith("merge-base:")) {
+    const mb = (0, import_git_refs.parseMergeBase)(spec);
+    const sha = mb ? (0, import_git_refs.mergeBase)(projectPath, mb.a, mb.b) : null;
+    if (!sha) return null;
+    return fromGitObject(spec, (0, import_git_refs.sideLabel)(projectPath, spec, []), sha, projectPath);
+  }
+  if (spec.startsWith("workstream:")) {
+    const workstreams = (0, import_git_refs.worktreesForCompare)(projectPath);
+    const tree = (0, import_git_refs.treeOf)(projectPath, spec, workstreams);
+    if (!tree) return null;
+    return fromGitObject(spec, (0, import_git_refs.sideLabel)(projectPath, spec, workstreams), tree, projectPath);
+  }
+  return null;
+}
+async function comparandBranches(projectPath) {
+  try {
+    return await (0, import_workstream_service.workstreamBranches)(projectPath);
+  } catch {
+    return [];
+  }
+}
+function listComparands(projectPath, commitLimit = 20, branches = []) {
+  const out = [
+    { spec: "live", label: "Live (working tree)", kind: "live" }
+  ];
+  if ((0, import_diff_engine.getBaseline)()) out.push({ spec: "baseline", label: "Baseline", kind: "baseline" });
+  for (const snap of (0, import_trellis_service.listSnapshots)()) {
+    out.push({
+      spec: `checkpoint:${snap.id}`,
+      label: snap.name,
+      kind: "checkpoint",
+      timestamp: snap.createdAt
+    });
+  }
+  for (const branch of branches) {
+    if (!(0, import_git_safety2.isSafeGitRef)(branch)) continue;
+    out.push({ spec: `commit:${branch}`, label: `${branch} (line of work)`, kind: "branch" });
+  }
+  try {
+    const n = Math.min(Math.max(Math.trunc(commitLimit) || 20, 1), 500);
+    const log = (0, import_node_child_process.execFileSync)("git", ["log", `-${n}`, "--format=%h	%s"], {
+      cwd: projectPath,
+      encoding: "utf-8"
+    });
+    for (const line of log.split("\n")) {
+      const [sha, subject] = line.split("	");
+      if (!sha) continue;
+      out.push({ spec: `commit:${sha}`, label: `${sha} ${subject ?? ""}`.trim(), kind: "commit" });
+    }
+  } catch {
+  }
+  return out;
+}
+function compareSnapshots(beforeSpec, afterSpec, projectPath) {
+  const before = resolveComparand(beforeSpec, projectPath);
+  if (!before) return { ok: false, error: `Could not resolve "${beforeSpec}"` };
+  const after = resolveComparand(afterSpec, projectPath);
+  if (!after) return { ok: false, error: `Could not resolve "${afterSpec}"` };
+  const diff = (0, import_diff_engine.diffSnapshots)(before.snapshot, after.snapshot);
+  const edgesComparable = before.edgesKnown && after.edgesKnown;
+  const notes = [];
+  let stillOnDisk = 0;
+  if (after.spec === "live") {
+    const gone = diff.removedFiles.filter((rel) => {
+      try {
+        return !import_node_fs.default.existsSync((0, import_confined_fs.resolveWithin)(projectPath, rel, "removal check"));
+      } catch {
+        return true;
+      }
+    });
+    stillOnDisk = diff.removedFiles.length - gone.length;
+    diff.removedFiles = gone;
+    diff.summary = { ...diff.summary, removed: gone.length };
+  }
+  if (stillOnDisk > 0) {
+    notes.push(
+      `${stillOnDisk} file(s) present at "${beforeSpec}" are still on disk but are not in the index \u2014 most often a parse error. They are not reported as removed, and no claim is made about whether their contents changed.`
+    );
+  }
+  if (!edgesComparable) {
+    const why = [before.edgesNote, after.edgesNote].filter(Boolean).join(" ");
+    notes.push(`Edges were not compared: ${why || "one side's edges are not known."} Compare against a checkpoint to include edges.`);
+  }
+  if (beforeSpec === afterSpec) {
+    notes.push("Both sides are the same point, so the diff is empty by construction.");
+  }
+  return {
+    ok: true,
+    result: {
+      before: {
+        spec: before.spec,
+        label: before.label,
+        fileCount: before.snapshot.files.size,
+        edgesKnown: before.edgesKnown
+      },
+      after: {
+        spec: after.spec,
+        label: after.label,
+        fileCount: after.snapshot.files.size,
+        edgesKnown: after.edgesKnown
+      },
+      // Edge fields are zeroed rather than left misleading when the
+      // comparison could not see edges.
+      diff: edgesComparable ? diff : {
+        ...diff,
+        addedEdges: [],
+        removedEdges: [],
+        blastRadius: [],
+        summary: { ...diff.summary, edgesAdded: 0, edgesRemoved: 0 }
+      },
+      edgesComparable,
+      notes
+    }
+  };
+}
+void import_database.getDb;
+function readFileAt(spec, projectPath, relativePath) {
+  if (spec === "live") {
+    try {
+      return { ok: true, content: (0, import_confined_fs.readTextWithin)(projectPath, relativePath, "file/at"), label: "Live" };
+    } catch (err) {
+      if (err instanceof import_confined_fs.ConfinementError) throw err;
+      return { ok: true, content: null, label: "Live" };
+    }
+  }
+  if (spec === "none") return { ok: true, content: null, label: "Nothing" };
+  if (spec === "index") {
+    try {
+      const content = (0, import_node_child_process.execFileSync)("git", ["show", `:./${relativePath}`], {
+        cwd: projectPath,
+        encoding: "utf-8",
+        maxBuffer: 16 * 1024 * 1024,
+        stdio: ["ignore", "pipe", "ignore"]
+      });
+      return { ok: true, content, label: "Staged" };
+    } catch {
+      return { ok: true, content: null, label: "Staged" };
+    }
+  }
+  if (spec.startsWith("commit:")) {
+    const ref = spec.slice("commit:".length);
+    (0, import_git_safety.assertSafeGitRef)(ref, "file comparand");
+    try {
+      const content = (0, import_node_child_process.execFileSync)("git", ["show", `${ref}:./${relativePath}`], {
+        cwd: projectPath,
+        encoding: "utf-8",
+        maxBuffer: 16 * 1024 * 1024
+      });
+      return { ok: true, content, label: `Commit ${ref}` };
+    } catch {
+      return { ok: true, content: null, label: `Commit ${ref}` };
+    }
+  }
+  if (spec.startsWith("merge-base:")) {
+    const mb = (0, import_git_refs.parseMergeBase)(spec);
+    const sha = mb ? (0, import_git_refs.mergeBase)(projectPath, mb.a, mb.b) : null;
+    if (!sha) return { ok: false, content: null, label: spec, unavailable: "These two share no history, or one of them is not here." };
+    const read = readFileAt(`commit:${sha}`, projectPath, relativePath);
+    return { ...read, label: (0, import_git_refs.sideLabel)(projectPath, spec, []) };
+  }
+  if (spec === "baseline" || spec.startsWith("checkpoint:")) {
+    return {
+      ok: false,
+      content: null,
+      label: spec === "baseline" ? "Baseline" : spec,
+      unavailable: "Snapshots store content hashes, not file contents, so this point can say which files changed but not how. Compare against a commit or the working tree to see a diff."
+    };
+  }
+  return { ok: false, content: null, label: spec, unavailable: `Unknown comparand "${spec}"` };
+}
+function canSupplyContent(spec) {
+  return spec === "live" || spec === "index" || spec === "none" || spec.startsWith("commit:") || spec.startsWith("merge-base:") || spec.startsWith("workstream:");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  canSupplyContent,
+  comparandBranches,
+  compareSnapshots,
+  listComparands,
+  readFileAt,
+  resolveComparand
+});