codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/plan-migrate-service.js

@@ -0,0 +1,395 @@
+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 plan_migrate_service_exports = {};
+__export(plan_migrate_service_exports, {
+  migrateAllPlans: () => migrateAllPlans,
+  migratePlan: () => migratePlan
+});
+module.exports = __toCommonJS(plan_migrate_service_exports);
+var import_database = require("./database");
+var import_persistence = require("./persistence");
+var import_plan_item_service = require("./plan-item-service");
+const DEFAULT_OPTS = {
+  dryRun: true,
+  author: "system",
+  authorType: "system"
+};
+function migrateAllPlans(options = {}) {
+  const opts = { ...DEFAULT_OPTS, ...options };
+  const db = (0, import_database.getDb)();
+  const r = db.exec(`SELECT uid FROM plans`);
+  const planUids = (r[0]?.values ?? []).map((row) => row[0]);
+  const totals = emptyCounts();
+  for (const uid of planUids) {
+    const c = migratePlan(uid, opts);
+    addCounts(totals, c);
+  }
+  return totals;
+}
+function migratePlan(planUid, options = {}) {
+  const opts = { ...DEFAULT_OPTS, ...options };
+  const counts = emptyCounts();
+  counts.plansWalked = 1;
+  const alreadyMigrated = readAlreadyMigratedKeys(planUid);
+  const docs = readPlanDocuments(planUid);
+  for (const doc of docs) {
+    const key = `plan_documents:${doc.uid}`;
+    if (alreadyMigrated.has(key)) {
+      counts.skipped++;
+      continue;
+    }
+    counts.objectsCreated++;
+    if (opts.dryRun) continue;
+    (0, import_plan_item_service.createItem)({
+      planUid,
+      uid: doc.uid,
+      kind: "object",
+      title: doc.title,
+      body: doc.body,
+      template: doc.docType,
+      parentUid: null,
+      // pass 2 will fix nesting via parent_doc_uid
+      sortOrder: parseOrderHint(doc.orderHint),
+      author: doc.author,
+      authorType: doc.authorType,
+      createdAt: doc.createdAt,
+      updatedAt: doc.updatedAt,
+      migratedFrom: key
+    });
+    counts.syntheticEvents++;
+  }
+  const phases = readPlanPhases(planUid);
+  for (const phase of phases) {
+    const key = `plan_phases:${phase.uid}`;
+    if (alreadyMigrated.has(key)) {
+      counts.skipped++;
+      continue;
+    }
+    counts.phaseActionsCreated++;
+    if (opts.dryRun) continue;
+    (0, import_plan_item_service.createItem)({
+      planUid,
+      uid: phase.uid,
+      kind: "action",
+      title: phase.title,
+      body: composePhaseBody(phase),
+      template: "phase",
+      parentUid: null,
+      // Phases sort after Objects. Objects fall in [0, 9999] roughly;
+      // phases get a 10000 offset, then phase_number * 100 to leave
+      // room for manual reordering.
+      sortOrder: 1e4 + phase.phaseNumber * 100,
+      status: phase.status,
+      author: "system",
+      authorType: "system",
+      createdAt: phase.createdAt,
+      updatedAt: phase.updatedAt,
+      migratedFrom: key
+    });
+    counts.syntheticEvents++;
+  }
+  const tasks = readTasks(planUid);
+  for (const task of tasks) {
+    const key = `tasks:${task.uid}`;
+    if (alreadyMigrated.has(key)) {
+      counts.skipped++;
+      continue;
+    }
+    counts.taskActionsCreated++;
+    if (opts.dryRun) continue;
+    const provisionalParent = task.phaseUid;
+    (0, import_plan_item_service.createItem)({
+      planUid,
+      uid: task.uid,
+      kind: "action",
+      title: task.description.split("\n")[0].slice(0, 200) || "Untitled",
+      body: task.body ?? "",
+      template: "leaf",
+      parentUid: provisionalParent,
+      // Tasks within a phase keep their original sort_order. Unphased
+      // tasks land after the phases band.
+      sortOrder: provisionalParent ? task.sortOrder : 2e4 + task.sortOrder * 10,
+      status: task.status,
+      assignee: task.assignee,
+      assigneeType: task.assigneeType,
+      assigneeModel: task.assigneeModel,
+      progressPercent: task.progressPercent,
+      blockedReason: task.blockedReason,
+      scopePath: task.scopePath,
+      fileSpecs: task.fileSpecs,
+      symbolSpecs: task.symbolSpecs,
+      newConnections: task.newConnections,
+      removedConnections: task.removedConnections,
+      dependencies: task.dependencies,
+      author: task.assignee ?? "system",
+      authorType: task.assigneeType ?? "system",
+      createdAt: task.createdAt,
+      updatedAt: task.updatedAt,
+      migratedFrom: key
+    });
+    counts.syntheticEvents++;
+  }
+  if (opts.dryRun) return counts;
+  const db = (0, import_database.getDb)();
+  for (const doc of docs) {
+    if (!doc.parentDocUid) continue;
+    if (!(0, import_plan_item_service.getItem)(doc.parentDocUid)) continue;
+    db.run(
+      `UPDATE plan_items SET parent_uid = ? WHERE uid = ? AND parent_uid IS NULL`,
+      [doc.parentDocUid, doc.uid]
+    );
+    counts.docReparented++;
+  }
+  for (const task of tasks) {
+    if (!task.parentTaskUid) continue;
+    if (!(0, import_plan_item_service.getItem)(task.parentTaskUid)) continue;
+    db.run(
+      `UPDATE plan_items SET parent_uid = ? WHERE uid = ?`,
+      [task.parentTaskUid, task.uid]
+    );
+    counts.subtaskReparented++;
+  }
+  const migratedItemUids = collectMigratedUids(planUid);
+  if (migratedItemUids.size > 0) {
+    counts.attachmentsRetargeted = retargetRows(
+      "attachments",
+      ["task", "plan_doc"],
+      "item",
+      migratedItemUids
+    );
+    counts.commentsRetargeted = retargetRows(
+      "comments",
+      ["task"],
+      "item",
+      migratedItemUids
+    );
+  }
+  (0, import_persistence.markDirty)();
+  return counts;
+}
+function readPlanDocuments(planUid) {
+  const db = (0, import_database.getDb)();
+  let r;
+  try {
+    r = db.exec(
+      `SELECT uid, doc_type, title, body, order_hint, parent_doc_uid,
+              author, author_type, created_at, updated_at
+       FROM plan_documents WHERE plan_uid = ?
+       ORDER BY order_hint ASC NULLS LAST, created_at ASC`,
+      [planUid]
+    );
+  } catch {
+    return [];
+  }
+  if (!r[0]) return [];
+  return r[0].values.map((row) => ({
+    uid: row[0],
+    docType: row[1] ?? "custom",
+    title: row[2] ?? "",
+    body: row[3] ?? "",
+    orderHint: row[4] ?? null,
+    parentDocUid: row[5] ?? null,
+    author: row[6] ?? "human",
+    authorType: row[7] ?? "human",
+    createdAt: row[8] ?? Date.now(),
+    updatedAt: row[9] ?? Date.now()
+  }));
+}
+function readPlanPhases(planUid) {
+  const db = (0, import_database.getDb)();
+  let r;
+  try {
+    r = db.exec(
+      `SELECT uid, phase_number, title, scope, prerequisites,
+              git_checkpoint, acceptance_criteria, status, created_at, updated_at
+       FROM plan_phases WHERE plan_uid = ? ORDER BY phase_number ASC`,
+      [planUid]
+    );
+  } catch {
+    return [];
+  }
+  if (!r[0]) return [];
+  return r[0].values.map((row) => ({
+    uid: row[0],
+    phaseNumber: row[1] ?? 0,
+    title: row[2] ?? "",
+    scope: row[3] ?? "",
+    prerequisites: row[4] ?? "",
+    gitCheckpoint: row[5] ?? null,
+    acceptanceCriteria: row[6] ?? "",
+    status: row[7] ?? "pending",
+    createdAt: row[8] ?? Date.now(),
+    updatedAt: row[9] ?? Date.now()
+  }));
+}
+function readTasks(planUid) {
+  const db = (0, import_database.getDb)();
+  let r;
+  try {
+    r = db.exec(
+      `SELECT uid, sort_order, description, status, assignee, assignee_type, assignee_model,
+              affected_files, affected_symbols, new_connections, removed_connections, dependencies,
+              file_spec, symbol_specs, phase_uid,
+              parent_task_uid, body, prompt, scope_path, file_specs,
+              progress_percent, blocked_reason,
+              created_at, updated_at
+       FROM tasks WHERE plan_uid = ? ORDER BY sort_order ASC`,
+      [planUid]
+    );
+  } catch {
+    return [];
+  }
+  if (!r[0]) return [];
+  return r[0].values.map((row) => ({
+    uid: row[0],
+    sortOrder: row[1] ?? 0,
+    description: row[2] ?? "",
+    status: row[3] ?? "pending",
+    assignee: row[4] ?? null,
+    assigneeType: row[5] ?? null,
+    assigneeModel: row[6] ?? null,
+    affectedFiles: parseJsonArr(row[7]),
+    affectedSymbols: parseJsonArr(row[8]),
+    newConnections: parseJsonArr(row[9]),
+    removedConnections: parseJsonArr(row[10]),
+    dependencies: parseJsonArr(row[11]),
+    fileSpec: row[12] ?? null,
+    symbolSpecs: parseJsonArr(row[13]),
+    phaseUid: row[14] ?? null,
+    parentTaskUid: row[15] ?? null,
+    body: row[16] ?? null,
+    prompt: row[17] ?? null,
+    scopePath: row[18] ?? null,
+    fileSpecs: parseJsonArr(row[19]),
+    progressPercent: row[20] ?? null,
+    blockedReason: row[21] ?? null,
+    createdAt: row[22] ?? Date.now(),
+    updatedAt: row[23] ?? Date.now()
+  }));
+}
+function parseJsonArr(s) {
+  if (typeof s !== "string") return [];
+  try {
+    const parsed = JSON.parse(s);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function readAlreadyMigratedKeys(planUid) {
+  const db = (0, import_database.getDb)();
+  const r = db.exec(
+    `SELECT migrated_from FROM plan_items
+     WHERE plan_uid = ? AND migrated_from IS NOT NULL`,
+    [planUid]
+  );
+  const out = /* @__PURE__ */ new Set();
+  if (!r[0]) return out;
+  for (const row of r[0].values) {
+    const v = row[0];
+    if (v) out.add(v);
+  }
+  return out;
+}
+function parseOrderHint(hint) {
+  if (!hint) return 9999;
+  const n = Number(hint);
+  if (!Number.isFinite(n)) return 9999;
+  return Math.round(n * 10);
+}
+function composePhaseBody(phase) {
+  const sections = [];
+  if (phase.scope.trim()) sections.push(`## Scope
+
+${phase.scope.trim()}`);
+  if (phase.prerequisites.trim()) sections.push(`## Prerequisites
+
+${phase.prerequisites.trim()}`);
+  if (phase.acceptanceCriteria.trim()) sections.push(`## Acceptance criteria
+
+${phase.acceptanceCriteria.trim()}`);
+  if (phase.gitCheckpoint && phase.gitCheckpoint.trim()) {
+    sections.push(`## Git checkpoint
+
+\`${phase.gitCheckpoint.trim()}\``);
+  }
+  return sections.join("\n\n");
+}
+function collectMigratedUids(planUid) {
+  const db = (0, import_database.getDb)();
+  const r = db.exec(
+    `SELECT uid FROM plan_items WHERE plan_uid = ? AND migrated_from IS NOT NULL`,
+    [planUid]
+  );
+  const out = /* @__PURE__ */ new Set();
+  if (!r[0]) return out;
+  for (const row of r[0].values) out.add(row[0]);
+  return out;
+}
+function retargetRows(table, fromTypes, toType, itemUids) {
+  const db = (0, import_database.getDb)();
+  let updated = 0;
+  for (const uid of itemUids) {
+    const placeholders = fromTypes.map(() => "?").join(", ");
+    const params = [toType, uid, ...fromTypes];
+    const before = db.exec(
+      `SELECT COUNT(*) FROM ${table} WHERE target_uid = ? AND target_type IN (${placeholders})`,
+      [uid, ...fromTypes]
+    );
+    const count = before[0]?.values[0]?.[0] ?? 0;
+    if (count === 0) continue;
+    db.run(
+      `UPDATE ${table} SET target_type = ?
+       WHERE target_uid = ? AND target_type IN (${placeholders})`,
+      params
+    );
+    updated += count;
+  }
+  return updated;
+}
+function emptyCounts() {
+  return {
+    plansWalked: 0,
+    objectsCreated: 0,
+    phaseActionsCreated: 0,
+    taskActionsCreated: 0,
+    subtaskReparented: 0,
+    docReparented: 0,
+    attachmentsRetargeted: 0,
+    commentsRetargeted: 0,
+    syntheticEvents: 0,
+    skipped: 0
+  };
+}
+function addCounts(into, from) {
+  into.plansWalked += from.plansWalked;
+  into.objectsCreated += from.objectsCreated;
+  into.phaseActionsCreated += from.phaseActionsCreated;
+  into.taskActionsCreated += from.taskActionsCreated;
+  into.subtaskReparented += from.subtaskReparented;
+  into.docReparented += from.docReparented;
+  into.attachmentsRetargeted += from.attachmentsRetargeted;
+  into.commentsRetargeted += from.commentsRetargeted;
+  into.syntheticEvents += from.syntheticEvents;
+  into.skipped += from.skipped;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  migrateAllPlans,
+  migratePlan
+});

package/src/backend/services/plan-overlay-service.js

@@ -0,0 +1,173 @@
+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 plan_overlay_service_exports = {};
+__export(plan_overlay_service_exports, {
+  buildFileOverlay: () => buildFileOverlay,
+  relativeTo: () => relativeTo
+});
+module.exports = __toCommonJS(plan_overlay_service_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_plan_item_service = require("./plan-item-service");
+var import_database = require("./database");
+function normalise(p) {
+  return p.replace(/^\.\//, "").replace(/^\/+/, "").replace(/\\/g, "/").toLowerCase();
+}
+function specTargets(spec, relativePath) {
+  const target = normalise(spec.path);
+  const file = normalise(relativePath);
+  if (!target) return false;
+  if (target === file) return true;
+  if (spec.isDir) return file.startsWith(target.endsWith("/") ? target : `${target}/`);
+  return false;
+}
+function resolveSymbolSpan(lookupSymbols, absolutePath, symbolName) {
+  let symbols;
+  try {
+    symbols = lookupSymbols(absolutePath);
+  } catch {
+    return null;
+  }
+  if (symbols.length === 0) return null;
+  const exact = symbols.find((s) => s.name === symbolName);
+  if (exact) return { startLine: exact.startLine, endLine: exact.endLine };
+  const qualified = symbols.find((s) => /[#.)]/.test(s.name) && s.name.split(/[#.]/).pop() === symbolName);
+  if (qualified) return { startLine: qualified.startLine, endLine: qualified.endLine };
+  const caseInsensitive = symbols.find((s) => s.name.toLowerCase() === symbolName.toLowerCase());
+  if (caseInsensitive) {
+    return { startLine: caseInsensitive.startLine, endLine: caseInsensitive.endLine };
+  }
+  return null;
+}
+function markerBase(item, edit) {
+  return {
+    itemUid: item.uid,
+    itemTitle: item.title,
+    itemStatus: item.status ?? null,
+    itemAssignee: item.assignee ?? null,
+    planUid: item.planUid,
+    instruction: edit?.instruction ?? "",
+    intent: edit?.intent ?? null,
+    symbol: edit?.symbol ?? null
+  };
+}
+function buildFileOverlay(params) {
+  const lookupItems = params.lookupItems ?? import_plan_item_service.listAllItems;
+  const lookupSymbols = params.lookupSymbols ?? import_database.getFileSymbolsWithMembers;
+  const markers = [];
+  const fileLevel = [];
+  const unanchored = [];
+  const touchingItems = /* @__PURE__ */ new Set();
+  const planUids = params.planUid ? params.plans.filter((p) => p === params.planUid) : params.plans;
+  for (const planUid of planUids) {
+    let items;
+    try {
+      items = lookupItems(planUid);
+    } catch {
+      continue;
+    }
+    for (const item of items) {
+      for (const spec of item.fileSpecs ?? []) {
+        if (!specTargets(spec, params.relativePath)) continue;
+        touchingItems.add(item.uid);
+        const edits = spec.edits ?? [];
+        if (edits.length === 0) {
+          fileLevel.push({
+            ...markerBase(item, null),
+            anchor: "file",
+            startLine: null,
+            endLine: null,
+            instruction: spec.description ?? "",
+            intent: spec.action ?? null
+          });
+          continue;
+        }
+        for (const edit of edits) {
+          if (edit.lineRange) {
+            const { start, end } = edit.lineRange;
+            if (start < 1 || start > params.lineCount || end < start) {
+              unanchored.push({
+                ...markerBase(item, edit),
+                anchor: "unanchored",
+                startLine: null,
+                endLine: null,
+                // Never clamp. A marker in the wrong place is worse than
+                // no marker, because a reader believes it.
+                reason: `Pinned to lines ${start}\u2013${end}, but the file has ${params.lineCount}. The file has probably changed since the plan was written.`
+              });
+              continue;
+            }
+            markers.push({
+              ...markerBase(item, edit),
+              anchor: "lines",
+              startLine: start,
+              endLine: Math.min(end, params.lineCount)
+            });
+            continue;
+          }
+          if (edit.symbol) {
+            const span = resolveSymbolSpan(lookupSymbols, params.absolutePath, edit.symbol);
+            if (!span) {
+              unanchored.push({
+                ...markerBase(item, edit),
+                anchor: "unanchored",
+                startLine: null,
+                endLine: null,
+                reason: `No symbol named "${edit.symbol}" in this file.`
+              });
+              continue;
+            }
+            markers.push({ ...markerBase(item, edit), anchor: "symbol", ...span });
+            continue;
+          }
+          fileLevel.push({
+            ...markerBase(item, edit),
+            anchor: "file",
+            startLine: null,
+            endLine: null
+          });
+        }
+      }
+    }
+  }
+  markers.sort((a, b) => (a.startLine ?? 0) - (b.startLine ?? 0));
+  return {
+    relativePath: params.relativePath,
+    markers,
+    fileLevel,
+    unanchored,
+    itemCount: touchingItems.size
+  };
+}
+function relativeTo(projectRoot, absolutePath) {
+  return import_node_path.default.relative(projectRoot, absolutePath).replace(/\\/g, "/");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildFileOverlay,
+  relativeTo
+});