codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/source-control.js

@@ -0,0 +1,189 @@
+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 source_control_exports = {};
+__export(source_control_exports, {
+  parseNameStatus: () => parseNameStatus,
+  parsePorcelain: () => parsePorcelain,
+  projectPrefix: () => projectPrefix,
+  sourceControl: () => sourceControl
+});
+module.exports = __toCommonJS(source_control_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_fs = __toESM(require("node:fs"));
+var import_git_safety = require("./git-safety");
+var import_git_checkout = require("./git-checkout");
+const MAX_FILES = 500;
+const trim = (p) => p.replace(/[\\/]+$/, "");
+const real = (p) => {
+  try {
+    return import_node_fs.default.realpathSync.native(trim(p));
+  } catch {
+    return trim(p);
+  }
+};
+function git(cwd, args) {
+  return (0, import_node_child_process.execFileSync)("git", args, { cwd, encoding: "utf-8", maxBuffer: 32 * 1024 * 1024, stdio: ["ignore", "pipe", "ignore"] });
+}
+const STATUS = { A: "added", M: "modified", D: "deleted", R: "renamed", C: "added", T: "modified", U: "modified" };
+function parsePorcelain(out, prefix) {
+  const staged = [];
+  const changes = [];
+  const untracked = [];
+  const rel = (p) => prefix && p.startsWith(prefix) ? p.slice(prefix.length) : p;
+  const parts = out.split("\0");
+  for (let i = 0; i < parts.length; i++) {
+    const entry = parts[i];
+    if (entry.length < 4) continue;
+    const x = entry[0];
+    const y = entry[1];
+    const file = rel(entry.slice(3));
+    const from = x === "R" || x === "C" || y === "R" || y === "C" ? rel(parts[++i] ?? "") : void 0;
+    if (x === "?" && y === "?") {
+      untracked.push({ path: file, status: "untracked" });
+      continue;
+    }
+    if (x === "!") continue;
+    if (x !== " " && STATUS[x]) staged.push({ path: file, status: STATUS[x], ...x === "R" && from ? { from } : {} });
+    if (y !== " " && STATUS[y]) changes.push({ path: file, status: STATUS[y], ...y === "R" && from ? { from } : {} });
+  }
+  return { staged, changes, untracked };
+}
+function parseNameStatus(out, prefix) {
+  const rel = (p) => prefix && p.startsWith(prefix) ? p.slice(prefix.length) : p;
+  const parts = out.split("\0").filter((p) => p.length > 0);
+  const files = [];
+  for (let i = 0; i < parts.length; i++) {
+    const code = parts[i];
+    const kind = code[0];
+    if (kind === "R" || kind === "C") {
+      const from = parts[++i];
+      const to = parts[++i];
+      if (to) files.push(kind === "R" ? { path: rel(to), status: "renamed", from: rel(from) } : { path: rel(to), status: "added" });
+    } else {
+      const p = parts[++i];
+      if (p && STATUS[kind]) files.push({ path: rel(p), status: STATUS[kind] });
+    }
+  }
+  return files;
+}
+const count = (n, one, many = `${one}s`) => `${n} ${n === 1 ? one : many}`;
+function sourceControl(projectRoot, baselineCommit, workstreams) {
+  const project = trim(projectRoot);
+  let prefix = "";
+  try {
+    prefix = git(project, ["rev-parse", "--show-prefix"]).trim();
+  } catch {
+    return { project, git: false, branch: null, head: null, groups: [], words: "This folder is not a git repository, so there is nothing to compare it with." };
+  }
+  let head = null;
+  try {
+    const [sha, ...subject] = git(project, ["log", "-1", "--format=%h%x09%s"]).trim().split("	");
+    if (sha) head = { sha, subject: subject.join("	") };
+  } catch {
+  }
+  let branch = null;
+  try {
+    branch = git(project, ["symbolic-ref", "--short", "-q", "HEAD"]).trim() || null;
+  } catch {
+  }
+  const groups = [];
+  const headSpec = head ? "commit:HEAD" : "none";
+  const at = head ? `${branch ?? "HEAD"} ${head.sha}` : "no commit yet";
+  try {
+    const parsed = parsePorcelain(git(project, ["status", "--porcelain=v1", "-z", "--untracked-files=all", "--", "."]), prefix);
+    const { staged, changes } = parsed;
+    const untracked = (0, import_git_checkout.withoutNestedCheckouts)(project, parsed.untracked, (f) => f.path);
+    if (staged.length) groups.push({ id: "staged", kind: "staged", title: "Ready to commit", words: `Staged: these go into the next commit. Compared with the last commit (${at})`, git: { term: "staged", command: "git diff --cached" }, before: headSpec, after: "index", labels: { before: `Last commit (${head?.sha ?? "none"})`, after: "Staged" }, files: staged.slice(0, MAX_FILES), truncated: staged.length > MAX_FILES || void 0 });
+    if (changes.length) groups.push({ id: "changes", kind: "changes", title: "Changed, not staged", words: "Edited but not yet staged for a commit. Compared with what is staged", git: { term: "unstaged", command: "git diff" }, before: "index", after: "live", labels: { before: "Staged", after: "Working tree" }, files: changes.slice(0, MAX_FILES), truncated: changes.length > MAX_FILES || void 0 });
+    if (untracked.length) groups.push({ id: "untracked", kind: "untracked", title: "New files", words: "Files git is not tracking yet, so there is nothing earlier to compare them with", git: { term: "untracked", command: "git status --untracked-files" }, before: "none", after: "live", labels: { before: "Nothing (new file)", after: "Working tree" }, files: untracked.slice(0, MAX_FILES), truncated: untracked.length > MAX_FILES || void 0 });
+  } catch {
+  }
+  if (head && baselineCommit && (0, import_git_safety.isSafeGitRef)(baselineCommit)) {
+    try {
+      const commits = Number(git(project, ["rev-list", "--count", `${baselineCommit}..HEAD`]).trim()) || 0;
+      if (commits > 0) {
+        const files = parseNameStatus(git(project, ["diff", "--name-status", "-z", "-M", baselineCommit, "HEAD", "--", "."]), prefix);
+        const base = baselineCommit.slice(0, 7);
+        if (files.length) groups.push({ id: "since-opened", kind: "since-opened", title: "Committed since you opened it", words: `${count(commits, "commit")} since ${base}, when the graph's baseline was taken`, git: { term: null, command: `git diff ${base}..HEAD` }, before: `commit:${baselineCommit}`, after: "commit:HEAD", labels: { before: `When you opened it (${base})`, after: `Last commit (${head.sha})` }, files: files.slice(0, MAX_FILES), truncated: files.length > MAX_FILES || void 0 });
+      }
+    } catch {
+    }
+  }
+  const projectReal = real(project);
+  for (const w of workstreams) {
+    const wroot = w.root.startsWith("branch:") ? trim(w.root) : real(w.root);
+    if (wroot === projectReal || projectReal.startsWith(`${wroot}/`) || projectReal.startsWith(`${wroot}\\`)) continue;
+    const inside = w.changes.files.filter((f) => !prefix || f.path.startsWith(prefix)).map((f) => ({ ...f, path: f.path.slice(prefix.length), ...f.from ? { from: f.from.startsWith(prefix) ? f.from.slice(prefix.length) : f.from } : {} }));
+    if (inside.length === 0) continue;
+    const name = w.branch ?? w.root.split(/[\\/]/).pop() ?? w.root;
+    const base = w.changes.base;
+    const agents = [...new Set(w.agents.map((a) => a.agentType).filter((a) => !!a))];
+    const where = w.root.startsWith("branch:") ? "branch" : "worktree";
+    groups.push({
+      id: `workstream:${w.root}`,
+      kind: "workstream",
+      title: name,
+      words: `${where === "worktree" ? "A worktree" : "A branch"} with ${count(inside.length, "changed file")} since it left main${agents.length ? `, worked on by ${agents.join(" and ")}` : ""}`,
+      before: base && (0, import_git_safety.isSafeGitRef)(base) ? `commit:${base}` : "none",
+      after: `workstream:${w.root}`,
+      labels: { before: base ? `Where it left main (${base.slice(0, 7)})` : "Nothing", after: name },
+      git: {
+        term: where,
+        // A worktree's working copy, committed or not; a branch's own commits.
+        command: where === "worktree" ? `git -C ${w.root} diff ${base ? base.slice(0, 7) : "HEAD"}` : `git diff ${base ? base.slice(0, 7) : "main"}...${w.branch ?? name}`
+      },
+      files: inside.map((f) => ({ path: f.path, status: f.status, ...f.from ? { from: f.from } : {} })),
+      truncated: w.changes.truncated || void 0,
+      workstream: { id: w.root, branch: w.branch, agents }
+    });
+  }
+  const local = new Set(groups.filter((g) => g.kind === "staged" || g.kind === "changes" || g.kind === "untracked").flatMap((g) => g.files.map((f) => f.path))).size;
+  const since = groups.find((g) => g.kind === "since-opened");
+  const others = groups.filter((g) => g.kind === "workstream");
+  const said = [
+    local ? `${count(local, "file")} changed in this checkout` : null,
+    since ? `${count(since.files.length, "file")} committed since you opened it` : null,
+    others.length ? `work in ${count(others.length, "other worktree or branch", "other worktrees and branches")}` : null
+  ].filter(Boolean);
+  const words = said.length ? `${said.join("; ")}.` : `Nothing has changed: this checkout matches its last commit${head ? ` (${head.sha} \u201C${head.subject}\u201D)` : ""}, and no other worktree or branch has work in progress.`;
+  return { project, git: true, branch, head, groups, words };
+}
+function projectPrefix(projectRoot) {
+  try {
+    return git(trim(projectRoot), ["rev-parse", "--show-prefix"]).trim();
+  } catch {
+    return "";
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseNameStatus,
+  parsePorcelain,
+  projectPrefix,
+  sourceControl
+});

package/src/backend/services/spec-links-service.js

@@ -0,0 +1,123 @@
+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 spec_links_service_exports = {};
+__export(spec_links_service_exports, {
+  reliedOnBy: () => reliedOnBy,
+  reliedOnWords: () => reliedOnWords,
+  reliesOn: () => reliesOn,
+  setReliesOn: () => setReliesOn,
+  specRefProblem: () => specRefProblem
+});
+module.exports = __toCommonJS(spec_links_service_exports);
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_plan_item_service = require("./plan-item-service");
+var import_spec_sections = require("../../shared/lib/spec-sections");
+const rows = (sql, params = []) => (0, import_database.getDb)().exec(sql, params)[0]?.values ?? [];
+const planTitle = (planUid) => rows("SELECT title FROM plans WHERE uid = ?", [planUid])[0]?.[0] ?? "";
+const planProject = (planUid) => rows("SELECT project_path FROM plans WHERE uid = ?", [planUid])[0]?.[0] ?? null;
+function specRefProblem(itemUid, refs, lookup = import_plan_item_service.getItem) {
+  for (const ref of refs) {
+    const page = lookup(ref.page);
+    if (!page) return `No page ${ref.page}: a task can only rely on a page that exists.`;
+    if (page.kind !== "object") return `"${page.title}" is a task, not a page: a task relies on pages (dependencies are for tasks).`;
+    if (itemUid && page.uid === itemUid) return "An item cannot rely on itself.";
+    const section = ref.section ?? "";
+    if (section && !(0, import_spec_sections.findSection)(page.body ?? "", section)) {
+      return `"${page.title}" has no heading "${section}". Sections are addressed by their heading's slug, such as "fields" for "## Fields".`;
+    }
+  }
+  return null;
+}
+function setReliesOn(itemUid, refs, by) {
+  const db = (0, import_database.getDb)();
+  const now = Date.now();
+  db.run("DELETE FROM spec_links WHERE item_uid = ?", [itemUid]);
+  const seen = /* @__PURE__ */ new Set();
+  for (const ref of refs) {
+    const key = `${ref.page}\0${ref.section ?? ""}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    db.run(
+      "INSERT INTO spec_links (item_uid, page_uid, section, author, author_type, created_at) VALUES (?, ?, ?, ?, ?, ?)",
+      [itemUid, ref.page, ref.section ?? "", by.author, by.authorType, now]
+    );
+  }
+  (0, import_persistence.markDirty)();
+}
+function reliesOn(itemUid) {
+  return rows("SELECT page_uid, section FROM spec_links WHERE item_uid = ? ORDER BY created_at, page_uid, section", [itemUid]).flatMap((r) => {
+    const page = (0, import_plan_item_service.getItem)(r[0]);
+    if (!page) return [];
+    const section = r[1];
+    const heading = section ? (0, import_spec_sections.findSection)(page.body ?? "", section) : void 0;
+    return [{
+      pageUid: page.uid,
+      pageTitle: page.title,
+      planUid: page.planUid,
+      planTitle: planTitle(page.planUid),
+      section,
+      sectionTitle: heading?.title ?? null,
+      sectionMissing: !!section && !heading
+    }];
+  });
+}
+function reliedOnBy(pageUid, section) {
+  const page = (0, import_plan_item_service.getItem)(pageUid);
+  if (!page) return [];
+  const project = planProject(page.planUid);
+  const params = [pageUid];
+  let where = "l.page_uid = ?";
+  if (section) {
+    where += " AND (l.section = '' OR l.section = ?)";
+    params.push(section);
+  }
+  if (project) {
+    where += " AND p.project_path = ?";
+    params.push(project);
+  }
+  return rows(
+    `SELECT i.uid, i.title, i.status, i.assignee, i.plan_uid, p.title, l.section
+     FROM spec_links l JOIN plan_items i ON i.uid = l.item_uid JOIN plans p ON p.uid = i.plan_uid
+     WHERE ${where} ORDER BY p.title, i.sort_order, i.title`,
+    params
+  ).map((r) => ({
+    itemUid: r[0],
+    title: r[1],
+    status: r[2] ?? null,
+    assignee: r[3] ?? null,
+    planUid: r[4],
+    planTitle: r[5],
+    section: r[6],
+    sectionTitle: r[6] ? (0, import_spec_sections.findSection)(page.body ?? "", r[6])?.title ?? null : null
+  }));
+}
+function reliedOnWords(rel) {
+  if (rel.length === 0) return null;
+  const tasks = new Set(rel.map((r) => r.itemUid)).size;
+  const plans = new Set(rel.map((r) => r.planUid)).size;
+  return `Relied on by ${tasks} ${tasks === 1 ? "task" : "tasks"} in ${plans} ${plans === 1 ? "plan" : "plans"}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  reliedOnBy,
+  reliedOnWords,
+  reliesOn,
+  setReliesOn,
+  specRefProblem
+});

package/src/backend/services/spec-proposal-withdraw.js

@@ -0,0 +1,50 @@
+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 spec_proposal_withdraw_exports = {};
+__export(spec_proposal_withdraw_exports, {
+  withdrawProposals: () => withdrawProposals
+});
+module.exports = __toCommonJS(spec_proposal_withdraw_exports);
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+function withdrawProposals(scope, reason, now = Date.now()) {
+  const where = scope.planUid ? { sql: "plan_uid = ?", params: [scope.planUid] } : scope.pageUids?.length ? { sql: `page_uid IN (${scope.pageUids.map(() => "?").join(",")})`, params: scope.pageUids } : null;
+  if (!where) return 0;
+  const db = (0, import_database.getDb)();
+  const open = db.exec(`SELECT uid, hit_ref FROM spec_proposals WHERE status = 'open' AND ${where.sql}`, where.params)[0]?.values ?? [];
+  for (const [uid, ref] of open) {
+    db.run(
+      `UPDATE spec_proposals SET status = 'withdrawn', decided_at = ?, decided_by = 'CodeTrellis', decided_by_type = 'system', decision_note = ? WHERE uid = ?`,
+      [now, reason, uid]
+    );
+    if (ref) {
+      db.run(
+        `UPDATE breakpoint_hits SET decision = 'stop', note = ?, answered_at = ?, answered_by = 'CodeTrellis', answered_by_type = 'system'
+          WHERE ref = ? AND answered_at IS NULL`,
+        [reason, now, ref]
+      );
+    }
+    db.run(`UPDATE breakpoints SET cleared_at = ?, cleared_by = 'CodeTrellis', cleared_by_type = 'system' WHERE kind = 'proposal' AND target = ? AND cleared_at IS NULL`, [now, uid]);
+  }
+  if (open.length) (0, import_persistence.markDirty)();
+  return open.length;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  withdrawProposals
+});