codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/sql/tokenizer.js

@@ -0,0 +1,195 @@
+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 tokenizer_exports = {};
+__export(tokenizer_exports, {
+  isNameToken: () => isNameToken,
+  isWord: () => isWord,
+  tokenize: () => tokenize
+});
+module.exports = __toCommonJS(tokenizer_exports);
+const QUOTE_PAIRS = {
+  '"': '"',
+  "`": "`",
+  "[": "]"
+};
+function isWordStart(ch) {
+  return /[A-Za-z_#]/.test(ch);
+}
+function isWordChar(ch) {
+  return /[A-Za-z0-9_$#]/.test(ch);
+}
+function tokenize(sql) {
+  const tokens = [];
+  const len = sql.length;
+  let i = 0;
+  let line = 1;
+  const push = (type, value, start) => {
+    tokens.push({ type, value, start, line });
+  };
+  while (i < len) {
+    const ch = sql[i];
+    if (ch === "\n") {
+      line++;
+      i++;
+      continue;
+    }
+    if (ch === " " || ch === "	" || ch === "\r") {
+      i++;
+      continue;
+    }
+    if (ch === "-" && sql[i + 1] === "-" || ch === "#") {
+      while (i < len && sql[i] !== "\n") i++;
+      continue;
+    }
+    if (ch === "/" && sql[i + 1] === "*") {
+      i += 2;
+      while (i < len && !(sql[i] === "*" && sql[i + 1] === "/")) {
+        if (sql[i] === "\n") line++;
+        i++;
+      }
+      i += 2;
+      continue;
+    }
+    if (ch === "$") {
+      const tagMatch = /^\$([A-Za-z_]\w*)?\$/.exec(sql.slice(i));
+      if (tagMatch) {
+        const tag = tagMatch[0];
+        const start = i;
+        const end = sql.indexOf(tag, i + tag.length);
+        const bodyEnd = end === -1 ? len : end;
+        const body = sql.slice(i + tag.length, bodyEnd);
+        line += (body.match(/\n/g) || []).length;
+        push("string", body, start);
+        i = end === -1 ? len : end + tag.length;
+        continue;
+      }
+    }
+    if (ch === "'") {
+      const start = i;
+      i++;
+      let body = "";
+      while (i < len) {
+        if (sql[i] === "\\" && i + 1 < len) {
+          body += sql[i + 1];
+          i += 2;
+          continue;
+        }
+        if (sql[i] === "'") {
+          if (sql[i + 1] === "'") {
+            body += "'";
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        if (sql[i] === "\n") line++;
+        body += sql[i];
+        i++;
+      }
+      push("string", body, start);
+      continue;
+    }
+    if (QUOTE_PAIRS[ch]) {
+      const closer = QUOTE_PAIRS[ch];
+      const start = i;
+      i++;
+      let body = "";
+      while (i < len) {
+        if (sql[i] === closer) {
+          if (sql[i + 1] === closer) {
+            body += closer;
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        if (sql[i] === "\n") line++;
+        body += sql[i];
+        i++;
+      }
+      push("quoted", body, start);
+      continue;
+    }
+    if ((ch === "$" || ch === "#") && sql[i + 1] === "{") {
+      const start = i;
+      const close = sql.indexOf("}", i + 2);
+      i = close === -1 ? len : close + 1;
+      push("param", sql.slice(start, i), start);
+      continue;
+    }
+    if (ch === "%") {
+      const m = /^%(\([^)]*\))?[sdfrv]/.exec(sql.slice(i));
+      if (m) {
+        push("param", m[0], i);
+        i += m[0].length;
+        continue;
+      }
+    }
+    if (ch === "?") {
+      const m = /^\?\d*/.exec(sql.slice(i));
+      push("param", m[0], i);
+      i += m[0].length;
+      continue;
+    }
+    if (ch === "$" && /\d/.test(sql[i + 1] ?? "")) {
+      const m = /^\$\d+/.exec(sql.slice(i));
+      push("param", m[0], i);
+      i += m[0].length;
+      continue;
+    }
+    if ((ch === ":" || ch === "@") && isWordStart(sql[i + 1] ?? "")) {
+      const m = new RegExp(`^\\${ch}\\w+`).exec(sql.slice(i));
+      if (m) {
+        push("param", m[0], i);
+        i += m[0].length;
+        continue;
+      }
+    }
+    if (/\d/.test(ch)) {
+      const m = /^\d+(\.\d+)?/.exec(sql.slice(i));
+      push("number", m[0], i);
+      i += m[0].length;
+      continue;
+    }
+    if (isWordStart(ch)) {
+      const start = i;
+      while (i < len && isWordChar(sql[i])) i++;
+      push("word", sql.slice(start, i), start);
+      continue;
+    }
+    push("punct", ch, i);
+    i++;
+  }
+  return tokens;
+}
+function isWord(token, ...words) {
+  if (!token || token.type !== "word") return false;
+  const v = token.value.toUpperCase();
+  return words.some((w) => w.toUpperCase() === v);
+}
+function isNameToken(token) {
+  return !!token && (token.type === "word" || token.type === "quoted");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isNameToken,
+  isWord,
+  tokenize
+});

package/src/backend/services/stack-overlaps.js

@@ -0,0 +1,117 @@
+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 stack_overlaps_exports = {};
+__export(stack_overlaps_exports, {
+  declaredFootprint: () => declaredFootprint,
+  stackOverlaps: () => stackOverlaps
+});
+module.exports = __toCommonJS(stack_overlaps_exports);
+var import_plan_dependencies = require("./plan-dependencies");
+function declaredFootprint(items) {
+  const files = /* @__PURE__ */ new Set();
+  const symbols = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    if (item.kind !== "action" || (0, import_plan_dependencies.isSettled)(item)) continue;
+    for (const f of item.fileSpecs ?? []) {
+      if (f.isDir) continue;
+      if (f.path) files.add(f.path);
+      if (f.moveTo) files.add(f.moveTo);
+    }
+    for (const s of item.symbolSpecs ?? []) {
+      if (!s.name) continue;
+      symbols.set(s.filePath ? `${s.filePath}#${s.name}` : s.name, s.name);
+      if (s.filePath) files.add(s.filePath);
+    }
+  }
+  return { files, symbols };
+}
+const OPEN = /* @__PURE__ */ new Set(["open", "acknowledged", "intended"]);
+function meets(s) {
+  if (s.kind === "collision" || s.kind === "contract") return true;
+  return (s.kind === "version-split" || s.kind === "stale-base") && !!s.subject?.material;
+}
+const baseName = (p) => p.split(/[\\/]/).pop() || p;
+function list(names) {
+  const shown = names.slice(0, 3);
+  const more = names.length - shown.length;
+  if (more > 0) return `${shown.join(", ")} and ${more} more`;
+  if (shown.length <= 1) return shown.join("");
+  return `${shown.slice(0, -1).join(", ")} and ${shown[shown.length - 1]}`;
+}
+function stackOverlaps(plans, signals, canon = (r) => r, when = "now") {
+  const pairKey = (a, b) => a < b ? `${a}\0${b}` : `${b}\0${a}`;
+  const actual = /* @__PURE__ */ new Map();
+  const plansAt = (root) => plans.filter((p) => p.roots.some((r) => canon(r) === canon(root)));
+  for (const s of signals) {
+    if (!meets(s) || !OPEN.has(s.state)) continue;
+    const seen = /* @__PURE__ */ new Set();
+    for (let i = 0; i < s.workstreams.length; i++) {
+      for (let j = i + 1; j < s.workstreams.length; j++) {
+        for (const a of plansAt(s.workstreams[i])) {
+          for (const b of plansAt(s.workstreams[j])) {
+            if (a.uid === b.uid) continue;
+            const key = pairKey(a.uid, b.uid);
+            if (seen.has(key)) continue;
+            seen.add(key);
+            const at = actual.get(key) ?? [];
+            at.push({ id: s.id, kind: s.kind, severity: s.severity, summary: s.summary });
+            actual.set(key, at);
+          }
+        }
+      }
+    }
+  }
+  const out = new Map(plans.map((p) => [p.uid, []]));
+  for (let i = 0; i < plans.length; i++) {
+    for (let j = i + 1; j < plans.length; j++) {
+      const a = plans[i];
+      const b = plans[j];
+      const files = [...a.files].filter((f) => b.files.has(f)).sort();
+      const symbols = [...a.symbols.keys()].filter((k) => b.symbols.has(k)).map((k) => a.symbols.get(k)).sort();
+      const materials = [...a.materials ?? []].filter((m) => b.materials?.has(m)).sort();
+      const signalsBetween = actual.get(pairKey(a.uid, b.uid)) ?? [];
+      if (files.length === 0 && symbols.length === 0 && materials.length === 0 && signalsBetween.length === 0) continue;
+      const parts = [];
+      if (symbols.length || files.length) parts.push(`Both plan to change ${list([...symbols, ...files])}.`);
+      if (materials.length) parts.push(`Both rely on ${list(materials.map(baseName))}.`);
+      if (signalsBetween.length) parts.push(`Open ${when}: ${signalsBetween.map((s) => s.summary).join("; ")}`);
+      const detail = parts.join(" ");
+      const high = signalsBetween.some((s) => s.severity === "high");
+      for (const [me, other] of [[a, b], [b, a]]) {
+        out.get(me.uid).push({
+          withPlanUid: other.uid,
+          withLabel: other.label,
+          declared: { files, symbols, materials },
+          actual: signalsBetween,
+          high,
+          words: `\u26A0 overlaps ${other.label}`,
+          detail
+        });
+      }
+    }
+  }
+  for (const each of out.values()) {
+    each.sort((x, y) => Number(y.high) - Number(x.high) || x.withLabel.localeCompare(y.withLabel));
+  }
+  return out;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  declaredFootprint,
+  stackOverlaps
+});

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

@@ -0,0 +1,225 @@
+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 stack_service_exports = {};
+__export(stack_service_exports, {
+  buildStack: () => buildStack,
+  readWords: () => readWords,
+  stackPlanOf: () => stackPlanOf,
+  stackThen: () => stackThen
+});
+module.exports = __toCommonJS(stack_service_exports);
+var import_plan_service = require("./plan-service");
+var import_plan_item_service = require("./plan-item-service");
+var import_plan_dependencies = require("./plan-dependencies");
+var import_section_workstreams = require("./section-workstreams");
+var import_external_intake_service = require("./external-intake-service");
+var import_plan_arrivals = require("./plan-arrivals");
+var import_external_refs_service = require("./external-refs-service");
+var import_breakpoint_service = require("./breakpoint-service");
+var import_worktree_service = require("./worktree-service");
+var import_awareness_service = require("./awareness-service");
+var import_stack_overlaps = require("./stack-overlaps");
+var import_database = require("./database");
+var import_plan_dependencies2 = require("./plan-dependencies");
+var import_task_workstreams = require("./task-workstreams");
+var import_node_fs = __toESM(require("node:fs"));
+const DONE = /* @__PURE__ */ new Set(["completed", "archived"]);
+const DAY_MONTH = new Intl.DateTimeFormat("en-GB", { day: "numeric", month: "short", timeZone: "UTC" });
+function readWords(path, sha256, at) {
+  const name = path.split(/[\\/]/).pop() || path;
+  return `read ${name} on ${DAY_MONTH.format(new Date(at))}${sha256 ? ` (version ${sha256.slice(0, 7)})` : ""}`;
+}
+function readsFromDb(itemUid, before) {
+  const res = (0, import_database.getDb)().exec(
+    `SELECT path, sha256, at FROM material_reads WHERE item_uid = ?${before !== void 0 ? " AND at <= ?" : ""} ORDER BY at, rowid`,
+    before !== void 0 ? [itemUid, before] : [itemUid]
+  );
+  const latest = /* @__PURE__ */ new Map();
+  for (const [path, sha, at] of res[0]?.values ?? []) {
+    const p = String(path);
+    latest.delete(p);
+    latest.set(p, { path: p, sha256: sha ?? null, at: Number(at), words: readWords(p, sha ?? null, Number(at)) });
+  }
+  return [...latest.values()];
+}
+function materialsFromDb(itemUids, before) {
+  if (!itemUids.length) return [];
+  const marks = itemUids.map(() => "?").join(",");
+  const res = (0, import_database.getDb)().exec(
+    `SELECT DISTINCT value FROM attachments WHERE role = 'material' AND target_uid IN (${marks})${before !== void 0 ? " AND created_at <= ?" : ""}`,
+    before !== void 0 ? [...itemUids, before] : [...itemUids]
+  );
+  return (res[0]?.values ?? []).map((r) => String(r[0]));
+}
+function filesOf(item) {
+  const files = /* @__PURE__ */ new Set();
+  for (const f of item.fileSpecs ?? []) {
+    if (f.isDir) continue;
+    if (f.path) files.add(f.path);
+    if (f.moveTo) files.add(f.moveTo);
+  }
+  for (const s of item.symbolSpecs ?? []) if (s.filePath) files.add(s.filePath);
+  return [...files];
+}
+function stackPlanOf(plan, items, sources2) {
+  const local = new Map(items.map((i) => [i.uid, i]));
+  const within = (uid) => local.get(uid) ?? sources2.getItem(uid);
+  const actions = items.filter((i) => i.kind === "action");
+  const ticketKey = sources2.planTicketKey(plan.uid);
+  const tasks = items.map((item) => {
+    const state = item.kind === "action" ? (0, import_plan_dependencies.dependencyState)(item, sources2, local) : { met: true, waits: [] };
+    const unmet = new Map(state.waits.map((w) => [w.uid, w]));
+    const dependencies = (item.dependencies ?? []).map((uid) => {
+      const wait = unmet.get(uid);
+      if (wait) {
+        return { uid, met: false, problem: wait.problem, title: wait.title, planUid: wait.planUid, planTitle: wait.planTitle, words: wait.words };
+      }
+      const dep = within(uid);
+      const elsewhere = dep && dep.planUid !== plan.uid;
+      return {
+        uid,
+        met: true,
+        problem: null,
+        title: dep?.title ?? null,
+        planUid: dep?.planUid ?? null,
+        planTitle: elsewhere ? sources2.planTitle(dep.planUid) : null,
+        words: null
+      };
+    });
+    return {
+      uid: item.uid,
+      parentUid: item.parentUid ?? null,
+      kind: item.kind,
+      title: item.title,
+      status: item.kind === "action" ? item.status ?? "pending" : null,
+      assignee: item.assignee ?? null,
+      assigneeType: item.assigneeType ?? null,
+      assigneeSession: item.assigneeSession ?? null,
+      workstream: (0, import_section_workstreams.resolveSection)(item, within)?.branch ?? null,
+      ticketKey: sources2.itemTicketKey(item.uid),
+      files: filesOf(item),
+      dependencies,
+      waits: state.met ? null : (0, import_plan_dependencies.waitSentence)(item.title, state),
+      reads: item.kind === "action" ? sources2.readsOf?.(item.uid) ?? [] : []
+    };
+  });
+  return {
+    uid: plan.uid,
+    title: plan.title,
+    status: plan.status,
+    ticketKey,
+    label: ticketKey ?? plan.title,
+    progress: { done: actions.filter((a) => a.status === "done").length, total: actions.length },
+    needsYou: sources2.waitingHits(plan.uid),
+    tasks,
+    overlaps: [],
+    arrival: sources2.arrivalOf?.(plan.uid) ?? null
+  };
+}
+const sources = {
+  getItem: (uid) => import_plan_item_service.dependencyLookup.getItem(uid),
+  planTitle: (planUid) => import_plan_item_service.dependencyLookup.planTitle(planUid),
+  planTicketKey: (planUid) => (0, import_external_intake_service.getPlanExternalRefs)(planUid).find((r) => r.externalKey)?.externalKey ?? null,
+  itemTicketKey: (itemUid) => (0, import_external_refs_service.getExternalRefs)(itemUid).find((r) => r.externalKey)?.externalKey ?? null,
+  waitingHits: (planUid) => (0, import_breakpoint_service.listHits)({ state: "waiting", planUid }).length,
+  readsOf: (itemUid) => readsFromDb(itemUid),
+  materialsOn: (itemUids) => materialsFromDb(itemUids),
+  arrivalOf: (planUid) => {
+    const a = (0, import_plan_arrivals.getPlanArrival)(planUid);
+    return a ? (0, import_plan_arrivals.arrivalWords)(a) : null;
+  }
+};
+const canon = (p) => {
+  if (p.startsWith("branch:") || p.startsWith(import_task_workstreams.TASK_PREFIX)) return p;
+  try {
+    return import_node_fs.default.realpathSync.native(p);
+  } catch {
+    return p;
+  }
+};
+function branchRoots(projectPath) {
+  let worktrees = [];
+  try {
+    worktrees = (0, import_worktree_service.listWorktrees)(projectPath);
+  } catch {
+  }
+  return (branch) => worktrees.find((w) => w.branch === branch)?.path ?? `branch:${branch}`;
+}
+function assemble(projectPath, plans, itemsOf, from, signals, when) {
+  const rootOf = branchRoots(projectPath);
+  const rows = [];
+  const footprints = [];
+  for (const plan of plans) {
+    const items = itemsOf(plan.uid);
+    const row = stackPlanOf(plan, items, from);
+    rows.push(row);
+    const branches = [...new Set(row.tasks.map((t) => t.workstream).filter((b) => !!b))];
+    const tasks = items.filter((i) => i.kind === "action").map((i) => (0, import_task_workstreams.taskWorkstreamId)(i.uid));
+    const briefItems = items.filter((i) => i.kind === "object" || i.kind === "action" && !(0, import_plan_dependencies2.isSettled)(i)).map((i) => i.uid);
+    const hasOpenTask = items.some((i) => i.kind === "action" && !(0, import_plan_dependencies2.isSettled)(i));
+    const materials = new Set(hasOpenTask ? from.materialsOn?.(briefItems) ?? [] : []);
+    footprints.push({ uid: row.uid, label: row.label, ...(0, import_stack_overlaps.declaredFootprint)(items), roots: [...branches.map(rootOf), ...tasks], materials });
+  }
+  const overlaps = (0, import_stack_overlaps.stackOverlaps)(footprints, signals, canon, when);
+  for (const row of rows) row.overlaps = overlaps.get(row.uid) ?? [];
+  return { project: projectPath, plans: rows };
+}
+function buildStack(projectPath) {
+  const plans = (0, import_plan_service.listPlans)(projectPath).filter((p) => !DONE.has(p.status));
+  let signals = [];
+  try {
+    signals = (0, import_awareness_service.loadSignals)(projectPath);
+  } catch {
+  }
+  return assemble(projectPath, plans, import_plan_item_service.listAllItems, sources, signals, "now");
+}
+function stackThen(projectPath, plans, signalsThen, waitingThen, at) {
+  const byUid = /* @__PURE__ */ new Map();
+  for (const p of plans) for (const i of p.items) byUid.set(i.uid, i);
+  const titles = new Map(plans.map((p) => [p.plan.uid, p.plan.title]));
+  const itemsOf = new Map(plans.map((p) => [p.plan.uid, p.items]));
+  const then = {
+    // A task made later did not exist then, so a dependency on it reads as missing.
+    getItem: (uid) => byUid.get(uid) ?? null,
+    planTitle: (planUid) => titles.get(planUid) ?? null,
+    planTicketKey: sources.planTicketKey,
+    itemTicketKey: sources.itemTicketKey,
+    waitingHits: (planUid) => waitingThen.filter((h) => h.planUid === planUid).length,
+    readsOf: (itemUid) => readsFromDb(itemUid, at),
+    materialsOn: (itemUids) => materialsFromDb(itemUids, at),
+    arrivalOf: sources.arrivalOf
+  };
+  return assemble(projectPath, plans.map((p) => p.plan), (uid) => itemsOf.get(uid) ?? [], then, signalsThen, "then");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildStack,
+  readWords,
+  stackPlanOf,
+  stackThen
+});