codetrellis 0.0.0-stage → 0.3.0

package/src/backend/services/git-activity-service.js

@@ -0,0 +1,325 @@
+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 git_activity_service_exports = {};
+__export(git_activity_service_exports, {
+  getPlanCommitHistory: () => getPlanCommitHistory,
+  getPlanFilesAtCommit: () => getPlanFilesAtCommit,
+  getTeamActivity: () => getTeamActivity,
+  searchPlanHistory: () => searchPlanHistory
+});
+module.exports = __toCommonJS(git_activity_service_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_path = __toESM(require("node:path"));
+var import_plans_home = require("./plans-home");
+function getTeamActivity(opts) {
+  const { projectRoot, since, limit = 50 } = opts;
+  const maxCount = Math.min(limit * 3, 300);
+  const args = [
+    "log",
+    "--format=COMMIT%x1f%H%x1f%aI%x1f%aN%x1f%s%x1f%b%x1e",
+    "--diff-filter=ACDMR",
+    "--name-status",
+    `--max-count=${maxCount}`,
+    ...since ? [buildSinceArg(since)] : [],
+    "--",
+    ".codetrellis/"
+  ];
+  let raw;
+  try {
+    raw = runGitArgs(args, projectRoot);
+  } catch {
+    return [];
+  }
+  if (!raw.trim()) return [];
+  const entries = parseGitLog(raw);
+  return entries.slice(0, limit);
+}
+function getPlanFilesAtCommit(projectRoot, planSlug, commitHash) {
+  projectRoot = (0, import_plans_home.plansHome)(projectRoot) ?? projectRoot;
+  const planDir = `.codetrellis/plans/${planSlug}`;
+  const files = /* @__PURE__ */ new Map();
+  let listing;
+  try {
+    listing = runGitArgs(["ls-tree", "-r", "--name-only", commitHash, "--", planDir], projectRoot);
+  } catch {
+    return files;
+  }
+  for (const filePath of listing.trim().split("\n").filter(Boolean)) {
+    try {
+      const content = runGitArgs(["show", `${commitHash}:${filePath}`], projectRoot);
+      files.set(filePath, content);
+    } catch {
+    }
+  }
+  return files;
+}
+function getPlanCommitHistory(projectRoot, planSlug, options) {
+  projectRoot = (0, import_plans_home.plansHome)(projectRoot) ?? projectRoot;
+  const planDir = `.codetrellis/plans/${planSlug}`;
+  const maxCount = options?.limit ?? 30;
+  const args = [
+    "log",
+    "--format=%H%x1f%aI%x1f%aN%x1f%s%x1f%b%x1e",
+    `--max-count=${maxCount}`,
+    ...options?.since ? [buildSinceArg(options.since)] : [],
+    "--",
+    planDir
+  ];
+  let raw;
+  try {
+    raw = runGitArgs(args, projectRoot);
+  } catch {
+    return [];
+  }
+  if (!raw.trim()) return [];
+  const results = [];
+  for (const block of raw.split("").filter(Boolean)) {
+    const parts = block.trim().split("");
+    if (parts.length < 4) continue;
+    const [hash, timestamp, author, subject, body] = parts;
+    const agentAttribution = parseAgentAttribution(body ?? "");
+    results.push({ hash, timestamp, author, subject, agentAttribution });
+  }
+  return results;
+}
+function searchPlanHistory(projectRoot, planSlug, query, options) {
+  projectRoot = (0, import_plans_home.plansHome)(projectRoot) ?? projectRoot;
+  const planDir = `.codetrellis/plans/${planSlug}`;
+  const maxCount = options?.limit ?? 20;
+  const args = [
+    "log",
+    // The separator STARTS each record. At the end, --name-only's file list
+    // (which follows the header) fell into the NEXT record: matchedFiles was
+    // always empty, and every match after the first was dropped because its
+    // record began with the previous commit's files (Phase 32 §0.4h).
+    "--format=%x1e%H%x1f%aI%x1f%aN%x1f%s",
+    "--name-only",
+    `-G${escapeRegex(query)}`,
+    "-i",
+    // case-insensitive
+    `--max-count=${maxCount}`,
+    ...options?.since ? [buildSinceArg(options.since)] : [],
+    ...options?.until ? [buildUntilArg(options.until)] : [],
+    "--",
+    planDir
+  ];
+  let raw;
+  try {
+    raw = runGitArgs(args, projectRoot);
+  } catch {
+    return [];
+  }
+  if (!raw.trim()) return [];
+  const results = [];
+  for (const block of raw.split("").filter(Boolean)) {
+    const lines = block.trim().split("\n");
+    if (lines.length === 0) continue;
+    const headerParts = lines[0].split("");
+    if (headerParts.length < 4) continue;
+    const [hash, timestamp, author, subject] = headerParts;
+    const matchedFiles = lines.slice(1).filter((l) => l.trim() && l.includes(".codetrellis/"));
+    results.push({ hash, timestamp, author, subject, matchedFiles });
+  }
+  return results;
+}
+function runGitArgs(args, cwd) {
+  return (0, import_node_child_process.execFileSync)("git", args, {
+    cwd,
+    encoding: "utf-8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 15e3
+  });
+}
+function buildSinceArg(since) {
+  const val = typeof since === "number" ? new Date(since).toISOString() : since;
+  return `--since=${val}`;
+}
+function buildUntilArg(until) {
+  const val = typeof until === "number" ? new Date(until).toISOString() : until;
+  return `--until=${val}`;
+}
+function escapeRegex(str) {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function parseAgentAttribution(body) {
+  const match = body.match(/^agent:\s*(\S+)(?:\s*·\s*model:\s*(.+))?$/m);
+  if (!match) return null;
+  return {
+    agentType: match[1],
+    model: match[2]?.trim() || void 0
+  };
+}
+function parseGitLog(raw) {
+  const entries = [];
+  const blocks = raw.split("COMMIT").filter((b) => b.trim());
+  for (const block of blocks) {
+    const rsSplit = block.split("");
+    const headerStr = rsSplit[0] ?? "";
+    const nameStatusStr = rsSplit.slice(1).join("");
+    const headerParts = headerStr.split("");
+    if (headerParts.length < 4) continue;
+    const [commitHash, timestamp, author, subject, ...bodyParts] = headerParts;
+    const body = bodyParts.join("");
+    const agentAttribution = parseAgentAttribution(body);
+    const nameStatusLines = nameStatusStr.split("\n");
+    for (const line of nameStatusLines) {
+      const trimmed = line.trim();
+      if (!trimmed) continue;
+      const tabParts = trimmed.split("	");
+      if (tabParts.length < 2) continue;
+      const status = tabParts[0];
+      const filePath = tabParts[tabParts.length - 1];
+      const entry = classifyChange(status, filePath, commitHash, timestamp, author, subject, agentAttribution);
+      if (entry) entries.push(entry);
+    }
+  }
+  return entries;
+}
+function classifyChange(status, filePath, commitHash, timestamp, author, subject, agentAttribution) {
+  const rel = filePath.startsWith(".codetrellis/") ? filePath.slice(".codetrellis/".length) : filePath;
+  const action = statusToAction(status);
+  const planMatch = rel.match(/^plans\/([^/]+)\/plan\.yaml$/);
+  if (planMatch) {
+    return {
+      timestamp,
+      author,
+      agentAttribution: agentAttribution ?? null,
+      action,
+      entityType: "plan",
+      entityTitle: planSlugToTitle(planMatch[1]),
+      planSlug: planMatch[1],
+      commitHash,
+      commitSubject: subject
+    };
+  }
+  const itemMatch = rel.match(/^plans\/([^/]+)\/items\/(.+)\.yaml$/);
+  if (itemMatch) {
+    const fileName = import_node_path.default.basename(itemMatch[2]);
+    const title = fileName === "_self" ? "(parent item)" : slugToTitle(fileName.replace(/^\d+-/, ""));
+    return {
+      timestamp,
+      author,
+      agentAttribution: agentAttribution ?? null,
+      action,
+      entityType: "item",
+      entityTitle: title,
+      planSlug: itemMatch[1],
+      commitHash,
+      commitSubject: subject
+    };
+  }
+  const channelMatch = rel.match(/^plans\/([^/]+)\/channels\/(.+)\.yaml$/);
+  if (channelMatch) {
+    return {
+      timestamp,
+      author,
+      agentAttribution: agentAttribution ?? null,
+      action,
+      entityType: "channel-event",
+      entityTitle: "Channel event",
+      planSlug: channelMatch[1],
+      commitHash,
+      commitSubject: subject
+    };
+  }
+  const docMatch = rel.match(/^docs\/(.+)\.md$/);
+  if (docMatch) {
+    return {
+      timestamp,
+      author,
+      agentAttribution: agentAttribution ?? null,
+      action,
+      entityType: "system-doc",
+      entityTitle: slugToTitle(docMatch[1]),
+      planSlug: null,
+      commitHash,
+      commitSubject: subject
+    };
+  }
+  if (rel === "config.json") {
+    return {
+      timestamp,
+      author,
+      agentAttribution: agentAttribution ?? null,
+      action,
+      entityType: "config",
+      entityTitle: "Project configuration",
+      planSlug: null,
+      commitHash,
+      commitSubject: subject
+    };
+  }
+  const legacyMatch = rel.match(/^plans\/([^/]+)\/(phases|tasks|docs)\/(.+)$/);
+  if (legacyMatch) {
+    const title = slugToTitle(import_node_path.default.basename(legacyMatch[3], import_node_path.default.extname(legacyMatch[3])));
+    return {
+      timestamp,
+      author,
+      agentAttribution: agentAttribution ?? null,
+      action,
+      entityType: "item",
+      entityTitle: title,
+      planSlug: legacyMatch[1],
+      commitHash,
+      commitSubject: subject
+    };
+  }
+  return null;
+}
+function statusToAction(gitStatus) {
+  const code = gitStatus.charAt(0);
+  switch (code) {
+    case "A":
+      return "created";
+    case "D":
+      return "deleted";
+    case "M":
+      return "updated";
+    case "C":
+      return "created";
+    case "R":
+      return "updated";
+    // rename treated as update
+    default:
+      return "updated";
+  }
+}
+function slugToTitle(slug) {
+  return slug.replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase()).trim();
+}
+function planSlugToTitle(planSlug) {
+  const stripped = planSlug.replace(/-[0-9a-f]{8}$/, "");
+  return slugToTitle(stripped);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPlanCommitHistory,
+  getPlanFilesAtCommit,
+  getTeamActivity,
+  searchPlanHistory
+});

package/src/backend/services/git-blobs.js

@@ -0,0 +1,70 @@
+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 git_blobs_exports = {};
+__export(git_blobs_exports, {
+  readBlobsAtCommit: () => readBlobsAtCommit
+});
+module.exports = __toCommonJS(git_blobs_exports);
+var import_node_child_process = require("node:child_process");
+var import_git_safety = require("./git-safety");
+function readBlobsAtCommit(root, commit, paths) {
+  const wanted = paths.filter((p) => !p.includes("\n"));
+  if (!(0, import_git_safety.isSafeGitRef)(commit)) return Promise.reject(new Error(`"${String(commit).slice(0, 80)}" is not a commit`));
+  if (wanted.length === 0) return Promise.resolve(/* @__PURE__ */ new Map());
+  return new Promise((resolve, reject) => {
+    const git = (0, import_node_child_process.spawn)("git", ["-C", root, "cat-file", "--batch"], { stdio: ["pipe", "pipe", "pipe"] });
+    const chunks = [];
+    let stderr = "";
+    git.stdout.on("data", (c) => chunks.push(c));
+    git.stderr.on("data", (c) => {
+      stderr += c.toString("utf8");
+    });
+    git.on("error", reject);
+    git.on("close", (code) => {
+      if (code !== 0) {
+        reject(new Error(`git cat-file exited ${code}: ${stderr.trim().slice(0, 200)}`));
+        return;
+      }
+      resolve(parseBatch(Buffer.concat(chunks), wanted));
+    });
+    git.stdin.on("error", () => {
+    });
+    git.stdin.end(wanted.map((p) => `${commit}:${p}
+`).join(""));
+  });
+}
+function parseBatch(out, wanted) {
+  const files = /* @__PURE__ */ new Map();
+  let at = 0;
+  for (const p of wanted) {
+    const eol = out.indexOf(10, at);
+    if (eol < 0) break;
+    const header = out.toString("utf8", at, eol);
+    at = eol + 1;
+    const m = /^[0-9a-f]+ (\w+) (\d+)$/.exec(header);
+    if (!m) continue;
+    const size = Number(m[2]);
+    if (m[1] === "blob") files.set(p, out.toString("utf8", at, at + size));
+    at += size + 1;
+  }
+  return files;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  readBlobsAtCommit
+});