agent-trajectories 0.5.6 → 0.5.8

package/dist/{chunk-2XT3DOJC.js → chunk-WMJRBQB4.js}

@@ -2,7 +2,7 @@
 import { spawn } from "child_process";
 import { existsSync as existsSync2, readFileSync } from "fs";
 import { createRequire } from "module";
-import { dirname, resolve as resolvePath } from "path";
+import { dirname as dirname2, resolve as resolvePath } from "path";
 
 // src/core/id.ts
 import { webcrypto } from "crypto";
@@ -666,21 +666,54 @@ function formatTime(isoString) {
 }
 
 // src/storage/file.ts
+import { randomUUID } from "crypto";
 import { existsSync } from "fs";
-import { mkdir, readFile, readdir, unlink, writeFile } from "fs/promises";
-import { join } from "path";
+import {
+  mkdir,
+  readFile,
+  readdir,
+  rename,
+  unlink,
+  writeFile
+} from "fs/promises";
+import { basename, dirname, isAbsolute, join, relative } from "path";
 function expandPath(path) {
   if (path.startsWith("~")) {
     return join(process.env.HOME ?? "", path.slice(1));
   }
   return path;
 }
+function describeReadFailure(reason, error) {
+  if (reason === "schema_violation" && error && typeof error === "object" && "issues" in error) {
+    const issues = error.issues ?? [];
+    if (issues.length > 0) {
+      const first = issues[0];
+      const where = first.path.length > 0 ? first.path.join(".") : "root";
+      const extra = issues.length > 1 ? ` (+${issues.length - 1} more)` : "";
+      return `${where}: ${first.message}${extra}`;
+    }
+    return "schema validation failed";
+  }
+  if (error instanceof Error) return error.message;
+  return String(error);
+}
+var indexLocks = /* @__PURE__ */ new Map();
+function withIndexLock(path, task) {
+  const prev = indexLocks.get(path) ?? Promise.resolve();
+  const next = prev.then(task, task);
+  indexLocks.set(
+    path,
+    next.catch(() => void 0)
+  );
+  return next;
+}
 var FileStorage = class {
   baseDir;
   trajectoriesDir;
   activeDir;
   completedDir;
   indexPath;
+  lastReconcileSummary;
   constructor(baseDir) {
     this.baseDir = baseDir ?? process.cwd();
     const dataDir = process.env.TRAJECTORIES_DATA_DIR;
@@ -701,10 +734,10 @@ var FileStorage = class {
     await mkdir(this.activeDir, { recursive: true });
     await mkdir(this.completedDir, { recursive: true });
     if (!existsSync(this.indexPath)) {
-      await this.saveIndex({
-        version: 1,
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-        trajectories: {}
+      await withIndexLock(this.indexPath, async () => {
+        if (!existsSync(this.indexPath)) {
+          await this.saveIndex(this.emptyIndex());
+        }
       });
     }
     await this.reconcileIndex();
@@ -730,51 +763,59 @@ var FileStorage = class {
       alreadyIndexed: 0,
       skippedMalformedJson: 0,
       skippedSchemaViolation: 0,
-      skippedIoError: 0
+      skippedIoError: 0,
+      failures: []
     };
-    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));
+    await withIndexLock(this.indexPath, async () => {
+      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;
       }
-    } 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;
+      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;
+          }
+          summary.failures.push({
+            path: result.path,
+            reason: result.reason,
+            message: describeReadFailure(result.reason, result.error)
+          });
+          continue;
         }
-        continue;
+        const trajectory2 = result.trajectory;
+        if (index.trajectories[trajectory2.id]) {
+          summary.alreadyIndexed += 1;
+          continue;
+        }
+        index.trajectories[trajectory2.id] = {
+          title: trajectory2.task.title,
+          status: trajectory2.status,
+          startedAt: trajectory2.startedAt,
+          completedAt: trajectory2.completedAt,
+          path: filePath
+        };
+        summary.added += 1;
       }
-      const trajectory2 = result.trajectory;
-      if (index.trajectories[trajectory2.id]) {
-        summary.alreadyIndexed += 1;
-        continue;
+      if (Object.keys(index.trajectories).length !== before) {
+        await this.saveIndex(index);
       }
-      index.trajectories[trajectory2.id] = {
-        title: trajectory2.task.title,
-        status: trajectory2.status,
-        startedAt: trajectory2.startedAt,
-        completedAt: trajectory2.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}`];
@@ -789,8 +830,74 @@ var FileStorage = class {
       }
       console.warn(`[trajectories] ${parts.join(", ")}`);
     }
+    this.lastReconcileSummary = summary;
     return summary;
   }
+  /**
+   * Returns the most recent reconcile summary, if any. Lets the CLI
+   * inspect the failures collected during `initialize()` without having
+   * to re-walk the directory tree (and re-emit the warn line).
+   */
+  getLastReconcileSummary() {
+    return this.lastReconcileSummary;
+  }
+  /**
+   * Move trajectory files that fail to load into `.trajectories/invalid/`
+   * so reconcile no longer scans them. Only quarantines parse and schema
+   * failures — transient io_error failures are left in place because the
+   * file may load fine on the next attempt.
+   *
+   * Returns the list of files that were moved (with their original paths
+   * and the destination directory) so the caller can report what changed.
+   */
+  async quarantineInvalid() {
+    const summary = await this.reconcileIndex();
+    const targetDir = join(this.trajectoriesDir, "invalid");
+    const candidates = summary.failures.filter((f) => f.reason !== "io_error");
+    if (candidates.length === 0) {
+      return { moved: [], targetDir };
+    }
+    await mkdir(targetDir, { recursive: true });
+    const moved = [];
+    for (const failure of candidates) {
+      const dest = await this.resolveQuarantineDest(failure.path, targetDir);
+      try {
+        await mkdir(dirname(dest), { recursive: true });
+        await rename(failure.path, dest);
+        moved.push(failure);
+      } catch (error) {
+        console.warn(
+          `[trajectories] failed to quarantine ${failure.path}: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    return { moved, targetDir };
+  }
+  /**
+   * Pick a destination path under `targetDir` for a quarantined file.
+   *
+   * Preserves the file's relative location under the trajectories root
+   * (e.g. `completed/2026-04/foo.json` → `invalid/completed/2026-04/foo.json`)
+   * so two invalid files that share a basename across `active/` and
+   * `completed/` don't collapse onto each other and silently overwrite.
+   *
+   * Falls back to a numeric-suffix scheme for paths that live outside
+   * the trajectories directory or that, after relative resolution, would
+   * still collide with something already quarantined.
+   */
+  async resolveQuarantineDest(sourcePath, targetDir) {
+    const rel = relative(this.trajectoriesDir, sourcePath);
+    const safeRel = rel && !rel.startsWith("..") && !isAbsolute(rel) ? rel : basename(sourcePath);
+    let dest = join(targetDir, safeRel);
+    if (!existsSync(dest)) return dest;
+    const ext = safeRel.endsWith(".json") ? ".json" : "";
+    const stem = ext ? safeRel.slice(0, -ext.length) : safeRel;
+    for (let i = 1; i < 1e3; i += 1) {
+      dest = join(targetDir, `${stem}.${i}${ext}`);
+      if (!existsSync(dest)) return dest;
+    }
+    return dest;
+  }
   /**
    * Recursively collect all .json file paths under `dir` into `out`.
    * Silently treats a missing directory as empty.
@@ -977,17 +1084,19 @@ var FileStorage = class {
     if (existsSync(activePath)) {
       await unlink(activePath);
     }
-    const index = await this.loadIndex();
-    const entry = index.trajectories[id];
-    if (entry?.path && existsSync(entry.path)) {
-      await unlink(entry.path);
-      const mdPath = entry.path.replace(".json", ".md");
-      if (existsSync(mdPath)) {
-        await unlink(mdPath);
+    await withIndexLock(this.indexPath, async () => {
+      const index = await this.loadIndex();
+      const entry = index.trajectories[id];
+      if (entry?.path && existsSync(entry.path)) {
+        await unlink(entry.path);
+        const mdPath = entry.path.replace(".json", ".md");
+        if (existsSync(mdPath)) {
+          await unlink(mdPath);
+        }
       }
-    }
-    delete index.trajectories[id];
-    await this.saveIndex(index);
+      delete index.trajectories[id];
+      await this.saveIndex(index);
+    });
   }
   /**
    * Search trajectories by text
@@ -1065,10 +1174,23 @@ var FileStorage = class {
     const result = await this.readTrajectoryFile(path);
     return result.ok ? result.trajectory : null;
   }
+  /**
+   * Read and parse the on-disk index.
+   *
+   * Tolerances (belt-and-braces against the read/write race):
+   *   - ENOENT: first-run, return an empty index silently.
+   *   - Empty file: a concurrent writer truncated index.json in "w" mode
+   *     right before we read. Return an empty index silently — this is
+   *     not a real corruption, just an interleaving the mutex + atomic
+   *     rename should already prevent. Logging here would be noise.
+   *   - Non-empty but malformed JSON: genuinely corrupted on disk (hand
+   *     edit, disk error, etc). Log it and return an empty index so the
+   *     caller can recover, but keep the log so the problem is visible.
+   */
   async loadIndex() {
+    let content;
     try {
-      const content = await readFile(this.indexPath, "utf-8");
-      return JSON.parse(content);
+      content = await readFile(this.indexPath, "utf-8");
     } catch (error) {
       if (error.code !== "ENOENT") {
         console.error(
@@ -1076,27 +1198,56 @@ var FileStorage = class {
           error
         );
       }
-      return {
-        version: 1,
-        lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
-        trajectories: {}
-      };
+      return this.emptyIndex();
+    }
+    if (content.length === 0) {
+      return this.emptyIndex();
     }
+    try {
+      return JSON.parse(content);
+    } catch (error) {
+      console.error(
+        "Error loading trajectory index, using empty index:",
+        error
+      );
+      return this.emptyIndex();
+    }
+  }
+  emptyIndex() {
+    return {
+      version: 1,
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      trajectories: {}
+    };
   }
+  /**
+   * Atomic write: stage into a process-unique temp path in the same directory
+   * and then rename over the live file. `rename` is atomic on POSIX, so
+   * concurrent readers in any process either see the old complete file or
+   * the new complete file — never a half-written / zero-byte state.
+   *
+   * Callers MUST hold `withIndexLock(this.indexPath, ...)` so the in-process
+   * read-modify-write cycle stays serialized; the unique temp name also keeps
+   * parallel writers in other processes from colliding on a shared tmp path.
+   */
   async saveIndex(index) {
     index.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
-    await writeFile(this.indexPath, JSON.stringify(index, null, 2), "utf-8");
+    const tmpPath = `${this.indexPath}.${process.pid}.${randomUUID()}.tmp`;
+    await writeFile(tmpPath, JSON.stringify(index, null, 2), "utf-8");
+    await rename(tmpPath, this.indexPath);
   }
   async updateIndex(trajectory2, filePath) {
-    const index = await this.loadIndex();
-    index.trajectories[trajectory2.id] = {
-      title: trajectory2.task.title,
-      status: trajectory2.status,
-      startedAt: trajectory2.startedAt,
-      completedAt: trajectory2.completedAt,
-      path: filePath
-    };
-    await this.saveIndex(index);
+    await withIndexLock(this.indexPath, async () => {
+      const index = await this.loadIndex();
+      index.trajectories[trajectory2.id] = {
+        title: trajectory2.task.title,
+        status: trajectory2.status,
+        startedAt: trajectory2.startedAt,
+        completedAt: trajectory2.completedAt,
+        path: filePath
+      };
+      await this.saveIndex(index);
+    });
   }
 };
 
@@ -1140,7 +1291,7 @@ function resolveTrajectoryCliInvocation() {
     );
     const binEntry = typeof pkg.bin === "string" ? pkg.bin : pkg.bin?.trail ?? (pkg.name ? pkg.bin?.[pkg.name] : void 0);
     if (binEntry) {
-      const cliPath = resolvePath(dirname(packageJsonPath), binEntry);
+      const cliPath = resolvePath(dirname2(packageJsonPath), binEntry);
       if (existsSync2(cliPath)) {
         return { command: process.execPath, args: [cliPath] };
       }
@@ -2039,4 +2190,4 @@ export {
   getCommitsBetween,
   getFilesChangedBetween
 };
-//# sourceMappingURL=chunk-2XT3DOJC.js.map
+//# sourceMappingURL=chunk-WMJRBQB4.js.map