codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/schema-reconciler.js

@@ -0,0 +1,250 @@
+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 schema_reconciler_exports = {};
+__export(schema_reconciler_exports, {
+  parseCreateTableSql: () => parseCreateTableSql,
+  reconcileSchema: () => reconcileSchema,
+  reconcileSchemaFromSql: () => reconcileSchemaFromSql
+});
+module.exports = __toCommonJS(schema_reconciler_exports);
+const COMMENT_LINE = /--[^\n]*/g;
+const COMMENT_BLOCK = /\/\*[\s\S]*?\*\//g;
+function stripComments(sql) {
+  return sql.replace(COMMENT_BLOCK, "").replace(COMMENT_LINE, "");
+}
+function parseCreateTableSql(sql) {
+  const cleaned = stripComments(sql);
+  const out = [];
+  const headRe = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*\(/gi;
+  let m;
+  while ((m = headRe.exec(cleaned)) !== null) {
+    const tableName = m[1];
+    const bodyStart = m.index + m[0].length;
+    const bodyEnd = findMatchingParen(cleaned, bodyStart - 1);
+    if (bodyEnd < 0) continue;
+    const body = cleaned.slice(bodyStart, bodyEnd);
+    const columns = parseColumnList(body);
+    out.push({ name: tableName, columns });
+    headRe.lastIndex = bodyEnd + 1;
+  }
+  return out;
+}
+function findMatchingParen(s, openIdx) {
+  if (s[openIdx] !== "(") return -1;
+  let depth = 1;
+  let i = openIdx + 1;
+  while (i < s.length) {
+    const ch = s[i];
+    if (ch === "'" || ch === '"') {
+      const quote = ch;
+      i++;
+      while (i < s.length) {
+        if (s[i] === quote) {
+          if (s[i + 1] === quote) {
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    if (ch === "(") depth++;
+    else if (ch === ")") {
+      depth--;
+      if (depth === 0) return i;
+    }
+    i++;
+  }
+  return -1;
+}
+function parseColumnList(body) {
+  const parts = splitTopLevelCommas(body);
+  const columns = [];
+  for (const raw of parts) {
+    const part = raw.trim();
+    if (!part) continue;
+    if (isConstraintClause(part)) continue;
+    const col = parseColumnDef(part);
+    if (col) columns.push(col);
+  }
+  return columns;
+}
+function splitTopLevelCommas(s) {
+  const out = [];
+  let depth = 0;
+  let start = 0;
+  let i = 0;
+  while (i < s.length) {
+    const ch = s[i];
+    if (ch === "'" || ch === '"') {
+      const quote = ch;
+      i++;
+      while (i < s.length) {
+        if (s[i] === quote) {
+          if (s[i + 1] === quote) {
+            i += 2;
+            continue;
+          }
+          i++;
+          break;
+        }
+        i++;
+      }
+      continue;
+    }
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    else if (ch === "," && depth === 0) {
+      out.push(s.slice(start, i));
+      start = i + 1;
+    }
+    i++;
+  }
+  out.push(s.slice(start));
+  return out;
+}
+const CONSTRAINT_KEYWORDS = [
+  "PRIMARY KEY",
+  "UNIQUE",
+  "CHECK",
+  "FOREIGN KEY",
+  "CONSTRAINT"
+];
+function isConstraintClause(part) {
+  const upper = part.toUpperCase().trimStart();
+  return CONSTRAINT_KEYWORDS.some((kw) => upper.startsWith(kw + " ") || upper.startsWith(kw + "("));
+}
+function parseColumnDef(def) {
+  let rest = def.trim();
+  let name;
+  if (rest.startsWith('"')) {
+    const closeIdx = rest.indexOf('"', 1);
+    if (closeIdx < 0) return null;
+    name = rest.slice(1, closeIdx);
+    rest = rest.slice(closeIdx + 1).trim();
+  } else {
+    const m = rest.match(/^([A-Za-z_][A-Za-z0-9_]*)\s+([\s\S]*)$/);
+    if (!m) return null;
+    name = m[1];
+    rest = m[2];
+  }
+  const typeMatch = rest.match(/^([A-Za-z][A-Za-z0-9_]*)/);
+  const type = typeMatch ? typeMatch[1].toUpperCase() : "TEXT";
+  const upper = rest.toUpperCase();
+  const notNull = /\bNOT\s+NULL\b/.test(upper);
+  const defaultValue = extractDefault(rest);
+  return { name, type, notNull, defaultValue };
+}
+function extractDefault(s) {
+  const re = /\bDEFAULT\s+/i;
+  const m = re.exec(s);
+  if (!m) return null;
+  const i = m.index + m[0].length;
+  if (i >= s.length) return null;
+  const ch = s[i];
+  if (ch === "'" || ch === '"') {
+    const quote = ch;
+    let j2 = i + 1;
+    while (j2 < s.length) {
+      if (s[j2] === quote) {
+        if (s[j2 + 1] === quote) {
+          j2 += 2;
+          continue;
+        }
+        return s.slice(i, j2 + 1);
+      }
+      j2++;
+    }
+    return null;
+  }
+  let j = i;
+  while (j < s.length && !/\s|,/.test(s[j])) j++;
+  return s.slice(i, j);
+}
+function liveColumns(db, table) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(table)) return [];
+  const result = db.exec(`PRAGMA table_info(${table})`);
+  if (result.length === 0) return [];
+  const { columns, values } = result[0];
+  const nameIdx = columns.indexOf("name");
+  if (nameIdx < 0) return [];
+  const out = [];
+  for (const row of values) {
+    const v = row[nameIdx];
+    if (typeof v === "string") out.push(v);
+  }
+  return out;
+}
+function buildAddColumnSql(table, col) {
+  const parts = [`ALTER TABLE ${table} ADD COLUMN ${col.name} ${col.type}`];
+  if (col.notNull && col.defaultValue !== null) {
+    parts.push(`NOT NULL DEFAULT ${col.defaultValue}`);
+  } else if (col.defaultValue !== null) {
+    parts.push(`DEFAULT ${col.defaultValue}`);
+  }
+  return parts.join(" ");
+}
+function reconcileSchema(db, expected, options = {}) {
+  const skip = new Set(options.skipTables ?? []);
+  const report = {
+    tablesChecked: 0,
+    tablesSkipped: [],
+    columnsAdded: [],
+    errors: []
+  };
+  for (const table of expected) {
+    if (skip.has(table.name)) {
+      report.tablesSkipped.push(table.name);
+      continue;
+    }
+    const actual = liveColumns(db, table.name);
+    if (actual.length === 0) {
+      report.tablesSkipped.push(table.name);
+      continue;
+    }
+    report.tablesChecked++;
+    const actualSet = new Set(actual);
+    for (const col of table.columns) {
+      if (actualSet.has(col.name)) continue;
+      const sql = buildAddColumnSql(table.name, col);
+      try {
+        db.run(sql);
+        report.columnsAdded.push({ table: table.name, column: col.name, sql });
+      } catch (err) {
+        report.errors.push({
+          table: table.name,
+          column: col.name,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      }
+    }
+  }
+  return report;
+}
+function reconcileSchemaFromSql(db, schemaSql, options = {}) {
+  return reconcileSchema(db, parseCreateTableSql(schemaSql), options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  parseCreateTableSql,
+  reconcileSchema,
+  reconcileSchemaFromSql
+});

package/src/backend/services/secret-store.js

@@ -0,0 +1,119 @@
+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 secret_store_exports = {};
+__export(secret_store_exports, {
+  fileStore: () => fileStore,
+  memoryStore: () => memoryStore,
+  openSecretStore: () => openSecretStore,
+  secretStore: () => secretStore
+});
+module.exports = __toCommonJS(secret_store_exports);
+var import_node_crypto = require("node:crypto");
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_persistence = require("./persistence");
+const KEY = /^[a-z][a-z0-9:._-]{0,127}$/;
+function checkKey(key) {
+  if (!KEY.test(key)) throw new Error(`Not a secret key: ${key}`);
+}
+function memoryStore(why) {
+  const values = /* @__PURE__ */ new Map();
+  return {
+    kind: "memory",
+    where: `kept only until CodeTrellis quits: ${why}`,
+    has: (key) => values.has(key),
+    get: (key) => values.get(key) ?? null,
+    set: (key, value) => {
+      checkKey(key);
+      values.set(key, value);
+    },
+    delete: (key) => {
+      values.delete(key);
+    }
+  };
+}
+function fileStore(dir, cipher, where) {
+  const fileOf = (key) => import_node_path.default.join(dir, `${(0, import_node_crypto.createHash)("sha256").update(key).digest("hex").slice(0, 32)}.bin`);
+  return {
+    kind: "os-keychain",
+    where,
+    has: (key) => import_node_fs.default.existsSync(fileOf(key)),
+    get: (key) => {
+      try {
+        return cipher.decrypt(import_node_fs.default.readFileSync(fileOf(key)));
+      } catch {
+        return null;
+      }
+    },
+    set: (key, value) => {
+      checkKey(key);
+      import_node_fs.default.mkdirSync(dir, { recursive: true, mode: 448 });
+      const file = fileOf(key);
+      const tmp = `${file}.${process.pid}.tmp`;
+      import_node_fs.default.writeFileSync(tmp, cipher.encrypt(value), { mode: 384 });
+      import_node_fs.default.renameSync(tmp, file);
+    },
+    delete: (key) => {
+      import_node_fs.default.rmSync(fileOf(key), { force: true });
+    }
+  };
+}
+function electronSafeStorage() {
+  if (!process.versions.electron) return null;
+  try {
+    const { safeStorage } = require("electron");
+    return safeStorage ?? null;
+  } catch {
+    return null;
+  }
+}
+const KEYCHAIN_NAME = { darwin: "the macOS Keychain", win32: "Windows (DPAPI)", linux: "the system keyring" };
+function openSecretStore() {
+  const safe = electronSafeStorage();
+  if (!safe) return memoryStore("this build has no OS keychain (it is not running inside the desktop app)");
+  if (!safe.isEncryptionAvailable()) return memoryStore("the OS keychain is not available");
+  if (process.platform === "linux" && safe.getSelectedStorageBackend?.() === "basic_text") {
+    return memoryStore("no system keyring is running, so the token could not be encrypted");
+  }
+  return fileStore(
+    import_node_path.default.join((0, import_persistence.getDataDir)(), "secrets"),
+    { encrypt: (s) => safe.encryptString(s), decrypt: (b) => safe.decryptString(b) },
+    `encrypted with a key held by ${KEYCHAIN_NAME[process.platform] ?? "the OS keychain"}`
+  );
+}
+let store = null;
+function secretStore() {
+  return store ??= openSecretStore();
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fileStore,
+  memoryStore,
+  openSecretStore,
+  secretStore
+});

package/src/backend/services/section-workstreams.js

@@ -0,0 +1,95 @@
+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 section_workstreams_exports = {};
+__export(section_workstreams_exports, {
+  branchOfRoot: () => branchOfRoot,
+  claimRefusal: () => claimRefusal,
+  cleanBranch: () => cleanBranch,
+  elsewhereLine: () => elsewhereLine,
+  offeredTo: () => offeredTo,
+  resolveSection: () => resolveSection,
+  usableBase: () => usableBase,
+  whereWorked: () => whereWorked,
+  workstreamOfBranch: () => workstreamOfBranch,
+  worktreeDirFor: () => import_branch_name.worktreeDirFor
+});
+module.exports = __toCommonJS(section_workstreams_exports);
+var import_branch_name = require("../../shared/lib/branch-name");
+const BRANCH_RE = /^(?!\/|.*\/\/|.*\.\.|.*@\{|.*\.lock$|.*\/$|-)[A-Za-z0-9._/@+-]{1,100}$/;
+function cleanBranch(raw) {
+  if (typeof raw !== "string") return null;
+  const b = raw.trim();
+  return BRANCH_RE.test(b) ? b : null;
+}
+function resolveSection(item, getItem) {
+  let cur = item;
+  const seen = /* @__PURE__ */ new Set();
+  while (cur && !seen.has(cur.uid)) {
+    seen.add(cur.uid);
+    if (cur.workstream) return { branch: cur.workstream, fromUid: cur.uid, fromTitle: cur.title };
+    cur = cur.parentUid ? getItem(cur.parentUid) : null;
+  }
+  return null;
+}
+function workstreamOfBranch(branch, workstreams) {
+  return workstreams.find((w) => w.branch === branch && !w.root.startsWith("branch:")) ?? workstreams.find((w) => w.branch === branch) ?? null;
+}
+function branchOfRoot(root, workstreams) {
+  if (!root) return null;
+  return workstreams.find((w) => w.root === root)?.branch ?? null;
+}
+function whereWorked(branch, workstreams) {
+  const w = workstreamOfBranch(branch, workstreams);
+  if (w && !w.root.startsWith("branch:")) return `${branch} in ${w.root}`;
+  if (w) return `${branch} (checked out in no worktree yet)`;
+  return `${branch} (no worktree or branch of that name here yet)`;
+}
+function claimRefusal(item, section, callerBranch, workstreams) {
+  if (!section || section.branch === callerBranch) return null;
+  const where = whereWorked(section.branch, workstreams);
+  const lead = section.fromUid === item.uid ? `\u201C${item.title}\u201D is worked on ${where}` : `\u201C${item.title}\u201D is in \u201C${section.fromTitle}\u201D, which is worked on ${where}`;
+  const you = callerBranch ? `You are working on ${callerBranch}.` : "CodeTrellis cannot tell which worktree you are in: your client reported no folder, or its checkout is on no branch.";
+  return `${lead}. ${you} Start a session there to claim it, or ask the person to move the section to your worktree.`;
+}
+function offeredTo(section, callerBranch) {
+  return !section || section.branch === callerBranch;
+}
+function elsewhereLine(branches) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const b of branches) counts.set(b, (counts.get(b) ?? 0) + 1);
+  return [...counts].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).map(([b, n]) => `${n} in ${b}`).join(", ");
+}
+function usableBase(baseRef) {
+  if (!baseRef) return null;
+  const b = baseRef.trim();
+  if (/^[0-9a-f]{7,40}$/i.test(b)) return b;
+  return cleanBranch(b);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  branchOfRoot,
+  claimRefusal,
+  cleanBranch,
+  elsewhereLine,
+  offeredTo,
+  resolveSection,
+  usableBase,
+  whereWorked,
+  workstreamOfBranch,
+  worktreeDirFor
+});

package/src/backend/services/self-write-tracker.js

@@ -0,0 +1,75 @@
+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 self_write_tracker_exports = {};
+__export(self_write_tracker_exports, {
+  stampSelfWrite: () => stampSelfWrite,
+  wasJustWrittenByUs: () => wasJustWrittenByUs
+});
+module.exports = __toCommonJS(self_write_tracker_exports);
+var import_node_crypto = __toESM(require("node:crypto"));
+var import_node_fs = __toESM(require("node:fs"));
+const recentSelfWrites = /* @__PURE__ */ new Map();
+const SELF_WRITE_TTL_MS = 1e3;
+const MAX_STAMPS = 5e3;
+function hashOf(filePath) {
+  try {
+    return import_node_crypto.default.createHash("sha1").update(import_node_fs.default.readFileSync(filePath)).digest("hex");
+  } catch {
+    return null;
+  }
+}
+function stampSelfWrite(filePath) {
+  recentSelfWrites.delete(filePath);
+  recentSelfWrites.set(filePath, { at: Date.now(), hash: hashOf(filePath) });
+  if (recentSelfWrites.size > MAX_STAMPS) {
+    const oldest = recentSelfWrites.keys().next().value;
+    if (oldest !== void 0) recentSelfWrites.delete(oldest);
+  }
+}
+function wasJustWrittenByUs(filePath) {
+  const t = recentSelfWrites.get(filePath);
+  if (!t) return false;
+  if (t.hash) {
+    const now = hashOf(filePath);
+    if (now === t.hash) return true;
+    if (now !== null) {
+      recentSelfWrites.delete(filePath);
+      return false;
+    }
+  }
+  if (Date.now() - t.at > SELF_WRITE_TTL_MS) {
+    recentSelfWrites.delete(filePath);
+    return false;
+  }
+  return true;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  stampSelfWrite,
+  wasJustWrittenByUs
+});