@wrongstack/core 0.10.2 → 0.10.3

package/dist/storage/index.js

@@ -30,8 +30,8 @@ async function atomicWrite(targetPath, content, opts = {}) {
     }
     let mode;
     try {
-      const stat4 = await fsp.stat(targetPath);
-      mode = stat4.mode & 511;
+      const stat5 = await fsp.stat(targetPath);
+      mode = stat5.mode & 511;
     } catch {
       mode = opts.mode;
     }
@@ -297,8 +297,8 @@ var DefaultSessionStore = class {
       return JSON.parse(raw);
     } catch {
       const full = this.sessionPath(id, ".jsonl");
-      const stat4 = await fsp.stat(full);
-      const summary = await this.summarize(id, stat4.mtime.toISOString());
+      const stat5 = await fsp.stat(full);
+      const summary = await this.summarize(id, stat5.mtime.toISOString());
       await atomicWrite(manifest, JSON.stringify(summary), { mode: 384 }).catch((err) => {
         console.warn(
           `[session-store] Failed to write manifest for "${id}":`,
@@ -1776,11 +1776,27 @@ var DefaultSessionReader = class {
     const data = await this.store.load(sessionId);
     for (const e of data.events) yield e;
   }
-  async search(q, sessionId) {
+  async search(q, sessionId, sessionQuery) {
     const limit = q.limit ?? 100;
     const matcher = buildMatcher(q);
     const allowedTypes = q.types ? new Set(q.types) : null;
-    const ids = sessionId ? [sessionId] : (await this.store.list(1e3)).map((s) => s.id);
+    let ids;
+    if (sessionId) {
+      ids = [sessionId];
+    } else {
+      const sessions = await this.store.list(1e3);
+      const titleNeedle = sessionQuery?.titleContains?.toLowerCase();
+      const filtered = sessions.filter((s) => {
+        if (sessionQuery?.since && s.startedAt < sessionQuery.since) return false;
+        if (sessionQuery?.until && s.startedAt > sessionQuery.until) return false;
+        if (sessionQuery?.provider && s.provider !== sessionQuery.provider) return false;
+        if (sessionQuery?.model && s.model !== sessionQuery.model) return false;
+        if (sessionQuery?.minTokens !== void 0 && s.tokenTotal < sessionQuery.minTokens) return false;
+        if (titleNeedle && !s.title.toLowerCase().includes(titleNeedle)) return false;
+        return true;
+      });
+      ids = filtered.map((s) => s.id);
+    }
     const hits = [];
     for (const id of ids) {
       let data;
@@ -2183,6 +2199,8 @@ var ReplayLogStore = class {
   writeChains = /* @__PURE__ */ new Map();
   /** Per-session hash → entry index, kept in memory after the first load. */
   cache = /* @__PURE__ */ new Map();
+  /** Per-session entry count on disk, to detect when compaction is needed. */
+  diskCount = /* @__PURE__ */ new Map();
   maxEntries;
   constructor(opts) {
     this.dir = opts.dir;
@@ -2205,17 +2223,30 @@ var ReplayLogStore = class {
         request: input.request,
         response: input.response
       };
-      let all = [...cache.values(), entry];
-      if (all.length > this.maxEntries) {
-        const evictCount = all.length - this.maxEntries;
-        all = all.slice(evictCount);
-      }
-      await this.writeAll(input.sessionId, all);
-      cache.clear();
-      for (const e of all) cache.set(e.hash, e);
+      cache.set(hash, entry);
+      const count = (this.diskCount.get(input.sessionId) ?? 0) + 1;
+      if (count > this.maxEntries) {
+        await this.compact(input.sessionId, cache);
+      } else {
+        await fsp.appendFile(this.filePath(input.sessionId), JSON.stringify(entry) + "\n", "utf8");
+        this.diskCount.set(input.sessionId, count);
+      }
     });
     return hash;
   }
+  /**
+   * Compact the replay log to keep only the most recent maxEntries.
+   * Called when entry count exceeds the cap. Rewrites the entire file
+   * but only happens O(n / maxEntries) times per session.
+   */
+  async compact(sessionId, cache) {
+    const all = [...cache.values()];
+    const keep = all.slice(-this.maxEntries);
+    await this.writeAll(sessionId, keep);
+    cache.clear();
+    for (const e of keep) cache.set(e.hash, e);
+    this.diskCount.set(sessionId, keep.length);
+  }
   // ── Reads ───────────────────────────────────────────────────────────────
   /**
    * Look up an entry by hash. Returns `null` when the request has
@@ -2299,6 +2330,7 @@ var ReplayLogStore = class {
     cache = /* @__PURE__ */ new Map();
     for (const e of all) cache.set(e.hash, e);
     this.cache.set(sessionId, cache);
+    this.diskCount.set(sessionId, all.length);
     return cache;
   }
   enqueue(sessionId, fn) {
@@ -2328,14 +2360,50 @@ var SessionRecovery = class {
    */
   async detectStale(sessionId) {
     const fp = this.filePath(sessionId);
-    let raw;
+    const TAIL_SIZE = 8192;
+    let stat5;
     try {
-      raw = await fsp.readFile(fp, "utf8");
+      stat5 = await fsp.stat(fp);
     } catch (err) {
       if (err.code === "ENOENT") return null;
       return null;
     }
-    return this.parseForStale(sessionId, fp, raw);
+    if (stat5.size === 0) return null;
+    const position = Math.max(0, stat5.size - TAIL_SIZE);
+    const buf = Buffer.alloc(TAIL_SIZE);
+    let fh;
+    try {
+      fh = await fsp.open(fp, "r");
+      const { bytesRead } = await fh.read(buf, 0, TAIL_SIZE, position);
+      let eventCount = 0;
+      const raw = buf.subarray(0, bytesRead).toString("utf8");
+      for (const line of raw.split("\n")) {
+        if (line.trim()) eventCount++;
+      }
+      const lines = raw.split("\n").filter((l) => l.trim());
+      for (let i = lines.length - 1; i >= 0; i--) {
+        try {
+          const ev = JSON.parse(lines[i]);
+          if (ev.type === "in_flight_start") {
+            return {
+              sessionId,
+              path: fp,
+              lastEventTs: ev.ts,
+              context: ev.context,
+              eventCount
+            };
+          }
+          return null;
+        } catch {
+          continue;
+        }
+      }
+      return null;
+    } catch {
+      return null;
+    } finally {
+      if (fh) await fh.close();
+    }
   }
   /**
    * Generate a recovery plan for a session. The plan describes
@@ -2416,46 +2484,22 @@ var SessionRecovery = class {
     }
     return path11.join(this.dir, `${sessionId}.jsonl`);
   }
-  /**
-   * Stream-parse the last few lines of a JSONL log. We do NOT load
-   * the whole file into memory — for long-running sessions the log
-   * can be megabytes. Instead we read tail-ward and find the last
-   * `in_flight_start` / `in_flight_end` pair.
-   */
-  async parseForStale(sessionId, fp, raw) {
-    const lines = raw.split("\n");
-    let lastEvent = null;
-    let eventCount = 0;
-    for (const line of lines) {
-      if (!line.trim()) continue;
-      try {
-        const ev = JSON.parse(line);
-        lastEvent = ev;
-        eventCount++;
-      } catch {
-      }
-    }
-    if (!lastEvent) return null;
-    if (lastEvent.type === "in_flight_start") {
-      return {
-        sessionId,
-        path: fp,
-        lastEventTs: lastEvent.ts,
-        context: lastEvent.context,
-        eventCount
-      };
-    }
-    return null;
-  }
 };
 var GENESIS_PREV = "0".repeat(64);
+var DEFAULT_FSYNC_EVERY = 100;
 var ToolAuditLog = class {
   dir;
   /** In-memory cache of the last entry's hash (per session), to compute chains efficiently. */
   tailHash = /* @__PURE__ */ new Map();
+  /** In-memory counter for entry indices — avoids re-reading the file on every write. */
+  tailIndex = /* @__PURE__ */ new Map();
+  /** Tracks writes since last fsync, per session. */
+  unSyncedWrites = /* @__PURE__ */ new Map();
   writeChains = /* @__PURE__ */ new Map();
+  fsyncEvery;
   constructor(opts) {
     this.dir = opts.dir;
+    this.fsyncEvery = opts.fsyncEvery ?? DEFAULT_FSYNC_EVERY;
   }
   /**
    * Append a tool call/result pair to the chain. Returns the
@@ -2467,6 +2511,7 @@ var ToolAuditLog = class {
     let entry = null;
     await this.enqueue(input.sessionId, async () => {
       const prevHash = this.tailHash.get(input.sessionId) ?? GENESIS_PREV;
+      const index = this.tailIndex.get(input.sessionId) ?? 0;
       const id = randomUUID();
       const ts = (/* @__PURE__ */ new Date()).toISOString();
       const content = {
@@ -2477,12 +2522,11 @@ var ToolAuditLog = class {
         toolUseId: input.toolUseId,
         input: input.input,
         output: input.output,
-        isError: input.isError
+        isError: input.isError,
+        index
       };
       const hash = createHash("sha256").update(stableStringify2(content), "utf8").digest("hex");
       entry = {
-        index: this.tailHash.has(input.sessionId) ? -1 : 0,
-        // placeholder; recomputed below
         id,
         ts,
         prevHash,
@@ -2491,15 +2535,12 @@ var ToolAuditLog = class {
         toolUseId: input.toolUseId,
         input: input.input,
         output: input.output,
-        isError: input.isError
+        isError: input.isError,
+        index
       };
-      const existing = await this.readAll(input.sessionId);
-      const index = existing.length;
-      const finalContent = { ...content, index };
-      const finalHash = createHash("sha256").update(stableStringify2(finalContent), "utf8").digest("hex");
-      entry = { ...entry, index, hash: finalHash };
       await this.appendLine(input.sessionId, entry);
-      this.tailHash.set(input.sessionId, finalHash);
+      this.tailHash.set(input.sessionId, hash);
+      this.tailIndex.set(input.sessionId, index + 1);
     });
     return entry;
   }
@@ -2581,9 +2622,34 @@ var ToolAuditLog = class {
   }
   async appendLine(sessionId, entry) {
     const fp = this.filePath(sessionId);
-    const existing = await this.readAll(sessionId);
-    const all = [...existing, entry];
-    await atomicWrite(fp, all.map((e) => JSON.stringify(e)).join("\n") + (all.length ? "\n" : ""));
+    const line = JSON.stringify(entry) + "\n";
+    await fsp.appendFile(fp, line, "utf8");
+    const count = (this.unSyncedWrites.get(sessionId) ?? 0) + 1;
+    this.unSyncedWrites.set(sessionId, count);
+    if (this.fsyncEvery !== Infinity && count % this.fsyncEvery === 0) {
+      await this.sync(sessionId, fp);
+    }
+  }
+  /**
+   * Explicitly sync the file to disk. Called automatically every
+   * `fsyncEvery` writes, and available for callers who want to
+   * force a sync before closing or during graceful shutdown.
+   */
+  async flush(sessionId) {
+    await this.sync(sessionId, this.filePath(sessionId));
+  }
+  async sync(sessionId, fp) {
+    try {
+      const fh = await fsp.open(fp, "r+");
+      try {
+        await fh.sync();
+      } finally {
+        await fh.close();
+      }
+    } catch {
+    } finally {
+      this.unSyncedWrites.set(sessionId, 0);
+    }
   }
   enqueue(sessionId, fn) {
     const prev = this.writeChains.get(sessionId) ?? Promise.resolve();
@@ -3787,8 +3853,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat4 = await fsp.stat(localPath);
-        if (stat4.isDirectory()) {
+        const stat5 = await fsp.stat(localPath);
+        if (stat5.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp.readFile(file, "utf8");
@@ -3813,8 +3879,8 @@ var CloudSync = class {
       const localPath = this.categoryToPath(cat);
       if (!localPath) continue;
       try {
-        const stat4 = await fsp.stat(localPath);
-        if (stat4.isDirectory()) {
+        const stat5 = await fsp.stat(localPath);
+        if (stat5.isDirectory()) {
           const files = await this.walkDir(localPath, localPath);
           for (const file of files) {
             const content = await fsp.readFile(file);