codetrellis 0.0.0-stage → 0.3.0

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

@@ -0,0 +1,156 @@
+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_history_service_exports = {};
+__export(plan_history_service_exports, {
+  diffPlanBetweenCommits: () => diffPlanBetweenCommits,
+  getPlanAtCommit: () => getPlanAtCommit
+});
+module.exports = __toCommonJS(plan_history_service_exports);
+var import_node_child_process = require("node:child_process");
+var import_git_safety = require("./git-safety");
+var import_node_path = __toESM(require("node:path"));
+var import_yaml = require("yaml");
+var import_plans_home = require("./plans-home");
+function getPlanAtCommit(projectRoot, planSlug, commitHash) {
+  projectRoot = (0, import_plans_home.plansHome)(projectRoot) ?? projectRoot;
+  (0, import_git_safety.assertSafeGitRef)(commitHash, "getPlanAtCommit(commitHash)");
+  const planDir = `.codetrellis/plans/${planSlug}`;
+  let timestamp;
+  try {
+    timestamp = runGitArgs(["show", "-s", "--format=%aI", commitHash], projectRoot).trim();
+  } catch {
+    return null;
+  }
+  let planMeta = null;
+  try {
+    const planYaml = runGitArgs(["show", `${commitHash}:${planDir}/plan.yaml`], projectRoot);
+    const parsed = (0, import_yaml.parse)(planYaml);
+    if (parsed && typeof parsed === "object") {
+      planMeta = {
+        uid: parsed.uid ?? "",
+        title: parsed.title ?? planSlug,
+        status: parsed.status ?? "unknown",
+        description: parsed.description ?? void 0,
+        createdAt: parsed.createdAt ?? void 0,
+        updatedAt: parsed.updatedAt ?? void 0
+      };
+    }
+  } catch {
+  }
+  const items = readItemsAtCommit(projectRoot, planDir, commitHash);
+  return { commitHash, timestamp, plan: planMeta, items };
+}
+function diffPlanBetweenCommits(projectRoot, planSlug, baseCommit, headCommit) {
+  (0, import_git_safety.assertSafeGitRef)(baseCommit, "diffPlanBetweenCommits(baseCommit)");
+  (0, import_git_safety.assertSafeGitRef)(headCommit, "diffPlanBetweenCommits(headCommit)");
+  const baseState = getPlanAtCommit(projectRoot, planSlug, baseCommit);
+  const headState = getPlanAtCommit(projectRoot, planSlug, headCommit);
+  const baseItems = new Map((baseState?.items ?? []).map((i) => [i.uid, i]));
+  const headItems = new Map((headState?.items ?? []).map((i) => [i.uid, i]));
+  const added = [];
+  const removed = [];
+  const modified = [];
+  for (const [uid, item] of headItems) {
+    if (!baseItems.has(uid)) {
+      added.push(item);
+    }
+  }
+  for (const [uid, item] of baseItems) {
+    if (!headItems.has(uid)) {
+      removed.push(item);
+    }
+  }
+  for (const [uid, headItem] of headItems) {
+    const baseItem = baseItems.get(uid);
+    if (!baseItem) continue;
+    const fields = [];
+    const checkFields = ["title", "status", "kind", "body", "visibility", "assignee", "parentUid"];
+    for (const field of checkFields) {
+      const before = baseItem[field];
+      const after = headItem[field];
+      if (JSON.stringify(before) !== JSON.stringify(after)) {
+        fields.push({ field, before, after });
+      }
+    }
+    if (fields.length > 0) {
+      modified.push({ uid, title: headItem.title, fields });
+    }
+  }
+  const planMetaChanged = JSON.stringify(baseState?.plan) !== JSON.stringify(headState?.plan);
+  return { baseCommit, headCommit, added, removed, modified, planMetaChanged };
+}
+function runGitArgs(args, cwd) {
+  return (0, import_node_child_process.execFileSync)("git", args, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 1e4
+  });
+}
+function readItemsAtCommit(projectRoot, planDir, commitHash) {
+  const items = [];
+  let listing;
+  try {
+    listing = runGitArgs(["ls-tree", "-r", "--name-only", commitHash, "--", planDir], projectRoot);
+  } catch {
+    return items;
+  }
+  for (const filePath of listing.trim().split("\n").filter(Boolean)) {
+    if (!filePath.endsWith(".yaml") && !filePath.endsWith(".yml")) continue;
+    if (filePath.endsWith("/plan.yaml")) continue;
+    const isItemFile = filePath.includes("/items/");
+    const isLegacy = filePath.includes("/tasks/") || filePath.includes("/phases/");
+    const isChannel = filePath.includes("/channels/");
+    if (!isItemFile && !isLegacy) continue;
+    if (isChannel) continue;
+    try {
+      const content = runGitArgs(["show", `${commitHash}:${filePath}`], projectRoot);
+      const parsed = (0, import_yaml.parse)(content);
+      if (!parsed || typeof parsed !== "object") continue;
+      const item = {
+        uid: parsed.uid ?? import_node_path.default.basename(filePath, ".yaml"),
+        title: parsed.title ?? import_node_path.default.basename(filePath, ".yaml"),
+        kind: parsed.kind ?? (isLegacy ? "action" : "object"),
+        status: parsed.status ?? void 0,
+        parentUid: parsed.parentUid ?? parsed.parent_uid ?? null,
+        body: parsed.body ?? void 0,
+        visibility: parsed.visibility ?? "shared",
+        assignee: parsed.assignee ?? void 0,
+        sortOrder: parsed.sortOrder ?? parsed.sort_order ?? void 0
+      };
+      items.push(item);
+    } catch {
+    }
+  }
+  return items;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  diffPlanBetweenCommits,
+  getPlanAtCommit
+});

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

@@ -0,0 +1,261 @@
+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_import_service_exports = {};
+__export(plan_import_service_exports, {
+  importFromClaudeSession: () => importFromClaudeSession,
+  importFromConversation: () => importFromConversation,
+  importFromGitDiff: () => importFromGitDiff,
+  importFromGitHubIssue: () => importFromGitHubIssue
+});
+module.exports = __toCommonJS(plan_import_service_exports);
+function importFromGitHubIssue(input) {
+  const items = [];
+  const checklistPattern = /^[-*]\s+\[[ x]\]\s+(.+)$/gm;
+  let match;
+  while ((match = checklistPattern.exec(input.body)) !== null) {
+    items.push({
+      kind: "action",
+      title: match[1].trim()
+    });
+  }
+  const codeBlockPattern = /```(\w+)?\n([\s\S]*?)```/g;
+  const codeBlocks = [];
+  while ((match = codeBlockPattern.exec(input.body)) !== null) {
+    codeBlocks.push(match[0]);
+  }
+  if (items.length === 0 && codeBlocks.length > 0) {
+    items.push({
+      kind: "action",
+      title: "Investigate and fix",
+      body: "Investigate the issue described above and implement a fix."
+    });
+  }
+  const fileRefPattern = /`([a-zA-Z0-9_/.\\-]+\.[a-zA-Z]{1,10})`/g;
+  const referencedFiles = /* @__PURE__ */ new Set();
+  while ((match = fileRefPattern.exec(input.body)) !== null) {
+    const f = match[1];
+    if (!f.includes(" ") && f.includes("/") && !f.startsWith("v")) {
+      referencedFiles.add(f);
+    }
+  }
+  if (referencedFiles.size > 0 && items.length > 0) {
+    items[0].fileSpecs = Array.from(referencedFiles).slice(0, 20).map((path) => ({
+      path,
+      action: "modify"
+    }));
+  }
+  const description = input.body.replace(/^[-*]\s+\[[ x]\]\s+.+$/gm, "").replace(/\n{3,}/g, "\n\n").trim();
+  return {
+    title: input.title,
+    description: description || input.body,
+    items,
+    source: "github_issue",
+    metadata: {
+      url: input.url,
+      labels: input.labels
+    }
+  };
+}
+function importFromConversation(input) {
+  const lines = input.text.split("\n");
+  const items = [];
+  const fileRefs = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    const trimmed = line.trim();
+    const numbered = trimmed.match(/^\d+\.\s+(.+)/);
+    if (numbered && numbered[1].length > 5 && numbered[1].length < 200) {
+      items.push({ kind: "action", title: numbered[1] });
+      continue;
+    }
+    const header = trimmed.match(/^#{2,3}\s+(.+)/);
+    if (header && header[1].length > 3 && header[1].length < 150) {
+      const generic = /^(context|background|summary|notes|references|links|introduction)/i;
+      if (!generic.test(header[1])) {
+        items.push({ kind: "action", title: header[1] });
+        continue;
+      }
+    }
+    const checklist = trimmed.match(/^[-*]\s+\[[ x]\]\s+(.+)/);
+    if (checklist) {
+      items.push({ kind: "action", title: checklist[1] });
+      continue;
+    }
+    const fileMatch = trimmed.match(/`([a-zA-Z0-9_/.\\-]+\.[a-zA-Z]{1,10})`/g);
+    if (fileMatch) {
+      for (const m of fileMatch) {
+        const f = m.slice(1, -1);
+        if (f.includes("/") && !f.startsWith("v") && !f.includes(" ")) {
+          fileRefs.add(f);
+        }
+      }
+    }
+  }
+  if (fileRefs.size > 0 && items.length > 0) {
+    items[0].fileSpecs = Array.from(fileRefs).slice(0, 20).map((path) => ({
+      path,
+      action: "modify"
+    }));
+  }
+  let title = input.title ?? "";
+  if (!title) {
+    const h1 = lines.find((l) => l.startsWith("# "));
+    if (h1) {
+      title = h1.replace(/^#\s+/, "").trim();
+    } else {
+      const firstMeaningful = lines.find((l) => l.trim().length > 10);
+      title = firstMeaningful?.trim().slice(0, 80) ?? "Imported plan";
+    }
+  }
+  return {
+    title,
+    description: input.text,
+    items: items.slice(0, 50),
+    // cap at 50 items
+    source: "conversation"
+  };
+}
+function importFromGitDiff(input) {
+  const items = [];
+  const diffFilePattern = /^diff --git a\/(.+?) b\/(.+?)$/gm;
+  const files = [];
+  let match;
+  while ((match = diffFilePattern.exec(input.diff)) !== null) {
+    const filePath = match[2];
+    const afterDiff = input.diff.slice(match.index, match.index + 500);
+    const isNew = afterDiff.includes("new file mode");
+    const isDeleted = afterDiff.includes("deleted file mode");
+    files.push({
+      path: filePath,
+      action: isNew ? "create" : isDeleted ? "delete" : "modify"
+    });
+  }
+  const dirGroups = /* @__PURE__ */ new Map();
+  for (const f of files) {
+    const dir = f.path.includes("/") ? f.path.split("/").slice(0, -1).join("/") : "(root)";
+    if (!dirGroups.has(dir)) dirGroups.set(dir, []);
+    dirGroups.get(dir).push(f);
+  }
+  if (dirGroups.size <= 5) {
+    for (const [dir, dirFiles] of dirGroups) {
+      const actionLabel = dirFiles.length === 1 ? `${dirFiles[0].action} ${dirFiles[0].path.split("/").pop()}` : `Changes in ${dir}/ (${dirFiles.length} files)`;
+      items.push({
+        kind: "action",
+        title: actionLabel,
+        scopePath: dir === "(root)" ? void 0 : dir,
+        fileSpecs: dirFiles.map((f) => ({
+          path: f.path,
+          action: f.action
+        }))
+      });
+    }
+  } else {
+    for (const f of files.slice(0, 30)) {
+      items.push({
+        kind: "action",
+        title: `${f.action} ${f.path}`,
+        fileSpecs: [{ path: f.path, action: f.action }]
+      });
+    }
+  }
+  const created = files.filter((f) => f.action === "create").length;
+  const modified = files.filter((f) => f.action === "modify").length;
+  const deleted = files.filter((f) => f.action === "delete").length;
+  const stats = [
+    created ? `${created} new` : "",
+    modified ? `${modified} modified` : "",
+    deleted ? `${deleted} deleted` : ""
+  ].filter(Boolean).join(", ");
+  return {
+    title: input.title ?? `Changes from diff (${stats})`,
+    description: `Imported from git diff: ${files.length} files (${stats}).${input.baseBranch ? `
+
+Base: \`${input.baseBranch}\`` : ""}`,
+    items,
+    source: "git_diff",
+    metadata: {
+      fileCount: files.length,
+      baseBranch: input.baseBranch
+    }
+  };
+}
+function importFromClaudeSession(input) {
+  const lines = input.jsonl.split("\n").filter((l) => l.trim());
+  const items = [];
+  const touchedFiles = /* @__PURE__ */ new Set();
+  let firstMessage = "";
+  let lastSummary = "";
+  for (const line of lines) {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.type === "human" && !firstMessage) {
+        firstMessage = typeof entry.message === "string" ? entry.message : entry.message?.content?.[0]?.text ?? "";
+      }
+      if (entry.type === "summary" || entry.subtype === "summary") {
+        lastSummary = entry.summary ?? entry.message ?? "";
+      }
+      if (entry.type === "tool_use" || entry.type === "tool_call") {
+        const tool = entry.name ?? entry.tool ?? "";
+        const input_data = entry.input ?? entry.params ?? {};
+        if (tool === "Write" || tool === "Edit") {
+          const filePath = input_data.file_path ?? input_data.path ?? "";
+          if (filePath && !touchedFiles.has(filePath)) {
+            touchedFiles.add(filePath);
+            items.push({
+              kind: "action",
+              title: `${tool === "Write" ? "Create" : "Modify"} ${filePath.split("/").pop()}`,
+              fileSpecs: [{
+                path: filePath,
+                action: tool === "Write" ? "create" : "modify"
+              }]
+            });
+          }
+        }
+        if (tool === "Bash" || tool === "bash") {
+          const cmd = input_data.command ?? "";
+          const mkdirMatch = cmd.match(/mkdir\s+-?p?\s+(.+)/);
+          if (mkdirMatch) {
+            items.push({
+              kind: "action",
+              title: `Create directory ${mkdirMatch[1].trim()}`
+            });
+          }
+        }
+      }
+    } catch {
+    }
+  }
+  const title = input.title ?? firstMessage.slice(0, 100).split("\n")[0] ?? "Imported from Claude Code session";
+  const description = lastSummary || firstMessage || "Imported from a Claude Code session.";
+  return {
+    title,
+    description,
+    items: items.slice(0, 50),
+    source: "claude_session",
+    metadata: {
+      totalLines: lines.length,
+      filesModified: touchedFiles.size
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  importFromClaudeSession,
+  importFromConversation,
+  importFromGitDiff,
+  importFromGitHubIssue
+});