agent-trajectories 0.2.3 → 0.3.1

package/dist/cli/index.js

@@ -9,8 +9,9 @@ import {
   exportToJSON,
   exportToMarkdown,
   exportToTimeline,
+  generateRandomId,
   getSearchPaths
-} from "../chunk-2NBMLFIW.js";
+} from "../chunk-DX4OPGH7.js";
 
 // src/cli/index.ts
 import { program } from "commander";
@@ -35,6 +36,184 @@ function registerAbandonCommand(program2) {
 }
 
 // src/cli/commands/complete.ts
+import { existsSync } from "fs";
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+
+// src/core/trace.ts
+import { execSync } from "child_process";
+import { createHash } from "crypto";
+function isValidGitRef(ref) {
+  const validRefPattern = /^[a-zA-Z0-9_\-./]+$/;
+  const commitHashPattern = /^[a-fA-F0-9]{7,40}$/;
+  if (ref === "HEAD" || ref === "working") {
+    return true;
+  }
+  if (commitHashPattern.test(ref)) {
+    return true;
+  }
+  if (validRefPattern.test(ref) && ref.length <= 255) {
+    if (!ref.includes("..") || ref.split("..").every((p) => p.length > 0)) {
+      return true;
+    }
+  }
+  return false;
+}
+function isGitRepo() {
+  try {
+    execSync("git rev-parse --is-inside-work-tree", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function getGitHead() {
+  if (!isGitRepo()) {
+    return null;
+  }
+  try {
+    const head = execSync("git rev-parse HEAD", {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+    return head;
+  } catch {
+    return null;
+  }
+}
+function captureGitState() {
+  return getGitHead();
+}
+function parseDiffOutput(diffOutput) {
+  const files = [];
+  const lines = diffOutput.split("\n");
+  let currentFile = null;
+  let currentRanges = [];
+  for (const line of lines) {
+    const diffHeaderMatch = line.match(/^diff --git a\/.+ b\/(.+)$/);
+    if (diffHeaderMatch) {
+      if (currentFile) {
+        files.push({ path: currentFile, ranges: currentRanges });
+      }
+      currentFile = diffHeaderMatch[1];
+      currentRanges = [];
+      continue;
+    }
+    const hunkMatch = line.match(/^@@ -\d+(?:,\d+)? \+(\d+)(?:,(\d+))? @@/);
+    if (hunkMatch && currentFile) {
+      const startLine = Number.parseInt(hunkMatch[1], 10);
+      const lineCount = hunkMatch[2] ? Number.parseInt(hunkMatch[2], 10) : 1;
+      if (lineCount > 0) {
+        currentRanges.push({
+          start_line: startLine,
+          end_line: startLine + lineCount - 1
+        });
+      }
+    }
+  }
+  if (currentFile) {
+    files.push({ path: currentFile, ranges: currentRanges });
+  }
+  return files;
+}
+function getChangedFiles(startRef, endRef = "HEAD") {
+  if (!isGitRepo()) {
+    return [];
+  }
+  if (!isValidGitRef(startRef) || !isValidGitRef(endRef)) {
+    return [];
+  }
+  try {
+    const diffOutput = execSync(`git diff ${startRef}..${endRef}`, {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB buffer for large diffs
+    });
+    return parseDiffOutput(diffOutput);
+  } catch {
+    return [];
+  }
+}
+function detectModel() {
+  if (process.env.TRAIL_TRACE_MODEL) {
+    return process.env.TRAIL_TRACE_MODEL;
+  }
+  if (process.env.ANTHROPIC_MODEL) {
+    return process.env.ANTHROPIC_MODEL;
+  }
+  if (process.env.OPENAI_MODEL) {
+    return process.env.OPENAI_MODEL;
+  }
+  return "unknown";
+}
+function generateTraceId() {
+  return `trace_${generateRandomId()}`;
+}
+function generateTrace(trajectory, startRef) {
+  if (!isGitRepo()) {
+    return null;
+  }
+  const endRef = getGitHead();
+  if (!endRef) {
+    return null;
+  }
+  const changedFiles = getChangedFiles(startRef, endRef);
+  if (changedFiles.length === 0) {
+    return null;
+  }
+  const model = detectModel();
+  const traceFiles = changedFiles.map(({ path, ranges }) => ({
+    path,
+    conversations: [
+      {
+        contributor: {
+          type: "agent",
+          model
+        },
+        ranges: ranges.map((range) => ({
+          ...range,
+          revision: endRef
+        }))
+      }
+    ]
+  }));
+  return {
+    version: 1,
+    id: generateTraceId(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    trajectory: trajectory.id,
+    files: traceFiles
+  };
+}
+function createTraceRef(startRef, traceId) {
+  const endRef = getGitHead();
+  return {
+    startRef,
+    endRef: endRef ?? void 0,
+    traceId
+  };
+}
+
+// src/cli/commands/complete.ts
+async function saveTraceFile(trajectory, trace) {
+  const dataDir = process.env.TRAJECTORIES_DATA_DIR;
+  const baseDir = dataDir ? dataDir : join(process.cwd(), ".trajectories");
+  const completedDir = join(baseDir, "completed");
+  const date = new Date(trajectory.completedAt ?? trajectory.startedAt);
+  const monthDir = join(
+    completedDir,
+    `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}`
+  );
+  if (!existsSync(monthDir)) {
+    await mkdir(monthDir, { recursive: true });
+  }
+  const tracePath = join(monthDir, `${trajectory.id}.trace.json`);
+  await writeFile(tracePath, JSON.stringify(trace, null, 2), "utf-8");
+}
 function registerCompleteCommand(program2) {
   program2.command("complete").description("Complete the active trajectory with retrospective").option("--summary <text>", "Summary of what was accomplished").option("--approach <text>", "How the work was approached").option("--confidence <number>", "Confidence level 0-1", Number.parseFloat).action(async (options) => {
     const storage = new FileStorage();
@@ -54,15 +233,37 @@ function registerCompleteCommand(program2) {
       console.error("Error: --confidence must be between 0 and 1");
       throw new Error("Invalid confidence");
     }
-    const completed = completeTrajectory(active, {
+    let completed = completeTrajectory(active, {
       summary: options.summary,
       approach: options.approach || "Standard approach",
       confidence
     });
+    let trace = null;
+    if (active._trace?.startRef) {
+      trace = generateTrace(completed, active._trace.startRef);
+      if (trace) {
+        const endRef = getGitHead();
+        completed = {
+          ...completed,
+          _trace: {
+            ...completed._trace,
+            startRef: active._trace.startRef,
+            endRef: endRef ?? void 0,
+            traceId: trace.id
+          }
+        };
+      }
+    }
     await storage.save(completed);
+    if (trace) {
+      await saveTraceFile(completed, trace);
+    }
     console.log(`\u2713 Trajectory completed: ${completed.id}`);
     console.log(`  Summary: ${options.summary}`);
     console.log(`  Confidence: ${Math.round(confidence * 100)}%`);
+    if (trace) {
+      console.log(`  Trace: ${trace.id} (${trace.files.length} files)`);
+    }
   });
 }
 
@@ -83,7 +284,7 @@ function registerDecisionCommand(program2) {
       console.error('Start one with: trail start "Task description"');
       throw new Error("No active trajectory");
     }
-    const alternatives = options.alternatives ? options.alternatives.split(",").map((s) => s.trim()) : [];
+    const alternatives = options.alternatives ? options.alternatives.split(",").map((s) => ({ option: s.trim(), reason: "" })) : [];
     const reasoning = options.reasoning || "";
     const updated = addDecision(active, {
       question: choice,
@@ -97,15 +298,18 @@ function registerDecisionCommand(program2) {
       console.log(`  Reasoning: ${reasoning}`);
     }
     if (alternatives.length > 0) {
-      console.log(`  Alternatives: ${alternatives.join(", ")}`);
+      const altStrings = alternatives.map(
+        (a) => a.option
+      );
+      console.log(`  Alternatives: ${altStrings.join(", ")}`);
     }
   });
 }
 
 // src/cli/commands/export.ts
 import { exec } from "child_process";
-import { mkdir, writeFile } from "fs/promises";
-import { join } from "path";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
+import { join as join2 } from "path";
 
 // src/web/styles.ts
 var styles = `
@@ -502,7 +706,7 @@ function getStatusClass(status) {
 function renderDecision(decision) {
   const alternatives = decision.alternatives?.length ? `<div class="alternatives">
         <span class="alternatives-label">Considered:</span>
-        ${decision.alternatives.map((a) => escapeHtml(a)).join(", ")}
+        ${decision.alternatives.map((a) => escapeHtml(typeof a === "string" ? a : a.option)).join(", ")}
        </div>` : "";
   return `
     <div class="decision">
@@ -741,16 +945,16 @@ function registerExportCommand(program2) {
         break;
     }
     if (options.output) {
-      await writeFile(options.output, output, "utf-8");
+      await writeFile2(options.output, output, "utf-8");
       console.log(`\u2713 Exported to ${options.output}`);
       if (options.open && options.format === "html") {
         openInBrowser(options.output);
       }
     } else if (options.open && options.format === "html") {
-      const outputDir = join(process.cwd(), ".trajectories", "html");
-      await mkdir(outputDir, { recursive: true });
-      const filePath = join(outputDir, `${trajectory.id}.html`);
-      await writeFile(filePath, output, "utf-8");
+      const outputDir = join2(process.cwd(), ".trajectories", "html");
+      await mkdir2(outputDir, { recursive: true });
+      const filePath = join2(outputDir, `${trajectory.id}.html`);
+      await writeFile2(filePath, output, "utf-8");
       console.log(`\u2713 Generated: ${filePath}`);
       openInBrowser(filePath);
     } else {
@@ -776,7 +980,7 @@ function openInBrowser(path) {
 }
 
 // src/cli/commands/list.ts
-import { existsSync } from "fs";
+import { existsSync as existsSync2 } from "fs";
 function registerListCommand(program2) {
   program2.command("list").description("List and search trajectories").option(
     "-s, --status <status>",
@@ -786,7 +990,7 @@ function registerListCommand(program2) {
     let allTrajectories = [];
     const seenIds = /* @__PURE__ */ new Set();
     for (const searchPath of searchPaths) {
-      if (!existsSync(searchPath)) {
+      if (!existsSync2(searchPath)) {
         continue;
       }
       const originalDataDir = process.env.TRAJECTORIES_DATA_DIR;
@@ -874,11 +1078,13 @@ function formatDate2(isoString) {
 }
 
 // src/cli/commands/show.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync as existsSync3 } from "fs";
+import { readFile } from "fs/promises";
+import { join as join3 } from "path";
 async function findTrajectory(id) {
   const searchPaths = getSearchPaths();
   for (const searchPath of searchPaths) {
-    if (!existsSync2(searchPath)) {
+    if (!existsSync3(searchPath)) {
       continue;
     }
     const originalDataDir = process.env.TRAJECTORIES_DATA_DIR;
@@ -900,13 +1106,79 @@ async function findTrajectory(id) {
   }
   return null;
 }
+async function findTraceFile(id) {
+  const searchPaths = getSearchPaths();
+  for (const searchPath of searchPaths) {
+    if (!existsSync3(searchPath)) {
+      continue;
+    }
+    const completedDir = join3(searchPath, "completed");
+    if (!existsSync3(completedDir)) {
+      continue;
+    }
+    try {
+      const { readdirSync } = await import("fs");
+      const months = readdirSync(completedDir);
+      for (const month of months) {
+        const tracePath = join3(completedDir, month, `${id}.trace.json`);
+        if (existsSync3(tracePath)) {
+          const content = await readFile(tracePath, "utf-8");
+          return JSON.parse(content);
+        }
+      }
+    } catch {
+    }
+  }
+  return null;
+}
 function registerShowCommand(program2) {
-  program2.command("show <id>").description("Show trajectory details").option("-d, --decisions", "Show decisions only").action(async (id, options) => {
+  program2.command("show <id>").description("Show trajectory details").option("-d, --decisions", "Show decisions only").option("-t, --trace", "Show trace information").action(async (id, options) => {
     const trajectory = await findTrajectory(id);
     if (!trajectory) {
       console.error(`Error: Trajectory not found: ${id}`);
       throw new Error("Trajectory not found");
     }
+    if (options.trace) {
+      console.log(`Trace for ${trajectory.task.title}:
+`);
+      if (trajectory._trace) {
+        console.log("Trace Reference:");
+        console.log(`  Start Ref: ${trajectory._trace.startRef}`);
+        if (trajectory._trace.endRef) {
+          console.log(`  End Ref:   ${trajectory._trace.endRef}`);
+        }
+        if (trajectory._trace.traceId) {
+          console.log(`  Trace ID:  ${trajectory._trace.traceId}`);
+        }
+        console.log("");
+      }
+      const trace = await findTraceFile(id);
+      if (trace) {
+        console.log("Trace Details:");
+        console.log(`  ID:        ${trace.id}`);
+        console.log(`  Timestamp: ${trace.timestamp}`);
+        console.log(`  Files:     ${trace.files.length}`);
+        console.log("");
+        if (trace.files.length > 0) {
+          console.log("Modified Files:");
+          for (const file of trace.files) {
+            const rangeCount = file.conversations.reduce(
+              (sum, conv) => sum + conv.ranges.length,
+              0
+            );
+            const model = file.conversations[0]?.contributor.model ?? "unknown";
+            console.log(`  \u2022 ${file.path}`);
+            console.log(`    Ranges: ${rangeCount}, Model: ${model}`);
+          }
+        }
+      } else if (!trajectory._trace) {
+        console.log("No trace information available");
+        console.log(
+          "Trace is captured when starting a trajectory in a git repo"
+        );
+      }
+      return;
+    }
     if (options.decisions) {
       const decisions = extractDecisions(trajectory);
       if (decisions.length === 0) {
@@ -920,7 +1192,10 @@ function registerShowCommand(program2) {
         console.log(`  Chose: ${decision.chosen}`);
         console.log(`  Reasoning: ${decision.reasoning}`);
         if (decision.alternatives.length > 0) {
-          console.log(`  Alternatives: ${decision.alternatives.join(", ")}`);
+          const altStrings = decision.alternatives.map(
+            (a) => typeof a === "string" ? a : a.option
+          );
+          console.log(`  Alternatives: ${altStrings.join(", ")}`);
         }
         console.log("");
       }
@@ -1002,11 +1277,18 @@ function registerStartCommand(program2) {
     }
     const agentName = options.agent ?? process.env.TRAJECTORIES_AGENT ?? void 0;
     const projectId = options.project ?? process.env.TRAJECTORIES_PROJECT ?? void 0;
+    const startRef = captureGitState();
     let trajectory = createTrajectory({
       title,
       source,
       projectId
     });
+    if (startRef) {
+      trajectory = {
+        ...trajectory,
+        _trace: createTraceRef(startRef)
+      };
+    }
     if (agentName) {
       trajectory = addChapter(trajectory, {
         title: "Initial work",