sidekick-shared 0.29.1 → 0.30.0

package/dist/promptHistory.js

@@ -69,11 +69,11 @@ exports.resolveRoots = resolveRoots;
 exports.listCandidates = listCandidates;
 exports.scanFile = scanFile;
 const crypto_1 = require("crypto");
-const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const humanPrompt_1 = require("./humanPrompt");
 const claudeListing_1 = require("./providers/claudeListing");
 const codexRollouts_1 = require("./providers/codexRollouts");
+const compressedRollouts_1 = require("./providers/compressedRollouts");
 const directoryListingCache_1 = require("./providers/directoryListingCache");
 const workspaceRoots_1 = require("./workspaceRoots");
 const fileHead_1 = require("./fileHead");
@@ -150,7 +150,9 @@ async function collectPromptHistory(options) {
         return finish();
     const sinceMs = options.since ? options.since.getTime() : null;
     const providers = options.providers ?? ALL_PROVIDERS;
-    const candidates = rotate(await listCandidates(providers, listingRoots, sinceMs), previousNext);
+    const candidates = rotate(await listCandidates(providers, listingRoots, sinceMs, {
+        includeCompressedRollouts: options.includeCompressedRollouts,
+    }), previousNext);
     const moved = movedSessionKeys(previous, candidates);
     const context = {
         roots,
@@ -186,7 +188,8 @@ async function collectPromptHistory(options) {
         }
         let stat;
         try {
-            stat = await fs.promises.stat(candidate.filePath);
+            // A compressed rollout's size is its decompressed content's.
+            stat = await (0, compressedRollouts_1.statRolloutContent)(candidate.filePath);
         }
         catch {
             continue;
@@ -291,7 +294,7 @@ async function collectPromptHistory(options) {
  */
 async function readPromptOrdinalMarks(provider, sessionId, filePath) {
     const marks = [];
-    const stat = await fs.promises.stat(filePath);
+    const stat = await (0, compressedRollouts_1.statRolloutContent)(filePath);
     const unbounded = Number.MAX_SAFE_INTEGER;
     const context = {
         roots: [],
@@ -480,19 +483,24 @@ function scopedCwd(cwd, roots, realpaths) {
     return null;
 }
 /** @internal */
-async function listCandidates(providers, listingRoots, sinceMs) {
+async function listCandidates(providers, listingRoots, sinceMs, options = {}) {
     const byPath = new Map();
     const listOptions = sinceMs !== null ? { since: sinceMs } : {};
     for (const provider of [...new Set(providers)]) {
         if (!ALL_PROVIDERS.includes(provider))
             continue;
         // Listings are only candidate supersets; scope is re-checked per prompt.
-        const list = provider === 'claude-code' ? claudeListing_1.listClaudeSessionFilesAsync : codexRollouts_1.listCodexSessionFilesAsync;
         const cache = new directoryListingCache_1.DirectoryListingCache();
         for (const root of listingRoots) {
             let files;
             try {
-                files = await list(root, listOptions, cache);
+                files =
+                    provider === 'claude-code'
+                        ? await (0, claudeListing_1.listClaudeSessionFilesAsync)(root, listOptions, cache)
+                        : await (0, codexRollouts_1.listCodexSessionFilesAsync)(root, {
+                            ...listOptions,
+                            includeCompressed: options.includeCompressedRollouts === true && (0, compressedRollouts_1.canReadCompressedRollouts)(),
+                        }, cache);
             }
             catch {
                 files = [];
@@ -514,11 +522,11 @@ async function listCandidates(providers, listingRoots, sinceMs) {
         compareStrings(left.sessionId, right.sessionId) ||
         compareStrings(left.key, right.key));
 }
-/** True when the file's first bytes still match a recorded head. */
+/** True when the file's first bytes (a compressed rollout's content) still match a recorded head. */
 async function fileStartsWith(filePath, head) {
     let handle;
     try {
-        handle = await fs.promises.open(filePath, 'r');
+        ({ handle } = await (0, compressedRollouts_1.openRolloutReadHandle)(filePath));
         return (0, fileHead_1.headMatches)(head, await readAt(handle, 0, Math.min(fileHead_1.HEAD_BYTES, head.bytes)));
     }
     catch {
@@ -591,8 +599,11 @@ async function verifyFile(handle, size, session) {
     return { head: (0, fileHead_1.fileHeadOf)(head), bytesRead };
 }
 /** @internal */
-async function scanFile(candidate, stat, prior, budget, context) {
-    const handle = await fs.promises.open(candidate.filePath, 'r');
+async function scanFile(candidate, fileStat, prior, budget, context) {
+    // A compressed rollout is scanned over its decompressed content.
+    const opened = await (0, compressedRollouts_1.openRolloutReadHandle)(candidate.filePath);
+    const handle = opened.handle;
+    const stat = opened.size === null ? fileStat : { size: opened.size, mtimeMs: fileStat.mtimeMs };
     try {
         let bytesRead = 0;
         const verified = await verifyFile(handle, stat.size, prior);

package/dist/providers/claudeCode.js

@@ -49,6 +49,7 @@ const string_decoder_1 = require("string_decoder");
 const sessionContext_1 = require("../context/sessionContext");
 const sessionStats_1 = require("../sessionStats");
 const jsonl_1 = require("../parsers/jsonl");
+const fileContinuity_1 = require("../fileContinuity");
 const claudeUsageDedupe_1 = require("../usage/claudeUsageDedupe");
 const diagnostics_1 = require("./diagnostics");
 const directoryListingCache_1 = require("./directoryListingCache");
@@ -146,7 +147,10 @@ class ClaudeCodeReader {
     /** Cursor after the last complete line, safe to persist across restarts. */
     committedPosition = 0;
     events = [];
-    _wasTruncated = false;
+    /** Why the last `readNew()` started over from offset 0, if it did. */
+    _lastReset = null;
+    /** Whether the file is still the one the positions refer to. */
+    continuity = new fileContinuity_1.FileContinuity();
     decoder = new string_decoder_1.StringDecoder('utf8');
     /** Split lines of one response repeat its usage; count each response once. */
     usageDeduper;
@@ -167,37 +171,28 @@ class ClaudeCodeReader {
     }
     readNew() {
         this.events = [];
-        this._wasTruncated = false;
+        this._lastReset = null;
+        let fd = null;
         try {
-            if (!fs.existsSync(this.sessionPath)) {
-                return [];
-            }
-            const stats = fs.statSync(this.sessionPath);
+            // Open first and stat the descriptor: the size and identity checked
+            // are those of the file actually read, even if the path is replaced.
+            fd = fs.openSync(this.sessionPath, 'r');
+            const stats = fs.fstatSync(fd);
+            const reason = this.continuity.check(fd, stats, this.filePosition, this.committedPosition);
+            // Truncated, rewritten, or replaced: what was read no longer describes
+            // the file, so start over from its beginning.
+            if (reason !== null)
+                this.restart(reason);
+            this.continuity.adopt(stats);
             const currentSize = stats.size;
-            // Handle truncation
-            if (currentSize < this.filePosition) {
-                this._wasTruncated = true;
-                this.filePosition = 0;
-                this.committedPosition = 0;
-                this.parser.reset();
-                this.decoder = new string_decoder_1.StringDecoder('utf8');
-                this.usageDeduper.reset();
-            }
             // No new content
             if (currentSize <= this.filePosition) {
-                return [];
+                return this.events;
             }
             // Read new bytes from last position
-            const fd = fs.openSync(this.sessionPath, 'r');
             const bufferSize = currentSize - this.filePosition;
             const buffer = Buffer.alloc(bufferSize);
-            let bytesRead = 0;
-            try {
-                bytesRead = fs.readSync(fd, buffer, 0, bufferSize, this.filePosition);
-            }
-            finally {
-                fs.closeSync(fd);
-            }
+            const bytesRead = fs.readSync(fd, buffer, 0, bufferSize, this.filePosition);
             const bytes = buffer.subarray(0, bytesRead);
             const newline = bytes.lastIndexOf(0x0a);
             if (newline >= 0)
@@ -207,10 +202,31 @@ class ClaudeCodeReader {
             this.filePosition += bytesRead;
         }
         catch (error) {
-            console.error(`ClaudeCodeReader: error reading ${this.sessionPath}: ${error}`);
+            if (error?.code !== 'ENOENT') {
+                console.error(`ClaudeCodeReader: error reading ${this.sessionPath}: ${error}`);
+            }
+        }
+        finally {
+            if (fd !== null) {
+                try {
+                    fs.closeSync(fd);
+                }
+                catch {
+                    // Ignore close errors.
+                }
+            }
         }
         return this.events;
     }
+    /** Starts over from offset 0 of a file that was truncated, rewritten, or replaced. */
+    restart(reason) {
+        this._lastReset = { reason, previousPosition: this.committedPosition };
+        this.filePosition = 0;
+        this.committedPosition = 0;
+        this.parser.reset();
+        this.decoder = new string_decoder_1.StringDecoder('utf8');
+        this.usageDeduper.reset();
+    }
     readAll() {
         this.reset();
         return this.readNew();
@@ -221,7 +237,8 @@ class ClaudeCodeReader {
         this.parser.reset();
         this.decoder = new string_decoder_1.StringDecoder('utf8');
         this.usageDeduper.reset();
-        this._wasTruncated = false;
+        this._lastReset = null;
+        this.continuity.forget();
     }
     exists() {
         return fs.existsSync(this.sessionPath);
@@ -241,9 +258,15 @@ class ClaudeCodeReader {
         this.committedPosition = position;
         this.parser.reset();
         this.decoder = new string_decoder_1.StringDecoder('utf8');
+        // The position comes from elsewhere (a snapshot): adopt the file the next
+        // read finds rather than compare it with one read before.
+        this.continuity.forget();
     }
     wasTruncated() {
-        return this._wasTruncated;
+        return this._lastReset !== null;
+    }
+    lastReset() {
+        return this._lastReset ? { ...this._lastReset } : null;
     }
     /** The usage deduper's recent message ids, so a resumed reader does not recount a split response. */
     getResumeState() {

package/dist/providers/codex.d.ts

@@ -4,7 +4,9 @@
  * Implements SessionProviderBase for monitoring Codex CLI sessions.
  * Codex stores sessions as JSONL rollout files in:
  *   ~/.codex/sessions/YYYY/MM/DD/rollout-<timestamp>-<uuid>.jsonl
- * with an optional SQLite index at ~/.codex/state.sqlite.
+ * with an optional SQLite index at ~/.codex/state.sqlite. Older rollouts are
+ * compressed in place to `….jsonl.zst`; those are read only with the
+ * `includeCompressedRollouts` option (see `providers/compressedRollouts`).
  *
  * Ported from sidekick-vscode/src/services/providers/CodexSessionProvider.ts
  */
@@ -15,6 +17,19 @@ import type { SubagentStats, TokenUsage } from '../types/sessionEvent';
 import type { CodexRateLimits } from '../types/codex';
 export { findCodexRolloutFile };
 export type { FindCodexRolloutFileOptions } from './codexRollouts';
+/** Options for {@link CodexProvider}; every field is optional and additive. */
+export interface CodexProviderOptions extends SessionProviderOptions {
+    /**
+     * Also discover and read compressed rollouts (`rollout-….jsonl.zst`,
+     * which Codex writes for older sessions). Listings, session lookups,
+     * labels, `createReader()` (a whole-file reader; live tailing stays
+     * `.jsonl`-only), search, and subagent stats then include them. Reading
+     * needs `zlib.zstdDecompressSync` (Node 22.15+); without it they are
+     * skipped and reported once through `onDiagnostic`. Default false, so
+     * session and history counts are unchanged.
+     */
+    includeCompressedRollouts?: boolean;
+}
 /**
  * Session provider for Codex CLI.
  *
@@ -33,7 +48,17 @@ export declare class CodexProvider implements SessionProviderBase {
     private lastTokenUsageData;
     /** Dated rollout-directory listings reused across async enumerations. */
     private readonly directoryCache;
-    constructor(options?: SessionProviderOptions);
+    /** See {@link CodexProviderOptions.includeCompressedRollouts}. */
+    private readonly compressedRequested;
+    private readonly onDiagnostic;
+    constructor(options?: CodexProviderOptions);
+    /**
+     * Whether compressed rollouts are discovered and read: requested, and the
+     * runtime can decompress them (otherwise reported once, on first use).
+     */
+    private get includeCompressed();
+    /** A stored rollout path as it exists now (its `.zst` when compressed and enabled). */
+    private resolveRollout;
     /** Lazy-initialize database connection. */
     private ensureDb;
     private ensureDbAsync;
@@ -70,11 +95,16 @@ export declare class CodexProvider implements SessionProviderBase {
     extractSessionLabel(sessionPath: string): string | null;
     extractSessionLabelsAsync(sessionPaths: readonly string[]): Promise<Map<string, string | null>>;
     createReader(sessionPath: string): SessionReader;
-    scanSubagents(_sessionDir: string, sessionId: string): SubagentStats[];
     /**
-     * Builds SubagentStats for a forked session by reading its rollout file.
+     * Every subagent below the session, any depth: spawned threads (the
+     * database's `threads.source`, else the newest rollouts' session_meta)
+     * and, on older schemas, forks (`forked_from_id`). Each carries its
+     * rollout (`filePath`), the parent's spawn call (`spawnToolUseId`),
+     * `agentNickname`, `agentPath`, `parentAgentId`, and `depth`; tool calls
+     * and tokens come from the child's own records, not the parent history a
+     * forked child embeds.
      */
-    private buildSubagentStats;
+    scanSubagents(_sessionDir: string, sessionId: string): SubagentStats[];
     searchInSession(sessionPath: string, query: string, maxResults: number): SearchHit[];
     getProjectsBaseDir(): string;
     getWatchRoots(): string[];