codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/channel-event-service.js

@@ -0,0 +1,297 @@
+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 channel_event_service_exports = {};
+__export(channel_event_service_exports, {
+  _recordSeqForTests: () => _recordSeqForTests,
+  _resetSeqForTests: () => _resetSeqForTests,
+  eventToManifest: () => eventToManifest,
+  getChannelEvent: () => getChannelEvent,
+  getChannelEventsSinceSeq: () => getChannelEventsSinceSeq,
+  getCurrentSeqHead: () => getCurrentSeqHead,
+  listChannelEvents: () => listChannelEvents,
+  listThread: () => listThread,
+  manifestToEventInput: () => manifestToEventInput,
+  postChannelEvent: () => postChannelEvent,
+  setChannelEventStatus: () => setChannelEventStatus
+});
+module.exports = __toCommonJS(channel_event_service_exports);
+var import_node_crypto = require("node:crypto");
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_types = require("../../shared/types");
+const PER_PLAN_RING_SIZE = 500;
+let nextSeq = 1;
+const seqRings = /* @__PURE__ */ new Map();
+const firstSeqByPlan = /* @__PURE__ */ new Map();
+function recordSeq(event) {
+  const seq = nextSeq++;
+  let ring = seqRings.get(event.planUid);
+  if (!ring) {
+    ring = [];
+    seqRings.set(event.planUid, ring);
+    firstSeqByPlan.set(event.planUid, seq);
+  }
+  ring.push({ seq, event });
+  if (ring.length > PER_PLAN_RING_SIZE) ring.shift();
+  return seq;
+}
+function getChannelEventsSinceSeq(planUid, sinceSeq, limit = 200) {
+  const ring = seqRings.get(planUid) ?? [];
+  const firstSeq = firstSeqByPlan.get(planUid) ?? null;
+  const latestSeq = ring.length > 0 ? ring[ring.length - 1].seq : firstSeq === null ? nextSeq - 1 : firstSeq - 1;
+  if (ring.length === 0) {
+    return { events: [], latestSeq, gap: false };
+  }
+  const oldestRingSeq = ring[0].seq;
+  const evicted = firstSeq !== null && oldestRingSeq > firstSeq;
+  if (evicted && sinceSeq < oldestRingSeq - 1) {
+    return { events: [], latestSeq, gap: true };
+  }
+  const newer = ring.filter((r) => r.seq > sinceSeq).slice(0, limit);
+  return { events: newer.map((r) => r.event), latestSeq, gap: false };
+}
+function getCurrentSeqHead() {
+  return nextSeq - 1;
+}
+function _recordSeqForTests(event) {
+  return recordSeq(event);
+}
+function _resetSeqForTests() {
+  nextSeq = 1;
+  seqRings.clear();
+  firstSeqByPlan.clear();
+}
+function postChannelEvent(input) {
+  if (!import_types.CHANNEL_EVENT_TYPES.includes(input.eventType)) {
+    throw new Error(`Unknown channel event type: ${input.eventType}`);
+  }
+  if (input.status && !import_types.CHANNEL_EVENT_STATUSES.includes(input.status)) {
+    throw new Error(`Unknown channel event status: ${input.status}`);
+  }
+  if (!input.payload || typeof input.payload.message !== "string" || !input.payload.message.trim()) {
+    throw new Error("Channel event payload must include a non-empty `message`.");
+  }
+  if (input.respondsTo) {
+    const parent = getChannelEvent(input.respondsTo);
+    if (!parent) {
+      throw new Error(`Cannot respond to unknown channel event: ${input.respondsTo}`);
+    }
+    if (parent.planUid !== input.planUid) {
+      throw new Error("Cannot thread across plans (`respondsTo` is on a different plan).");
+    }
+  }
+  const db = (0, import_database.getDb)();
+  const now = input.createdAt ?? Date.now();
+  const uid = input.uid ?? (0, import_node_crypto.randomUUID)();
+  const status = input.status ?? "open";
+  db.run(
+    `INSERT INTO channel_events
+       (uid, plan_uid, item_uid, event_type, payload, author, author_type, agent_model, responds_to, status, created_at, updated_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+     ON CONFLICT(uid) DO UPDATE SET
+       payload = excluded.payload,
+       status = excluded.status,
+       updated_at = excluded.updated_at`,
+    [
+      uid,
+      input.planUid,
+      input.itemUid ?? null,
+      input.eventType,
+      JSON.stringify(input.payload),
+      input.author,
+      input.authorType,
+      input.agentModel ?? null,
+      input.respondsTo ?? null,
+      status,
+      now,
+      input.updatedAt ?? now
+    ]
+  );
+  (0, import_persistence.markDirty)();
+  const created = getChannelEvent(uid);
+  if (!created) throw new Error("Channel event vanished immediately after insert");
+  recordSeq(created);
+  return created;
+}
+function getChannelEvent(uid) {
+  const db = (0, import_database.getDb)();
+  const result = db.exec(
+    `SELECT uid, plan_uid, item_uid, event_type, payload, author, author_type, agent_model, responds_to, status, created_at, updated_at
+       FROM channel_events
+      WHERE uid = ?`,
+    [uid]
+  );
+  if (!result[0] || result[0].values.length === 0) return null;
+  return rowToEvent(result[0].values[0]);
+}
+function listChannelEvents(planUid, options = {}) {
+  const db = (0, import_database.getDb)();
+  const params = [planUid];
+  let where = `plan_uid = ?`;
+  if (options.sinceMs !== void 0) {
+    where += ` AND created_at >= ?`;
+    params.push(options.sinceMs);
+  }
+  if (options.itemUid) {
+    where += ` AND item_uid = ?`;
+    params.push(options.itemUid);
+  }
+  if (options.eventTypes && options.eventTypes.length > 0) {
+    where += ` AND event_type IN (${options.eventTypes.map(() => "?").join(", ")})`;
+    for (const t of options.eventTypes) params.push(t);
+  }
+  if (options.status) {
+    const statuses = Array.isArray(options.status) ? options.status : [options.status];
+    if (statuses.length > 0) {
+      where += ` AND status IN (${statuses.map(() => "?").join(", ")})`;
+      for (const s of statuses) params.push(s);
+    }
+  }
+  const limit = options.limit ?? 200;
+  const offset = options.offset ?? 0;
+  params.push(limit, offset);
+  const result = db.exec(
+    `SELECT uid, plan_uid, item_uid, event_type, payload, author, author_type, agent_model, responds_to, status, created_at, updated_at
+       FROM channel_events
+      WHERE ${where}
+      ORDER BY created_at DESC
+      LIMIT ? OFFSET ?`,
+    params
+  );
+  if (!result[0]) return [];
+  return result[0].values.map(rowToEvent);
+}
+function listThread(rootUid) {
+  const db = (0, import_database.getDb)();
+  const collected = [];
+  const queue = [rootUid];
+  const seen = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const uid = queue.shift();
+    if (seen.has(uid)) continue;
+    seen.add(uid);
+    const ev = getChannelEvent(uid);
+    if (ev) collected.push(ev);
+    const childRes = db.exec(
+      `SELECT uid FROM channel_events WHERE responds_to = ? ORDER BY created_at ASC`,
+      [uid]
+    );
+    if (childRes[0]) {
+      for (const row of childRes[0].values) {
+        queue.push(row[0]);
+      }
+    }
+  }
+  return collected.sort((a, b) => a.createdAt - b.createdAt);
+}
+function setChannelEventStatus(uid, status) {
+  if (!import_types.CHANNEL_EVENT_STATUSES.includes(status)) {
+    throw new Error(`Unknown channel event status: ${status}`);
+  }
+  const db = (0, import_database.getDb)();
+  const now = Date.now();
+  db.run(
+    `UPDATE channel_events SET status = ?, updated_at = ? WHERE uid = ?`,
+    [status, now, uid]
+  );
+  (0, import_persistence.markDirty)();
+  const updated = getChannelEvent(uid);
+  if (!updated) throw new Error(`Channel event not found: ${uid}`);
+  return updated;
+}
+function eventToManifest(event) {
+  return {
+    uid: event.uid,
+    itemUid: event.itemUid,
+    eventType: event.eventType,
+    payload: event.payload,
+    author: event.author,
+    authorType: event.authorType,
+    agentModel: event.agentModel,
+    respondsTo: event.respondsTo,
+    status: event.status,
+    createdAt: new Date(event.createdAt).toISOString(),
+    updatedAt: new Date(event.updatedAt).toISOString()
+  };
+}
+function manifestToEventInput(planUid, record) {
+  return {
+    uid: record.uid,
+    planUid,
+    itemUid: record.itemUid,
+    eventType: record.eventType,
+    payload: record.payload,
+    author: record.author,
+    authorType: record.authorType,
+    agentModel: record.agentModel,
+    respondsTo: record.respondsTo,
+    status: record.status,
+    createdAt: Date.parse(record.createdAt) || Date.now(),
+    updatedAt: Date.parse(record.updatedAt) || Date.now()
+  };
+}
+function rowToEvent(row) {
+  const [
+    uid,
+    planUid,
+    itemUid,
+    eventType,
+    payloadJson,
+    author,
+    authorType,
+    agentModel,
+    respondsTo,
+    status,
+    createdAt,
+    updatedAt
+  ] = row;
+  let payload = { message: "" };
+  try {
+    payload = JSON.parse(payloadJson) ?? { message: "" };
+  } catch {
+    payload = { message: "[unparseable payload]" };
+  }
+  return {
+    uid: String(uid),
+    planUid: String(planUid),
+    itemUid: itemUid ? String(itemUid) : null,
+    eventType: String(eventType),
+    payload,
+    author: String(author),
+    authorType: String(authorType),
+    agentModel: agentModel ? String(agentModel) : null,
+    respondsTo: respondsTo ? String(respondsTo) : null,
+    status: String(status),
+    createdAt: Number(createdAt),
+    updatedAt: Number(updatedAt)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  _recordSeqForTests,
+  _resetSeqForTests,
+  eventToManifest,
+  getChannelEvent,
+  getChannelEventsSinceSeq,
+  getCurrentSeqHead,
+  listChannelEvents,
+  listThread,
+  manifestToEventInput,
+  postChannelEvent,
+  setChannelEventStatus
+});

package/src/backend/services/check-runs.js

@@ -0,0 +1,177 @@
+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 check_runs_exports = {};
+__export(check_runs_exports, {
+  forgetTeammateCheckRuns: () => forgetTeammateCheckRuns,
+  getCheckRun: () => getCheckRun,
+  knownCheckRunCounters: () => knownCheckRunCounters,
+  listCheckRuns: () => listCheckRuns,
+  putTeammateCheckRun: () => putTeammateCheckRun,
+  recordCheckRun: () => recordCheckRun,
+  runWords: () => runWords,
+  setCheckRunListener: () => setCheckRunListener
+});
+module.exports = __toCommonJS(check_runs_exports);
+var import_node_crypto = __toESM(require("node:crypto"));
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_check_run_record = require("./task-records/check-run-record");
+var import_agent_review = require("../../shared/lib/agent-review");
+const KEEP_MINE = 200;
+const parse = (s, fallback) => {
+  if (s === null || s === void 0) return fallback;
+  try {
+    return JSON.parse(String(s)) ?? fallback;
+  } catch {
+    return fallback;
+  }
+};
+let listener = null;
+function setCheckRunListener(fn) {
+  listener = fn;
+}
+function recordCheckRun(run, me = { writer: "this-device", name: "you" }) {
+  const id = `local-${import_node_crypto.default.randomUUID()}`;
+  insert(run.projectRoot, id, true, { ...run, writer: me.writer, name: me.name, counter: 0 }, null);
+  (0, import_database.getDb)().run(
+    `DELETE FROM rule_check_runs WHERE project_root = ? AND mine = 1 AND id NOT IN (
+       SELECT id FROM rule_check_runs WHERE project_root = ? AND mine = 1 ORDER BY at DESC LIMIT ?)`,
+    [run.projectRoot, run.projectRoot, KEEP_MINE]
+  );
+  (0, import_persistence.markDirty)();
+  try {
+    listener?.(run);
+  } catch (err) {
+    console.warn("[check-runs] could not share a run:", err);
+  }
+  return id;
+}
+function insert(projectRoot, id, mine, r, verdict) {
+  (0, import_database.getDb)().run(
+    `INSERT OR REPLACE INTO rule_check_runs (project_root, id, mine, writer, counter, name, by_author, by_type, ran_in, commit_sha, dirty, base, rulebook, scope, strict, outcome, says, findings, at, verdict, review)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+    [
+      projectRoot,
+      id,
+      mine ? 1 : 0,
+      r.writer,
+      r.counter,
+      r.name,
+      r.by.author,
+      r.by.authorType,
+      r.ranIn,
+      r.commit,
+      JSON.stringify(r.dirty),
+      r.base,
+      r.rulebook,
+      r.scope,
+      r.strict ? 1 : 0,
+      JSON.stringify(r.outcome),
+      JSON.stringify(r.says),
+      JSON.stringify(r.findings),
+      r.at,
+      verdict ? JSON.stringify(verdict) : null,
+      r.review ? JSON.stringify(r.review) : null
+    ]
+  );
+}
+function putTeammateCheckRun(projectRoot, r, verdict) {
+  (0, import_database.getDb)().run("DELETE FROM rule_check_runs WHERE project_root = ? AND mine = 0 AND writer = ? AND counter < ?", [projectRoot, r.writer, r.counter]);
+  insert(projectRoot, `${r.writer}-${r.counter}`, false, r, verdict);
+  (0, import_persistence.markDirty)();
+}
+function knownCheckRunCounters(projectRoot) {
+  const rows = (0, import_database.getDb)().exec("SELECT writer, MAX(counter) FROM rule_check_runs WHERE project_root = ? AND mine = 0 GROUP BY writer", [projectRoot])[0]?.values ?? [];
+  return new Map(rows.map((r) => [String(r[0]), Number(r[1])]));
+}
+function forgetTeammateCheckRuns(q) {
+  const where = q.projectRoot ? "project_root = ? AND mine = 0" : "writer = ? AND mine = 0";
+  const arg = q.projectRoot ?? q.writer ?? "";
+  const n = Number((0, import_database.getDb)().exec(`SELECT COUNT(*) FROM rule_check_runs WHERE ${where}`, [arg])[0]?.values[0]?.[0] ?? 0);
+  if (n) {
+    (0, import_database.getDb)().run(`DELETE FROM rule_check_runs WHERE ${where}`, [arg]);
+    (0, import_persistence.markDirty)();
+  }
+  return n;
+}
+const COLS = "id, mine, writer, counter, name, by_author, by_type, ran_in, commit_sha, dirty, base, rulebook, scope, strict, outcome, says, findings, at, verdict, review";
+function rowToRun(r) {
+  const mine = Number(r[1]) === 1;
+  const verdict = parse(r[18], {});
+  const name = verdict.verified && verdict.who ? verdict.who : String(r[4]);
+  const person = r[6] === "human" || r[6] === "unverified" || r[5] === r[4];
+  const who = mine ? person ? "you" : `${String(r[5])}` : person ? name : `${String(r[5])} for ${name}`;
+  const run = {
+    id: String(r[0]),
+    mine,
+    writer: String(r[2]),
+    counter: Number(r[3]),
+    who,
+    verified: mine || verdict.verified === true,
+    why: mine || verdict.verified ? null : verdict.why ?? null,
+    ranIn: String(r[7]),
+    commit: r[8] ?? null,
+    dirty: parse(r[9], []),
+    base: r[10] ?? null,
+    rulebook: r[11] ?? null,
+    scope: r[12] ?? null,
+    strict: Number(r[13]) === 1,
+    outcome: parse(r[14], { ok: false, files: 0, blocks: 0, warns: 0 }),
+    says: parse(r[15], []),
+    findings: parse(r[16], []),
+    at: Number(r[17]),
+    review: (0, import_agent_review.parseAgentReview)(parse(r[19], null))
+  };
+  return { ...run, words: runWords(run) };
+}
+function runWords(r) {
+  const at = r.commit ? ` at ${r.commit.slice(0, 7)}` : "";
+  const against = r.base ? `, against ${r.base}` : "";
+  const scope = r.scope ? `, ${r.scope}` : "";
+  const said = r.review ? `${r.review.agent}'s review${r.review.pass ? ` (${r.review.pass})` : ""}: ${(0, import_agent_review.reviewBlockWords)(r.review, r.outcome.blocks)}` : (0, import_check_run_record.outcomeWords)(r.outcome);
+  return `${r.who} in ${r.ranIn}${at}${against}${scope}: ${said}${r.verified ? "" : ` (unverified: ${r.why ?? "not signed"})`}`;
+}
+function listCheckRuns(projectRoot, limit = 50) {
+  const rows = (0, import_database.getDb)().exec(`SELECT ${COLS} FROM rule_check_runs WHERE project_root = ? ORDER BY at DESC LIMIT ?`, [projectRoot, Math.max(1, Math.min(limit, 500))])[0]?.values ?? [];
+  return rows.map(rowToRun);
+}
+function getCheckRun(projectRoot, id) {
+  const r = (0, import_database.getDb)().exec(`SELECT ${COLS} FROM rule_check_runs WHERE project_root = ? AND id = ?`, [projectRoot, id])[0]?.values[0];
+  return r ? rowToRun(r) : null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  forgetTeammateCheckRuns,
+  getCheckRun,
+  knownCheckRunCounters,
+  listCheckRuns,
+  putTeammateCheckRun,
+  recordCheckRun,
+  runWords,
+  setCheckRunListener
+});

package/src/backend/services/checkout-identity.js

@@ -0,0 +1,73 @@
+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 checkout_identity_exports = {};
+__export(checkout_identity_exports, {
+  heldByAnotherCheckout: () => heldByAnotherCheckout,
+  sameRepository: () => sameRepository
+});
+module.exports = __toCommonJS(checkout_identity_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_git_identity = require("./git-identity");
+const canonical = (p) => {
+  try {
+    return import_node_fs.default.realpathSync.native(p);
+  } catch {
+    return import_node_path.default.resolve(p);
+  }
+};
+function commonDir(folder) {
+  if (!import_node_fs.default.existsSync(import_node_path.default.join(folder, ".git"))) return null;
+  try {
+    const out = (0, import_node_child_process.execFileSync)("git", ["rev-parse", "--git-common-dir"], {
+      cwd: folder,
+      encoding: "utf-8",
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+    return out ? canonical(import_node_path.default.resolve(folder, out)) : null;
+  } catch {
+    return null;
+  }
+}
+function sameRepository(a, b) {
+  const common = commonDir(a);
+  if (common && common === commonDir(b)) return true;
+  const origin = (0, import_git_identity.getNormalisedOriginUrl)(a);
+  return !!origin && origin === (0, import_git_identity.getNormalisedOriginUrl)(b);
+}
+function heldByAnotherCheckout(holder, importing) {
+  if (!holder || !import_node_path.default.isAbsolute(holder) || !import_node_fs.default.existsSync(holder)) return false;
+  if (canonical(holder) === canonical(importing)) return false;
+  return sameRepository(holder, importing);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  heldByAnotherCheckout,
+  sameRepository
+});