sidekick-shared 0.24.5 → 0.26.0

package/dist/providers/claudeCode.js

@@ -48,7 +48,9 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 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 diagnostics_1 = require("./diagnostics");
 const sessionPathResolver_1 = require("../parsers/sessionPathResolver");
 const subagentScanner_1 = require("../parsers/subagentScanner");
 const modelContext_1 = require("../modelContext");
@@ -88,6 +90,42 @@ function extractSearchableText(event) {
     }
     return '';
 }
+function extractClaudeLabelFromPrefix(chunk) {
+    for (const line of chunk.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const event = JSON.parse(trimmed);
+            if (event.type !== 'user')
+                continue;
+            const content = event.message?.content;
+            if (!content)
+                continue;
+            let text = null;
+            if (typeof content === 'string') {
+                text = content.trim();
+            }
+            else if (Array.isArray(content)) {
+                const textBlock = content.find((block) => isTypedBlock(block) &&
+                    block.type === 'text' &&
+                    typeof block.text === 'string' &&
+                    block.text.trim().length > 0);
+                if (textBlock && isTypedBlock(textBlock) && typeof textBlock.text === 'string') {
+                    text = textBlock.text.trim();
+                }
+            }
+            if (text) {
+                const compact = text.replace(/\s+/g, ' ');
+                return compact.length > 60 ? compact.substring(0, 57) + '...' : compact;
+            }
+        }
+        catch {
+            // Skip malformed lines.
+        }
+    }
+    return null;
+}
 /**
  * Incremental JSONL reader for Claude Code session files.
  *
@@ -234,8 +272,12 @@ function normalizeClaudeUsage(event) {
 class ClaudeCodeProvider {
     id = 'claude-code';
     displayName = 'Claude Code';
+    diagnostics;
     /** Runtime-reported context window limit (overrides static map when set). */
     dynamicContextWindowLimit = null;
+    constructor(options = {}) {
+        this.diagnostics = new diagnostics_1.ProviderDiagnosticTracker(this.id, options);
+    }
     // --- Path resolution ---
     getSessionDirectory(workspacePath) {
         return (0, sessionPathResolver_1.getSessionDirectory)(workspacePath);
@@ -250,6 +292,43 @@ class ClaudeCodeProvider {
     findAllSessions(workspacePath) {
         return (0, sessionPathResolver_1.findAllSessions)(workspacePath);
     }
+    findSessionById(workspacePath, sessionId) {
+        const normalizedId = sessionId.trim();
+        if (!normalizedId || path.basename(normalizedId) !== normalizedId)
+            return null;
+        try {
+            const directories = new Set();
+            directories.add(this.getSessionDirectory(workspacePath));
+            const discovered = this.discoverSessionDirectory(workspacePath);
+            if (discovered)
+                directories.add(discovered);
+            for (const folder of this.getAllProjectFolders(workspacePath))
+                directories.add(folder.dir);
+            for (const directory of directories) {
+                const direct = path.join(directory, `${normalizedId}.jsonl`);
+                try {
+                    if (fs.statSync(direct).isFile()) {
+                        this.diagnostics.available('findSessionById');
+                        return direct;
+                    }
+                }
+                catch {
+                    // Continue with directory-shaped lookup for worktree layouts.
+                }
+                const match = this.findSessionsInDirectory(directory).find((candidate) => this.getSessionId(candidate) === normalizedId);
+                if (match) {
+                    this.diagnostics.available('findSessionById');
+                    return match;
+                }
+            }
+            this.recordHomeStatus('findSessionById');
+            return null;
+        }
+        catch {
+            this.recordHomeStatus('findSessionById');
+            return null;
+        }
+    }
     /** Backward-compatible alias for findAllSessions. */
     findSessionFiles(workspacePath) {
         return this.findAllSessions(workspacePath);
@@ -264,19 +343,89 @@ class ClaudeCodeProvider {
         const results = [];
         const seen = new Set();
         for (const folder of this.getAllProjectFolders()) {
-            for (const sessionPath of this.findSessionsInDirectory(folder.dir)) {
-                if (seen.has(sessionPath))
+            // The directory listing already stat'ed each file; reuse it instead of
+            // stat'ing every session a second time.
+            for (const file of (0, sessionPathResolver_1.findSessionFilesWithStats)(folder.dir)) {
+                if (seen.has(file.path))
                     continue;
-                seen.add(sessionPath);
+                seen.add(file.path);
+                results.push({ path: file.path, mtime: file.mtime, sizeBytes: file.sizeBytes });
+            }
+        }
+        this.recordHomeStatus('listAllSessionFiles');
+        return results;
+    }
+    async listSessionFilesAsync(workspacePath) {
+        const projectsRoot = this.getProjectsBaseDir();
+        let projectEntries = [];
+        try {
+            projectEntries = await fs.promises.readdir(projectsRoot, { withFileTypes: true });
+        }
+        catch {
+            this.recordHomeStatus('listSessionFilesAsync');
+            return [];
+        }
+        const encodedWorkspace = workspacePath ? (0, sessionPathResolver_1.encodeWorkspacePath)(workspacePath).toLowerCase() : null;
+        const workspaceBasename = workspacePath
+            ? path
+                .basename(workspacePath)
+                .replace(/[^a-zA-Z0-9]/g, '-')
+                .toLowerCase()
+            : null;
+        const directories = [];
+        for (const entry of projectEntries) {
+            const directory = path.join(projectsRoot, entry.name);
+            try {
+                const stat = entry.isDirectory() ? null : await fs.promises.stat(directory);
+                if (!entry.isDirectory() && !stat?.isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            const name = entry.name.toLowerCase();
+            if (encodedWorkspace &&
+                name !== encodedWorkspace &&
+                !name.startsWith(`${encodedWorkspace}-`) &&
+                name !== workspaceBasename &&
+                !name.endsWith(`-${workspaceBasename}`)) {
+                continue;
+            }
+            directories.push(directory);
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        const results = [];
+        for (const directory of directories) {
+            let entries = [];
+            try {
+                entries = await fs.promises.readdir(directory, { withFileTypes: true });
+            }
+            catch {
+                continue;
+            }
+            for (const entry of entries) {
+                if (!entry.isFile() || !this.isSessionFile(entry.name))
+                    continue;
+                const sessionPath = path.join(directory, entry.name);
                 try {
-                    results.push({ path: sessionPath, mtime: fs.statSync(sessionPath).mtime });
+                    const stat = await fs.promises.stat(sessionPath);
+                    if (stat.size > 0) {
+                        results.push({
+                            path: sessionPath,
+                            mtime: stat.mtime,
+                            sizeBytes: stat.size,
+                            sessionId: this.getSessionId(sessionPath),
+                        });
+                    }
                 }
                 catch {
-                    // Skip files that vanish between listing and stat.
+                    // Skip files that vanish between discovery and stat.
                 }
+                await new Promise((resolve) => setImmediate(resolve));
             }
         }
-        return results;
+        this.recordHomeStatus('listSessionFilesAsync');
+        return results.sort((left, right) => right.mtime.getTime() - left.mtime.getTime());
     }
     // --- File identification ---
     isSessionFile(filename) {
@@ -296,50 +445,32 @@ class ClaudeCodeProvider {
             fs.closeSync(fd);
             if (bytesRead === 0)
                 return null;
-            const chunk = buffer.toString('utf-8', 0, bytesRead);
-            const lines = chunk.split('\n');
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (!trimmed)
-                    continue;
-                try {
-                    const event = JSON.parse(trimmed);
-                    if (event.type !== 'user')
-                        continue;
-                    const content = event.message?.content;
-                    if (!content)
-                        continue;
-                    let text = null;
-                    if (typeof content === 'string') {
-                        text = content.trim();
-                    }
-                    else if (Array.isArray(content)) {
-                        const textBlock = content.find((block) => isTypedBlock(block) &&
-                            block.type === 'text' &&
-                            typeof block.text === 'string' &&
-                            block.text.trim().length > 0);
-                        if (textBlock && isTypedBlock(textBlock) && typeof textBlock.text === 'string') {
-                            text = textBlock.text.trim();
-                        }
-                    }
-                    if (text && text.length > 0) {
-                        text = text.replace(/\s+/g, ' ');
-                        if (text.length > 60) {
-                            text = text.substring(0, 57) + '...';
-                        }
-                        return text;
-                    }
-                }
-                catch {
-                    // Skip malformed lines
-                }
-            }
-            return null;
+            return extractClaudeLabelFromPrefix(buffer.toString('utf-8', 0, bytesRead));
         }
         catch {
             return null;
         }
     }
+    async extractSessionLabelsAsync(sessionPaths) {
+        const results = new Map();
+        for (const sessionPath of sessionPaths) {
+            let handle = null;
+            try {
+                handle = await fs.promises.open(sessionPath, 'r');
+                const buffer = Buffer.alloc(8192);
+                const { bytesRead } = await handle.read(buffer, 0, buffer.length, 0);
+                results.set(sessionPath, extractClaudeLabelFromPrefix(buffer.toString('utf8', 0, bytesRead)));
+            }
+            catch {
+                results.set(sessionPath, null);
+            }
+            finally {
+                await handle?.close().catch(() => undefined);
+            }
+            await new Promise((resolve) => setImmediate(resolve));
+        }
+        return results;
+    }
     // --- Data reading ---
     createReader(sessionPath) {
         return new ClaudeCodeReader(sessionPath);
@@ -397,100 +528,36 @@ class ClaudeCodeProvider {
     getProjectsBaseDir() {
         return path.join(os.homedir(), '.claude', 'projects');
     }
+    getWatchRoots() {
+        return [this.getProjectsBaseDir()];
+    }
     // --- Stats ---
     readSessionStats(sessionPath) {
-        const sessionId = path.basename(sessionPath, '.jsonl');
-        let messageCount = 0;
-        let startTime = '';
-        let endTime = '';
-        const tokens = { input: 0, output: 0, cacheWrite: 0, cacheRead: 0 };
-        const modelUsage = {};
-        const toolUsage = {};
-        let compactionEstimate = 0;
-        let truncationCount = 0;
-        let reportedCost = 0;
+        // One reader pass through the shared aggregator: cache-inclusive per-model
+        // totals, cost with provenance, a tool success/failure split, and the label
+        // from the first user prompt in the events already read.
+        return (0, sessionStats_1.readSessionFileStats)(this, sessionPath);
+    }
+    readSessionContextSnapshot(sessionPath, options = {}) {
+        return (0, sessionContext_1.readSessionContextSnapshot)(this, sessionPath, options);
+    }
+    // --- Optional methods ---
+    getRuntimeStatus() {
         try {
-            const content = fs.readFileSync(sessionPath, 'utf8');
-            const lines = content.split('\n');
-            for (const line of lines) {
-                const trimmed = line.trim();
-                if (!trimmed || !trimmed.startsWith('{'))
-                    continue;
-                try {
-                    const event = JSON.parse(trimmed);
-                    if (!startTime && event.timestamp)
-                        startTime = event.timestamp;
-                    if (event.timestamp)
-                        endTime = event.timestamp;
-                    if (event.type === 'assistant' && event.message?.usage) {
-                        messageCount++;
-                        const u = event.message.usage;
-                        tokens.input += u.input_tokens || 0;
-                        tokens.output += u.output_tokens || 0;
-                        tokens.cacheWrite += u.cache_creation_input_tokens || 0;
-                        tokens.cacheRead += u.cache_read_input_tokens || 0;
-                        if (u.reported_cost)
-                            reportedCost += u.reported_cost;
-                        const model = event.message.model || 'unknown';
-                        if (!modelUsage[model])
-                            modelUsage[model] = { calls: 0, tokens: 0 };
-                        modelUsage[model].calls++;
-                        modelUsage[model].tokens += (u.input_tokens || 0) + (u.output_tokens || 0);
-                        // Check content for tool_use blocks
-                        if (Array.isArray(event.message.content)) {
-                            for (const block of event.message.content) {
-                                if (block.type === 'tool_use' && typeof block.name === 'string') {
-                                    toolUsage[block.name] = (toolUsage[block.name] || 0) + 1;
-                                }
-                            }
-                        }
-                    }
-                    if (event.type === 'user')
-                        messageCount++;
-                    if (event.type === 'summary')
-                        compactionEstimate++;
-                    // Check for truncation in tool results
-                    if (event.type === 'user' && Array.isArray(event.message?.content)) {
-                        for (const block of event.message.content) {
-                            if (block.type === 'tool_result' && typeof block.content === 'string') {
-                                for (const pattern of jsonl_1.TRUNCATION_PATTERNS) {
-                                    if (pattern.regex.test(block.content)) {
-                                        truncationCount++;
-                                        break;
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-                catch {
-                    // Skip malformed lines
-                }
-            }
+            fs.accessSync(this.getProjectsBaseDir(), fs.constants.R_OK);
+            return { available: true, kind: 'available' };
         }
         catch {
-            // Skip unreadable files
+            return {
+                available: false,
+                kind: 'home_unavailable',
+                message: 'Claude Code session home is unavailable.',
+            };
         }
-        return {
-            providerId: 'claude-code',
-            sessionId,
-            filePath: sessionPath,
-            label: this.extractSessionLabel(sessionPath),
-            startTime,
-            endTime,
-            messageCount,
-            tokens,
-            modelUsage,
-            toolUsage,
-            compactionEstimate,
-            truncationCount,
-            reportedCost,
-        };
     }
-    readSessionContextSnapshot(sessionPath, options = {}) {
-        return (0, sessionContext_1.readSessionContextSnapshot)(this, sessionPath, options);
+    getLastOperationStatus() {
+        return this.diagnostics.getLastOperationStatus();
     }
-    // --- Optional methods ---
     getContextWindowLimit(modelId) {
         if (this.dynamicContextWindowLimit)
             return this.dynamicContextWindowLimit;
@@ -552,5 +619,18 @@ class ClaudeCodeProvider {
     dispose() {
         this.dynamicContextWindowLimit = null;
     }
+    recordHomeStatus(operation) {
+        const status = this.getRuntimeStatus();
+        if (status.available) {
+            this.diagnostics.available(operation);
+            return;
+        }
+        this.diagnostics.degraded(operation, status, {
+            kind: 'home_unavailable',
+            severity: 'info',
+            phase: 'enumerate',
+            message: status.message ?? 'Claude Code session home is unavailable.',
+        });
+    }
 }
 exports.ClaudeCodeProvider = ClaudeCodeProvider;

package/dist/providers/codex.d.ts

@@ -9,7 +9,7 @@
  * Ported from sidekick-vscode/src/services/providers/CodexSessionProvider.ts
  */
 import type { ReadSessionContextSnapshotOptions, SessionContextSnapshot } from '../context/sessionContext';
-import type { SessionProviderBase, SessionReader, ProjectFolderInfo, SearchHit, SessionFileInfo, SessionFileStats, ProviderId } from './types';
+import type { SessionProviderBase, SessionReader, ProjectFolderInfo, SearchHit, SessionFileInfo, SessionFileStats, ProviderId, ProviderOperationStatus, ProviderRuntimeStatus, SessionProviderOptions } from './types';
 import type { SubagentStats, TokenUsage } from '../types/sessionEvent';
 import type { CodexRateLimits } from '../types/codex';
 export interface FindCodexRolloutFileOptions {
@@ -43,24 +43,41 @@ export declare class CodexProvider implements SessionProviderBase {
     readonly displayName = "Codex CLI";
     private db;
     private dbInitialized;
+    private dbStatus;
+    private readonly diagnostics;
     private dynamicContextWindowLimit;
     private lastRateLimitsData;
     private lastTokenUsageData;
+    constructor(options?: SessionProviderOptions);
     /** Lazy-initialize database connection. */
     private ensureDb;
+    private ensureDbAsync;
+    /**
+     * Cache an async-created database only after an operation proved it usable.
+     * Sync paths treat a cached `db` as "open() succeeded", so adopting an
+     * unproven instance would silently disable their file fallbacks.
+     */
+    private adoptDbIfAvailable;
+    getRuntimeStatus(): ProviderRuntimeStatus;
+    getLastOperationStatus(): ProviderOperationStatus;
     getSessionDirectory(workspacePath: string): string;
     discoverSessionDirectory(workspacePath: string): string | null;
     findActiveSession(workspacePath: string): string | null;
     findAllSessions(workspacePath: string): string[];
+    findSessionById(_workspacePath: string, sessionId: string): string | null;
     /** Backward-compatible alias for findAllSessions. */
     findSessionFiles(workspacePath: string): string[];
     findSessionsInDirectory(dir: string): string[];
     listAllSessionFiles(): SessionFileInfo[];
+    listSessionFilesAsync(workspacePath?: string): Promise<SessionFileInfo[]>;
     getAllProjectFolders(workspacePath?: string): ProjectFolderInfo[];
     isSessionFile(filename: string): boolean;
     getSessionId(sessionPath: string): string;
     encodeWorkspacePath(workspacePath: string): string;
+    /** Thread title or first user message from the SQLite index; null without it. */
+    private extractSessionLabelFromDb;
     extractSessionLabel(sessionPath: string): string | null;
+    extractSessionLabelsAsync(sessionPaths: readonly string[]): Promise<Map<string, string | null>>;
     createReader(sessionPath: string): SessionReader;
     scanSubagents(_sessionDir: string, sessionId: string): SubagentStats[];
     /**
@@ -69,6 +86,7 @@ export declare class CodexProvider implements SessionProviderBase {
     private buildSubagentStats;
     searchInSession(sessionPath: string, query: string, maxResults: number): SearchHit[];
     getProjectsBaseDir(): string;
+    getWatchRoots(): string[];
     readSessionStats(sessionPath: string): SessionFileStats;
     readSessionContextSnapshot(sessionPath: string, options?: ReadSessionContextSnapshotOptions): SessionContextSnapshot;
     getContextWindowLimit(modelId?: string): number;
@@ -77,4 +95,5 @@ export declare class CodexProvider implements SessionProviderBase {
     /** Get the last rate limits data received from token_count events. */
     getLastRateLimits(): CodexRateLimits | null;
     dispose(): void;
+    private recordDatabaseFallback;
 }