agent-trajectories 0.5.3 → 0.5.4

package/dist/cli/index.js

@@ -92,7 +92,7 @@ var DecisionSchema = z.object({
 });
 var AgentParticipationSchema = z.object({
   name: z.string().min(1, "Agent name is required"),
-  role: z.enum(["lead", "contributor", "reviewer"]),
+  role: z.string().min(1, "Agent role is required"),
   joinedAt: z.string().datetime(),
   leftAt: z.string().datetime().optional()
 });
@@ -152,7 +152,7 @@ var TrajectoryTraceRefSchema = z.object({
   traceId: z.string().optional()
 });
 var TrajectorySchema = z.object({
-  id: z.string().regex(/^traj_[a-z0-9]+$/, "Invalid trajectory ID format"),
+  id: z.string().regex(/^traj_[a-z0-9_]+$/, "Invalid trajectory ID format"),
   version: z.literal(1),
   task: TaskReferenceSchema,
   status: TrajectoryStatusSchema,
@@ -161,11 +161,11 @@ var TrajectorySchema = z.object({
   agents: z.array(AgentParticipationSchema),
   chapters: z.array(ChapterSchema),
   retrospective: RetrospectiveSchema.optional(),
-  commits: z.array(z.string()),
-  filesChanged: z.array(z.string()),
-  projectId: z.string(),
+  commits: z.array(z.string()).default([]),
+  filesChanged: z.array(z.string()).default([]),
+  projectId: z.string().optional(),
   workflowId: z.string().optional(),
-  tags: z.array(z.string()),
+  tags: z.array(z.string()).default([]),
   _trace: TrajectoryTraceRefSchema.optional()
 });
 var CreateTrajectoryInputSchema = z.object({
@@ -567,11 +567,11 @@ function extractDecisions(trajectory) {
 }
 
 // src/storage/file.ts
-function expandPath(path) {
-  if (path.startsWith("~")) {
-    return join(process.env.HOME ?? "", path.slice(1));
+function expandPath(path2) {
+  if (path2.startsWith("~")) {
+    return join(process.env.HOME ?? "", path2.slice(1));
   }
-  return path;
+  return path2;
 }
 function getSearchPaths() {
   const searchPathsEnv = process.env.TRAJECTORIES_SEARCH_PATHS;
@@ -616,11 +616,129 @@ var FileStorage = class {
         trajectories: {}
       });
     }
+    await this.reconcileIndex();
+  }
+  /**
+   * Scan active/ and completed/ recursively and add any trajectory files
+   * missing from the index. Existing entries are preserved — reconcile
+   * only adds, never removes.
+   *
+   * Handles three on-disk layouts in completed/:
+   *   - flat:      completed/{id}.json         (legacy workforce data)
+   *   - monthly:   completed/YYYY-MM/{id}.json (current save() writes)
+   *   - nested:    completed/.../{id}.json     (defensive — any depth)
+   *
+   * Returns a ReconcileSummary so tests and CLI wrappers can observe
+   * outcomes without parsing logs. Only writes the index if anything was
+   * added.
+   */
+  async reconcileIndex() {
+    const summary = {
+      scanned: 0,
+      added: 0,
+      alreadyIndexed: 0,
+      skippedMalformedJson: 0,
+      skippedSchemaViolation: 0,
+      skippedIoError: 0
+    };
+    const index = await this.loadIndex();
+    const before = Object.keys(index.trajectories).length;
+    const discovered = [];
+    try {
+      const activeFiles = await readdir(this.activeDir);
+      for (const file of activeFiles) {
+        if (!file.endsWith(".json")) continue;
+        discovered.push(join(this.activeDir, file));
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    await this.walkJsonFilesInto(this.completedDir, discovered);
+    for (const filePath of discovered) {
+      summary.scanned += 1;
+      const result = await this.readTrajectoryFile(filePath);
+      if (!result.ok) {
+        if (result.reason === "malformed_json") {
+          summary.skippedMalformedJson += 1;
+        } else if (result.reason === "schema_violation") {
+          summary.skippedSchemaViolation += 1;
+        } else {
+          summary.skippedIoError += 1;
+        }
+        continue;
+      }
+      const trajectory = result.trajectory;
+      if (index.trajectories[trajectory.id]) {
+        summary.alreadyIndexed += 1;
+        continue;
+      }
+      index.trajectories[trajectory.id] = {
+        title: trajectory.task.title,
+        status: trajectory.status,
+        startedAt: trajectory.startedAt,
+        completedAt: trajectory.completedAt,
+        path: filePath
+      };
+      summary.added += 1;
+    }
+    if (Object.keys(index.trajectories).length !== before) {
+      await this.saveIndex(index);
+    }
+    const hadSkips = summary.skippedMalformedJson + summary.skippedSchemaViolation + summary.skippedIoError > 0;
+    if (summary.added > 0 || hadSkips) {
+      const parts = [`reconciled ${summary.added}/${summary.scanned}`];
+      if (summary.skippedMalformedJson > 0) {
+        parts.push(`malformed: ${summary.skippedMalformedJson}`);
+      }
+      if (summary.skippedSchemaViolation > 0) {
+        parts.push(`invalid: ${summary.skippedSchemaViolation}`);
+      }
+      if (summary.skippedIoError > 0) {
+        parts.push(`io: ${summary.skippedIoError}`);
+      }
+      console.warn(`[trajectories] ${parts.join(", ")}`);
+    }
+    return summary;
+  }
+  /**
+   * Recursively collect all .json file paths under `dir` into `out`.
+   * Silently treats a missing directory as empty.
+   */
+  async walkJsonFilesInto(dir, out) {
+    let entries;
+    try {
+      entries = await readdir(dir, { withFileTypes: true });
+    } catch (error) {
+      if (error.code === "ENOENT") return;
+      throw error;
+    }
+    for (const entry of entries) {
+      const entryPath = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        await this.walkJsonFilesInto(entryPath, out);
+      } else if (entry.isFile() && entry.name.endsWith(".json")) {
+        out.push(entryPath);
+      }
+    }
   }
   /**
-   * Save a trajectory
+   * Save a trajectory.
+   *
+   * Validates the input against the trajectory schema before touching
+   * disk. Closes the historical read/write asymmetry where save() would
+   * happily write data that the reader then rejected, producing files
+   * that could never be loaded back.
    */
-  async save(trajectory) {
+  async save(input) {
+    const validation = validateTrajectory(input);
+    if (!validation.success) {
+      const issues = validation.errors?.issues.map((issue) => {
+        const path2 = issue.path.length > 0 ? issue.path.join(".") : "root";
+        return `${path2}: ${issue.message}`;
+      }).join("; ") ?? "unknown validation error";
+      throw new Error(`Cannot save invalid trajectory: ${issues}`);
+    }
+    const trajectory = validation.data;
     const isCompleted = trajectory.status === "completed" || trajectory.status === "abandoned";
     let filePath;
     if (isCompleted) {
@@ -650,19 +768,23 @@ var FileStorage = class {
   async get(id) {
     const activePath = join(this.activeDir, `${id}.json`);
     if (existsSync(activePath)) {
-      return this.readTrajectoryFile(activePath);
+      return this.readTrajectoryOrNull(activePath);
     }
     const index = await this.loadIndex();
     const entry = index.trajectories[id];
     if (entry?.path && existsSync(entry.path)) {
-      return this.readTrajectoryFile(entry.path);
+      return this.readTrajectoryOrNull(entry.path);
     }
     try {
+      const flatPath = join(this.completedDir, `${id}.json`);
+      if (existsSync(flatPath)) {
+        return this.readTrajectoryOrNull(flatPath);
+      }
       const months = await readdir(this.completedDir);
       for (const month of months) {
         const filePath = join(this.completedDir, month, `${id}.json`);
         if (existsSync(filePath)) {
-          return this.readTrajectoryFile(filePath);
+          return this.readTrajectoryOrNull(filePath);
         }
       }
     } catch (error) {
@@ -685,7 +807,7 @@ var FileStorage = class {
       let mostRecent = null;
       let mostRecentTime = 0;
       for (const file of jsonFiles) {
-        const trajectory = await this.readTrajectoryFile(
+        const trajectory = await this.readTrajectoryOrNull(
           join(this.activeDir, file)
         );
         if (trajectory) {
@@ -813,20 +935,44 @@ var FileStorage = class {
   async close() {
   }
   // Private helpers
-  async readTrajectoryFile(path) {
+  /**
+   * Read a trajectory file and return a tagged result so callers can
+   * distinguish missing files, malformed JSON, and schema violations.
+   *
+   * Does NOT log. Callers choose whether to warn, swallow, or throw.
+   */
+  async readTrajectoryFile(path2) {
+    let content;
     try {
-      const content = await readFile(path, "utf-8");
-      const data = JSON.parse(content);
-      const validation = validateTrajectory(data);
-      if (validation.success) {
-        return validation.data;
-      }
-      console.error(`Invalid trajectory at ${path}:`, validation.errors);
-      return null;
+      content = await readFile(path2, "utf-8");
     } catch (error) {
-      console.error(`Failed to read trajectory at ${path}:`, error);
-      return null;
+      return { ok: false, reason: "io_error", path: path2, error };
     }
+    let data;
+    try {
+      data = JSON.parse(content);
+    } catch (error) {
+      return { ok: false, reason: "malformed_json", path: path2, error };
+    }
+    const validation = validateTrajectory(data);
+    if (validation.success) {
+      return { ok: true, trajectory: validation.data };
+    }
+    return {
+      ok: false,
+      reason: "schema_violation",
+      path: path2,
+      error: validation.errors
+    };
+  }
+  /**
+   * Convenience wrapper for callers that only care whether they got a
+   * trajectory. Returns null for any failure and writes nothing to the
+   * console — so nothing leaks into test output or the CLI spinner.
+   */
+  async readTrajectoryOrNull(path2) {
+    const result = await this.readTrajectoryFile(path2);
+    return result.ok ? result.trajectory : null;
   }
   async loadIndex() {
     try {
@@ -1662,9 +1808,9 @@ async function resolveCLIProvider() {
     return SUPPORTED_CLIS;
   })();
   for (const cli of clisToTry) {
-    const path = await findBinary(cli);
-    if (path) {
-      return new CLIProvider(cli, path);
+    const path2 = await findBinary(cli);
+    if (path2) {
+      return new CLIProvider(cli, path2);
     }
   }
   return null;
@@ -1672,8 +1818,8 @@ async function resolveCLIProvider() {
 async function findBinary(name) {
   try {
     const { stdout } = await execFileAsync("which", [name]);
-    const path = stdout.trim();
-    if (path) return path;
+    const path2 = stdout.trim();
+    if (path2) return path2;
   } catch {
   }
   const home = homedir();
@@ -2775,8 +2921,8 @@ function generateTrace(trajectory, startRef) {
     return null;
   }
   const model = detectModel();
-  const traceFiles = changedFiles.map(({ path, ranges }) => ({
-    path,
+  const traceFiles = changedFiles.map(({ path: path2, ranges }) => ({
+    path: path2,
     conversations: [
       {
         contributor: {
@@ -2923,8 +3069,11 @@ if [ -z "$ACTIVE_FILE" ]; then
   exit 0
 fi
 
-# Extract trajectory ID (grep for the "id" field)
-TRAJ_ID=$(grep -o '"id"[[:space:]]*:[[:space:]]*"traj_[a-z0-9]*"' "$ACTIVE_FILE" | head -1 | grep -o 'traj_[a-z0-9]*')
+# Extract trajectory ID (grep for the "id" field). Character class must
+# include underscore to match legacy traj_<timestamp>_<hex> ids -- without
+# it, grep -o silently truncates at the first internal underscore and
+# emits a wrong (shorter) id into the commit trailer.
+TRAJ_ID=$(grep -o '"id"[[:space:]]*:[[:space:]]*"traj_[a-z0-9_]*"' "$ACTIVE_FILE" | head -1 | grep -o 'traj_[a-z0-9_]*')
 if [ -z "$TRAJ_ID" ]; then
   exit 0
 fi
@@ -3882,19 +4031,19 @@ function registerExportCommand(program2) {
     }
   });
 }
-function openInBrowser(path) {
+function openInBrowser(path2) {
   const platform = process.platform;
   let command;
   if (platform === "darwin") {
-    command = `open "${path}"`;
+    command = `open "${path2}"`;
   } else if (platform === "win32") {
-    command = `start "" "${path}"`;
+    command = `start "" "${path2}"`;
   } else {
-    command = `xdg-open "${path}"`;
+    command = `xdg-open "${path2}"`;
   }
   exec(command, (error) => {
     if (error) {
-      console.log(`Open manually: file://${path}`);
+      console.log(`Open manually: file://${path2}`);
     }
   });
 }
@@ -4399,8 +4548,37 @@ function registerCommands(program2) {
   registerCompactCommand(program2);
 }
 
+// src/cli/version.ts
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+function findPackageJson(startDir) {
+  let dir = startDir;
+  while (dir !== path.dirname(dir)) {
+    const candidate = path.join(dir, "package.json");
+    if (fs.existsSync(candidate)) {
+      return candidate;
+    }
+    dir = path.dirname(dir);
+  }
+  throw new Error("Could not find package.json");
+}
+function resolveCliVersion() {
+  try {
+    const here = path.dirname(fileURLToPath(import.meta.url));
+    const packageJsonPath = findPackageJson(here);
+    const packageJson = JSON.parse(
+      fs.readFileSync(packageJsonPath, "utf-8")
+    );
+    return packageJson.version ?? "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+var VERSION = resolveCliVersion();
+
 // src/cli/index.ts
-program.name("trail").description("Leave a trail of your work for others to follow").version("0.1.0").option(
+program.name("trail").description("Leave a trail of your work for others to follow").version(VERSION).option(
   "--data-dir <path>",
   "Override trajectory storage directory (or set TRAJECTORIES_DATA_DIR)"
 ).hook("preAction", (thisCommand) => {