sidekick-shared 0.27.6 → 0.28.1

package/dist/esm/extractors/sources/codexAssets.js

@@ -0,0 +1,234 @@
+/**
+ * Codex CLI rollout reader for actionable asset extraction.
+ *
+ * Portions adapted from `trawl` by Juan Fourie (B33pBeeps), MIT licensed:
+ * https://github.com/B33pBeeps/trawl
+ *
+ * @module extractors/sources/codexAssets
+ */
+import { join, resolve } from 'node:path';
+import { closeSync, openSync, readFileSync, readSync, readdirSync, statSync } from 'node:fs';
+import { getCodexMonitoringHomes } from '../../codexProfiles';
+import { commandAsset, extractCommands, extractFilePaths, extractUrls, pathAsset, planAsset, urlAsset, } from '../sessionAssets';
+const EXEC_NAMES = new Set(['exec_command', 'shell', 'local_shell', 'container.exec']);
+function dirExists(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+function firstJsonLine(filePath) {
+    let fd;
+    try {
+        fd = openSync(filePath, 'r');
+    }
+    catch {
+        return null;
+    }
+    const buffer = Buffer.alloc(65536);
+    let data = '';
+    try {
+        let bytesRead;
+        while ((bytesRead = readSync(fd, buffer, 0, buffer.length, null)) > 0) {
+            data += buffer.toString('utf8', 0, bytesRead);
+            const newlineIndex = data.indexOf('\n');
+            if (newlineIndex >= 0) {
+                data = data.slice(0, newlineIndex);
+                break;
+            }
+            if (data.length > 1_000_000)
+                break;
+        }
+    }
+    catch {
+        return null;
+    }
+    finally {
+        closeSync(fd);
+    }
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+function readJsonl(filePath, skip) {
+    let raw;
+    try {
+        raw = readFileSync(filePath, 'utf8');
+    }
+    catch {
+        return [];
+    }
+    const lines = [];
+    for (const line of raw.split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        if (skip?.(trimmed))
+            continue;
+        try {
+            lines.push(JSON.parse(trimmed));
+        }
+        catch {
+            // Ignore partial or malformed JSONL lines.
+        }
+    }
+    return lines;
+}
+function rolloutFiles(limit = 150) {
+    const entries = [];
+    const seen = new Set();
+    const walk = (dir) => {
+        let dirEntries;
+        try {
+            dirEntries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of dirEntries) {
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                walk(fullPath);
+            }
+            else if (entry.isFile() &&
+                entry.name.startsWith('rollout-') &&
+                entry.name.endsWith('.jsonl')) {
+                try {
+                    if (seen.has(fullPath))
+                        continue;
+                    seen.add(fullPath);
+                    entries.push({ path: fullPath, mtime: statSync(fullPath).mtimeMs });
+                }
+                catch {
+                    // Ignore inaccessible files.
+                }
+            }
+        }
+    };
+    for (const home of getCodexMonitoringHomes()) {
+        const sessionsDir = join(home, 'sessions');
+        if (dirExists(sessionsDir))
+            walk(sessionsDir);
+    }
+    return entries
+        .sort((a, b) => b.mtime - a.mtime)
+        .slice(0, limit)
+        .map((entry) => entry.path);
+}
+export function codexSessions(cwd, limit = 3) {
+    const exactCwd = resolve(cwd);
+    const sessions = [];
+    for (const filePath of rolloutFiles()) {
+        const meta = firstJsonLine(filePath);
+        const payload = meta?.payload;
+        if (payload?.cwd === exactCwd) {
+            sessions.push(filePath);
+            if (sessions.length >= limit)
+                break;
+        }
+    }
+    return sessions;
+}
+function parseArgs(value) {
+    if (typeof value !== 'string')
+        return value && typeof value === 'object' ? value : {};
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return {};
+    }
+}
+function asString(value) {
+    return typeof value === 'string' ? value : undefined;
+}
+function provenance(sessionPath, source) {
+    return { agent: 'codex', sessionPath, source };
+}
+function commandFromLocalShell(item) {
+    const action = item.action;
+    const command = action?.command;
+    if (Array.isArray(command))
+        return command.map(String).join(' ');
+    return asString(command);
+}
+function patchFiles(patch, cwd) {
+    const paths = [];
+    for (const match of String(patch).matchAll(/^\*\*\* (?:Update|Add|Delete) File: (.+)$/gm)) {
+        for (const filePath of extractFilePaths(match[1].trim(), cwd)) {
+            paths.push(filePath);
+        }
+    }
+    return paths;
+}
+function addMessageAssets(acc, text, cwd, timestamp, meta) {
+    for (const url of extractUrls(text))
+        acc.urls.push(urlAsset(url, timestamp, meta));
+    for (const filePath of extractFilePaths(text, cwd))
+        acc.paths.push(pathAsset(filePath, timestamp, meta));
+    for (const command of extractCommands(text))
+        acc.commands.push(commandAsset(command, timestamp, meta));
+}
+function addExecutedCommandAssets(acc, command, cwd, timestamp, meta) {
+    for (const url of extractUrls(command))
+        acc.urls.push(urlAsset(url, timestamp, meta));
+    for (const filePath of extractFilePaths(command, cwd))
+        acc.paths.push(pathAsset(filePath, timestamp, meta));
+}
+export function readCodexAssets(cwd, limit = 3) {
+    const exactCwd = resolve(cwd);
+    const files = codexSessions(exactCwd, limit);
+    const acc = {
+        urls: [],
+        paths: [],
+        commands: [],
+        plans: [],
+        hadSession: files.length > 0,
+    };
+    const skip = (line) => line.includes('"type":"function_call_output"') ||
+        line.includes('"type":"reasoning"') ||
+        line.includes('"type":"token_count"');
+    for (const filePath of files) {
+        for (const line of readJsonl(filePath, skip)) {
+            const payload = line.payload;
+            if (!payload)
+                continue;
+            const timestamp = asString(line.timestamp);
+            if (payload.type === 'function_call') {
+                if (EXEC_NAMES.has(payload.name)) {
+                    const args = parseArgs(payload.arguments);
+                    addExecutedCommandAssets(acc, args.cmd ?? args.command, exactCwd, timestamp, provenance(filePath, `tool:${String(payload.name)}`));
+                }
+            }
+            else if (payload.type === 'local_shell_call') {
+                addExecutedCommandAssets(acc, commandFromLocalShell(payload), exactCwd, timestamp, provenance(filePath, 'tool:local_shell'));
+            }
+            else if (payload.type === 'item_completed') {
+                const item = payload.item;
+                const text = asString(item?.text);
+                if (item?.type === 'Plan' && text?.trim())
+                    acc.plans.push(planAsset(text, timestamp, provenance(filePath, 'plan')));
+            }
+            else if (payload.type === 'custom_tool_call' && payload.name === 'apply_patch') {
+                const meta = provenance(filePath, 'tool:apply_patch');
+                for (const file of patchFiles(payload.input, exactCwd))
+                    acc.paths.push(pathAsset(file, timestamp, meta));
+            }
+            else if (payload.type === 'message' && Array.isArray(payload.content)) {
+                for (const block of payload.content) {
+                    const typedBlock = block;
+                    addMessageAssets(acc, typedBlock.text, exactCwd, timestamp, provenance(filePath, 'message'));
+                }
+            }
+            else if (payload.type === 'agent_message') {
+                addMessageAssets(acc, payload.message, exactCwd, timestamp, provenance(filePath, 'message'));
+            }
+        }
+    }
+    return acc;
+}

package/dist/esm/extractors/tokenUsage.js

@@ -0,0 +1,41 @@
+/**
+ * Pure extraction of normalized TokenUsage from a SessionEvent.
+ *
+ * Provides a standalone function to extract camelCase TokenUsage from
+ * a raw session event without requiring an EventAggregator instance.
+ *
+ * @module extractors/tokenUsage
+ */
+/**
+ * Extracts normalized TokenUsage from a SessionEvent.
+ *
+ * Looks for `message.usage` on assistant events and normalizes
+ * the snake_case API fields to the camelCase TokenUsage shape.
+ *
+ * @param event - A parsed session event
+ * @returns TokenUsage if the event contains usage data, null otherwise
+ *
+ * @example
+ * ```typescript
+ * const usage = extractTokenUsage(event);
+ * if (usage) {
+ *   console.log(`Input: ${usage.inputTokens}, Output: ${usage.outputTokens}`);
+ * }
+ * ```
+ */
+export function extractTokenUsage(event) {
+    const usage = event.message?.usage;
+    if (!usage)
+        return null;
+    return {
+        inputTokens: usage.input_tokens ?? 0,
+        outputTokens: usage.output_tokens ?? 0,
+        cacheWriteTokens: usage.cache_creation_input_tokens ?? 0,
+        cacheReadTokens: usage.cache_read_input_tokens ?? 0,
+        model: event.message?.model ?? 'unknown',
+        timestamp: new Date(event.timestamp),
+        reportedCost: usage.reported_cost,
+        reasoningTokens: usage.reasoning_tokens,
+        ...(event.message?.usageKind ? { usageKind: event.message.usageKind } : {}),
+    };
+}

package/dist/esm/extractors/toolCall.js

@@ -0,0 +1,142 @@
+/**
+ * Pure extraction of ToolCall objects from a SessionEvent.
+ *
+ * Provides a standalone function to extract tool calls from assistant
+ * message content blocks without requiring an EventAggregator instance.
+ *
+ * @module extractors/toolCall
+ */
+import { categorizeError, extractErrorMessage } from './errorTaxonomy';
+function outputString(value) {
+    if (value == null)
+        return undefined;
+    const text = typeof value === 'string' ? value : JSON.stringify(value, null, 2);
+    return text.length > 5000 ? `${text.slice(0, 5000)}\n...(truncated)` : text;
+}
+/**
+ * Extracts ToolCall objects from a SessionEvent.
+ *
+ * Scans the message content blocks for `tool_use` entries and
+ * returns them as normalized ToolCall objects.
+ *
+ * @param event - A parsed session event
+ * @returns Array of ToolCall objects (empty if none found)
+ *
+ * @example
+ * ```typescript
+ * const calls = extractToolCalls(event);
+ * for (const call of calls) {
+ *   console.log(`${call.name}: ${JSON.stringify(call.input)}`);
+ * }
+ * ```
+ */
+export function extractToolCalls(event) {
+    // Tool calls live in assistant message content blocks
+    if (event.type !== 'assistant')
+        return [];
+    const content = event.message?.content;
+    if (!Array.isArray(content))
+        return [];
+    const timestamp = new Date(event.timestamp);
+    const calls = [];
+    for (const block of content) {
+        if (block && typeof block === 'object' && 'type' in block && block.type === 'tool_use') {
+            const toolBlock = block;
+            if (toolBlock.name) {
+                const isError = toolBlock.is_error === true || toolBlock.error != null;
+                const errorOutput = toolBlock.error ?? toolBlock.output;
+                calls.push({
+                    name: toolBlock.name,
+                    input: toolBlock.input ?? {},
+                    timestamp,
+                    toolUseId: toolBlock.id,
+                    ...(isError
+                        ? {
+                            isError: true,
+                            output: outputString(errorOutput),
+                            errorMessage: extractErrorMessage(errorOutput, toolBlock.name),
+                            errorCategory: categorizeError(errorOutput),
+                        }
+                        : {}),
+                });
+            }
+        }
+    }
+    return calls;
+}
+/**
+ * Stateful shared extractor that correlates provider-normalized tool uses with
+ * their later results. Completed calls always carry the canonical taxonomy.
+ */
+export class ToolCallTracker {
+    pending = new Map();
+    process(event) {
+        const completed = [];
+        for (const call of extractToolCalls(event)) {
+            if (call.toolUseId)
+                this.pending.set(call.toolUseId, call);
+            else
+                completed.push(call);
+        }
+        const topLevel = extractToolCall(event);
+        if (topLevel) {
+            const id = event.message?.id;
+            if (id) {
+                topLevel.toolUseId = id;
+                this.pending.set(id, topLevel);
+            }
+            else {
+                completed.push(topLevel);
+            }
+        }
+        const content = event.message?.content;
+        if (!Array.isArray(content))
+            return completed;
+        for (const block of content) {
+            if (!block ||
+                typeof block !== 'object' ||
+                !('type' in block) ||
+                block.type !== 'tool_result') {
+                continue;
+            }
+            const result = block;
+            if (!result.tool_use_id)
+                continue;
+            const call = this.pending.get(result.tool_use_id);
+            if (!call)
+                continue;
+            this.pending.delete(result.tool_use_id);
+            call.duration =
+                typeof result.duration === 'number'
+                    ? result.duration
+                    : Math.max(0, new Date(event.timestamp).getTime() - call.timestamp.getTime());
+            call.isError = result.is_error === true;
+            call.output = outputString(result.content);
+            if (call.isError) {
+                call.errorMessage = extractErrorMessage(result.content, call.name);
+                call.errorCategory = categorizeError(result.content);
+            }
+            completed.push(call);
+        }
+        return completed;
+    }
+    reset() {
+        this.pending.clear();
+    }
+}
+/**
+ * Extracts a single top-level `tool_use` event.
+ *
+ * This complements `extractToolCalls`, which scans assistant message content
+ * blocks. Some providers normalize tool calls as their own event with
+ * `event.type === 'tool_use'` and `event.tool` populated.
+ */
+export function extractToolCall(event) {
+    if (event.type !== 'tool_use' || !event.tool?.name)
+        return null;
+    return {
+        name: event.tool.name,
+        input: event.tool.input ?? {},
+        timestamp: new Date(event.timestamp),
+    };
+}

package/dist/esm/failingTools.js

@@ -0,0 +1,65 @@
+/**
+ * Failing-tool trend rows shared by the CLI `stats` block and the VS Code
+ * Health tab. Browser-safe: no filesystem access; callers pass the two
+ * windows they read with `getTopFailingTools()`.
+ *
+ * @module failingTools
+ */
+const TREND_TOLERANCE = 0.1;
+/**
+ * Compare the last week against the 30-day weekly average: more than 10%
+ * above is `up`, more than 10% below is `down`, otherwise `flat`. A tool
+ * with no 30-day history but failures this week is `up`.
+ */
+export function failingToolTrend(last7, last30) {
+    const weeklyAverage = last30 / (30 / 7);
+    if (weeklyAverage <= 0)
+        return last7 > 0 ? 'up' : 'flat';
+    const ratio = last7 / weeklyAverage;
+    if (ratio > 1 + TREND_TOLERANCE)
+        return 'up';
+    if (ratio < 1 - TREND_TOLERANCE)
+        return 'down';
+    return 'flat';
+}
+export const FAILING_TOOL_TREND_ARROWS = {
+    up: '↑',
+    down: '↓',
+    flat: '→',
+};
+/**
+ * Merge the 7-day and 30-day windows into one row per tool, ordered by
+ * 7-day failures, then 30-day failures, then name.
+ */
+export function mergeFailingToolWindows(last7, last30) {
+    const rows = new Map();
+    for (const tool of last30) {
+        rows.set(tool.tool, {
+            tool: tool.tool,
+            last7: 0,
+            last30: tool.failures,
+            categories: { ...(tool.categories ?? {}) },
+            trend: 'flat',
+        });
+    }
+    for (const tool of last7) {
+        const row = rows.get(tool.tool);
+        if (row) {
+            row.last7 = tool.failures;
+            // A 7-day count cannot exceed the 30-day one; tolerate windows read at different instants.
+            row.last30 = Math.max(row.last30, tool.failures);
+        }
+        else {
+            rows.set(tool.tool, {
+                tool: tool.tool,
+                last7: tool.failures,
+                last30: tool.failures,
+                categories: { ...(tool.categories ?? {}) },
+                trend: 'flat',
+            });
+        }
+    }
+    for (const row of rows.values())
+        row.trend = failingToolTrend(row.last7, row.last30);
+    return [...rows.values()].sort((a, b) => b.last7 - a.last7 || b.last30 - a.last30 || a.tool.localeCompare(b.tool));
+}

package/dist/esm/fileHead.js

@@ -0,0 +1,27 @@
+/**
+ * Rewrite detection shared by the incremental JSONL readers: a file whose
+ * first bytes changed, or whose resume point no longer follows a newline,
+ * was rewritten rather than appended to.
+ *
+ * @module fileHead
+ */
+import { createHash } from 'crypto';
+/** How many leading bytes identify a file's content. */
+export const HEAD_BYTES = 4096;
+export function hashHead(buffer) {
+    return createHash('sha256').update(buffer).digest('hex').slice(0, 32);
+}
+/** Records the prefix just read (at most `HEAD_BYTES`). */
+export function fileHeadOf(prefix) {
+    return { bytes: prefix.length, hash: hashHead(prefix) };
+}
+/**
+ * True when `prefix` (the file's current first bytes) still starts with the
+ * recorded head. A file that grew past a short head still matches.
+ */
+export function headMatches(known, prefix) {
+    if (!Number.isInteger(known.bytes) || known.bytes < 0 || known.bytes > prefix.length) {
+        return false;
+    }
+    return hashHead(prefix.subarray(0, known.bytes)) === known.hash;
+}