sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/context/sessionContext.js

@@ -0,0 +1,546 @@
+/**
+ * Provider-neutral session context evidence projection.
+ *
+ * Converts canonical SessionEvent streams into a compact manifest suitable for
+ * UI surfaces that need to explain what an assistant/provider has seen.
+ */
+import { EventAggregator } from '../aggregation/EventAggregator';
+import { getModelContextWindowSize } from '../modelContext';
+import { parseMcpToolName } from '../parsers/mcpToolName';
+import { estimateTextTokens } from '../tokenEstimation';
+const DEFAULT_CONTEXT_SOURCE_LIMIT = 200;
+const DEFAULT_SNIPPET_MAX_CHARS = 240;
+const DEFAULT_BODY_MAX_CHARS = 5000;
+const MEDIUM_PRESSURE_RATIO = 0.6;
+const HIGH_PRESSURE_RATIO = 0.8;
+const EMPTY_ATTRIBUTION = {
+    systemPrompt: 0,
+    userMessages: 0,
+    assistantResponses: 0,
+    toolInputs: 0,
+    toolOutputs: 0,
+    thinking: 0,
+    other: 0,
+};
+export function calculateSessionContextPressure(contextTokens, contextWindow) {
+    if (!Number.isFinite(contextTokens) || contextTokens <= 0) {
+        return { pressure: 'low', ratio: 0 };
+    }
+    if (!Number.isFinite(contextWindow) || contextWindow <= 0) {
+        return { pressure: 'low', ratio: 0 };
+    }
+    const ratio = Math.max(0, Math.min(1, contextTokens / contextWindow));
+    if (ratio >= HIGH_PRESSURE_RATIO)
+        return { pressure: 'high', ratio };
+    if (ratio >= MEDIUM_PRESSURE_RATIO)
+        return { pressure: 'medium', ratio };
+    return { pressure: 'low', ratio };
+}
+export function buildSessionContextSnapshot(events, options = {}) {
+    const providerId = options.providerId;
+    const aggregator = new EventAggregator({
+        providerId,
+        computeContextSize: options.computeContextSize,
+    });
+    const sourceState = createSourceExtractionState(options);
+    let lastPermissionMode;
+    let lastRateLimits;
+    for (const event of events) {
+        aggregator.processEvent(event);
+        extractSourcesFromEvent(event, sourceState);
+        if (event.permissionMode)
+            lastPermissionMode = event.permissionMode;
+        if (event.rateLimits)
+            lastRateLimits = event.rateLimits;
+    }
+    return assembleSessionContextSnapshot(aggregator, sourceState, lastPermissionMode, lastRateLimits, options);
+}
+function assembleSessionContextSnapshot(aggregator, sourceState, lastPermissionMode, lastRateLimits, options) {
+    const providerId = options.providerId;
+    const metrics = aggregator.getMetrics();
+    const model = options.model ?? metrics.currentModel ?? metrics.modelStats[0]?.model;
+    const contextWindow = options.contextWindow ??
+        options.contextWindowForModel?.(model) ??
+        getModelContextWindowSize(model);
+    const allSources = sourceState.sources;
+    const limitedSources = limitSources(allSources, options.sourceLimit ?? DEFAULT_CONTEXT_SOURCE_LIMIT);
+    const breakdown = buildLayerBreakdown(limitedSources);
+    const layers = breakdown.map((row) => row.layer);
+    const sourceTokenTotal = allSources.reduce((sum, source) => sum + source.tokenEstimate, 0);
+    const contextTokens = metrics.currentContextSize > 0 ? metrics.currentContextSize : sourceTokenTotal;
+    const { pressure, ratio } = calculateSessionContextPressure(contextTokens, contextWindow);
+    return {
+        schemaVersion: 1,
+        providerId,
+        sessionId: options.sessionId,
+        sessionPath: options.sessionPath,
+        model,
+        contextWindow,
+        contextTokens,
+        pressure,
+        pressureRatio: ratio,
+        layers,
+        breakdown,
+        sources: limitedSources,
+        capabilities: {
+            providerId,
+            providerLabel: options.providerLabel ?? providerLabel(providerId),
+            model,
+            observedTools: [...sourceState.observedTools].sort((a, b) => a.localeCompare(b)),
+            mcpServers: [...sourceState.mcpServers].sort((a, b) => a.localeCompare(b)),
+            permissionMode: lastPermissionMode,
+            rateLimits: lastRateLimits,
+        },
+        attribution: metrics.contextAttribution ?? { ...EMPTY_ATTRIBUTION },
+        tokens: metrics.tokens,
+        compactionCount: metrics.compactionCount,
+        compactionEvents: metrics.compactionEvents,
+        truncationCount: metrics.truncationCount,
+        truncationEvents: metrics.truncationEvents,
+    };
+}
+export function createSessionContextProjector(options = {}) {
+    let aggregator = createProjectorAggregator(options);
+    let sourceState = createSourceExtractionState(options);
+    let lastPermissionMode;
+    let lastRateLimits;
+    const process = (event) => {
+        aggregator.processEvent(event);
+        extractSourcesFromEvent(event, sourceState);
+        if (event.permissionMode)
+            lastPermissionMode = event.permissionMode;
+        if (event.rateLimits)
+            lastRateLimits = event.rateLimits;
+    };
+    const snapshot = () => assembleSessionContextSnapshot(aggregator, sourceState, lastPermissionMode, lastRateLimits, options);
+    return {
+        processEvent(event) {
+            process(event);
+            return snapshot();
+        },
+        processEvents(newEvents) {
+            for (const event of newEvents)
+                process(event);
+            return snapshot();
+        },
+        getSnapshot() {
+            return snapshot();
+        },
+        reset() {
+            aggregator = createProjectorAggregator(options);
+            sourceState = createSourceExtractionState(options);
+            lastPermissionMode = undefined;
+            lastRateLimits = undefined;
+        },
+    };
+}
+function createProjectorAggregator(options) {
+    return new EventAggregator({
+        providerId: options.providerId,
+        computeContextSize: options.computeContextSize,
+    });
+}
+export function readSessionContextSnapshot(provider, sessionPath, options = {}) {
+    const reader = provider.createReader(sessionPath);
+    const events = reader.readAll();
+    const model = options.model ?? latestModel(events);
+    return buildSessionContextSnapshot(events, {
+        ...options,
+        providerId: provider.id,
+        providerLabel: provider.displayName,
+        sessionId: provider.getSessionId(sessionPath),
+        sessionPath,
+        model,
+        contextWindow: options.contextWindow ?? provider.getContextWindowLimit?.(model),
+        computeContextSize: provider.computeContextSize
+            ? (usage) => provider.computeContextSize(usage)
+            : undefined,
+    });
+}
+function createSourceExtractionState(options) {
+    return {
+        options,
+        sources: [],
+        observedTools: new Set(),
+        mcpServers: new Set(),
+        counter: 0,
+    };
+}
+function extractSourcesFromEvent(event, state) {
+    switch (event.type) {
+        case 'system':
+            extractSystemSource(event, state);
+            break;
+        case 'user':
+            extractUserSources(event, state);
+            break;
+        case 'assistant':
+            extractAssistantSources(event, state);
+            break;
+        case 'tool_use':
+            if (event.tool) {
+                addToolInputSource(event, state, event.tool.name, event.tool.input, undefined);
+            }
+            break;
+        case 'tool_result':
+            addSource(state, {
+                event,
+                layer: 'tool outputs',
+                sourceType: event.result?.is_error ? 'error' : 'tool_output',
+                title: event.result?.is_error ? 'Tool error' : 'Tool result',
+                sourceRef: event.result?.tool_use_id,
+                text: stringifyValue(event.result?.output),
+                metadata: { toolUseId: event.result?.tool_use_id },
+            });
+            break;
+        case 'summary':
+            addSource(state, {
+                event,
+                layer: 'summary',
+                sourceType: 'summary',
+                title: 'Context summary',
+                text: extractText(event.message?.content) || 'Context compacted',
+            });
+            break;
+    }
+}
+function extractSystemSource(event, state) {
+    const message = event.message;
+    const text = extractText(message?.content);
+    const label = message?.sourceLabel ?? message?.role ?? 'system';
+    const usage = message?.usage;
+    if (text) {
+        addSource(state, {
+            event,
+            layer: 'system',
+            sourceType: 'system',
+            title: label,
+            sourceRef: message?.id,
+            text,
+        });
+    }
+    if (usage || event.rateLimits) {
+        addSource(state, {
+            event,
+            layer: 'runtime',
+            sourceType: event.rateLimits ? 'rate_limit' : 'runtime',
+            title: event.rateLimits ? 'Runtime usage and rate limits' : 'Runtime usage',
+            sourceRef: message?.id,
+            text: describeUsage(usage, event.rateLimits),
+            metadata: {
+                usage,
+                rateLimits: event.rateLimits,
+            },
+        });
+    }
+}
+function extractUserSources(event, state) {
+    const content = event.message.content;
+    if (Array.isArray(content)) {
+        for (const block of content) {
+            if (block.type === 'tool_result') {
+                const isError = block.is_error === true;
+                addSource(state, {
+                    event,
+                    layer: 'tool outputs',
+                    sourceType: isError ? 'error' : 'tool_output',
+                    title: isError ? 'Tool error' : 'Tool result',
+                    sourceRef: stringValue(block.tool_use_id),
+                    text: stringifyValue(block.content),
+                    metadata: {
+                        toolUseId: block.tool_use_id,
+                        duration: block.duration,
+                    },
+                });
+                continue;
+            }
+            const text = blockText(block);
+            if (text) {
+                addSource(state, {
+                    event,
+                    layer: 'user',
+                    sourceType: 'user_prompt',
+                    title: event.message.sourceLabel ?? 'User prompt',
+                    sourceRef: event.message.id,
+                    text,
+                });
+            }
+        }
+        return;
+    }
+    const text = extractText(content);
+    if (text) {
+        addSource(state, {
+            event,
+            layer: 'user',
+            sourceType: 'user_prompt',
+            title: event.message.sourceLabel ?? 'User prompt',
+            sourceRef: event.message.id,
+            text,
+        });
+    }
+}
+function extractAssistantSources(event, state) {
+    const content = event.message.content;
+    if (!Array.isArray(content)) {
+        const text = extractText(content);
+        if (text) {
+            addSource(state, {
+                event,
+                layer: 'assistant',
+                sourceType: 'assistant_response',
+                title: 'Assistant response',
+                sourceRef: event.message.id,
+                text,
+            });
+        }
+        return;
+    }
+    for (const block of content) {
+        if (block.type === 'tool_use' && typeof block.name === 'string') {
+            addToolInputSource(event, state, block.name, isRecord(block.input) ? block.input : {}, stringValue(block.id));
+            continue;
+        }
+        if (block.type === 'thinking' || block.type === 'reasoning') {
+            const text = blockText(block);
+            if (text) {
+                addSource(state, {
+                    event,
+                    layer: 'thinking',
+                    sourceType: 'thinking',
+                    title: 'Reasoning',
+                    sourceRef: event.message.id,
+                    text,
+                });
+            }
+            continue;
+        }
+        const text = blockText(block);
+        if (text) {
+            addSource(state, {
+                event,
+                layer: 'assistant',
+                sourceType: 'assistant_response',
+                title: 'Assistant response',
+                sourceRef: event.message.id,
+                text,
+            });
+        }
+    }
+}
+function addToolInputSource(event, state, toolName, input, sourceRef) {
+    state.observedTools.add(toolName);
+    const mcpServer = inferMcpServer(toolName, input);
+    if (mcpServer)
+        state.mcpServers.add(mcpServer);
+    const sourceFile = inferSourceFile(input);
+    const command = inferCommand(input);
+    addSource(state, {
+        event,
+        layer: 'tool inputs',
+        sourceType: 'tool_input',
+        title: sourceFile ? `${toolName}: ${sourceFile}` : toolName,
+        sourceRef: sourceRef ?? command,
+        sourceFile,
+        toolName,
+        text: stringifyValue(input),
+        metadata: {
+            rawToolName: input._sidekickRawToolName,
+            mcpServer,
+        },
+    });
+}
+function addSource(state, seed) {
+    const cleanText = clean(seed.text);
+    if (!cleanText)
+        return;
+    const bodyText = seed.text.trim();
+    const snippetMaxChars = state.options.snippetMaxChars ?? DEFAULT_SNIPPET_MAX_CHARS;
+    const bodyMaxChars = state.options.bodyMaxChars ?? DEFAULT_BODY_MAX_CHARS;
+    const bodyInfo = state.options.includeBodies
+        ? truncateWithInfo(bodyText, bodyMaxChars)
+        : undefined;
+    const tokenEstimate = estimateTokens(cleanText);
+    const metadata = {
+        ...(seed.metadata ?? {}),
+        ...(bodyInfo?.truncated ? { bodyTruncated: true, originalChars: bodyText.length } : {}),
+    };
+    state.sources.push({
+        id: `${state.options.sessionId ?? state.options.sessionPath ?? 'session'}:${state.counter++}`,
+        providerId: state.options.providerId,
+        sessionId: state.options.sessionId,
+        sessionPath: state.options.sessionPath,
+        eventType: seed.event.type,
+        timestamp: seed.event.timestamp,
+        layer: seed.layer,
+        sourceType: seed.sourceType,
+        title: seed.title,
+        sourceRef: seed.sourceRef,
+        sourceFile: seed.sourceFile,
+        toolName: seed.toolName,
+        score: seed.score,
+        tokenEstimate,
+        snippet: truncateClean(cleanText, snippetMaxChars),
+        body: bodyInfo?.text,
+        metadata: Object.keys(metadata).length > 0 ? metadata : undefined,
+    });
+}
+function buildLayerBreakdown(sources) {
+    const byLayer = new Map();
+    for (const source of sources) {
+        const row = byLayer.get(source.layer) ?? {
+            layer: source.layer,
+            tokenEstimate: 0,
+            sourceCount: 0,
+        };
+        row.tokenEstimate += source.tokenEstimate;
+        row.sourceCount++;
+        byLayer.set(source.layer, row);
+    }
+    return [...byLayer.values()].sort((a, b) => b.tokenEstimate - a.tokenEstimate);
+}
+function limitSources(sources, limit) {
+    if (!Number.isFinite(limit) || limit <= 0)
+        return [];
+    if (sources.length <= limit)
+        return [...sources];
+    const pinned = sources.filter((source) => source.sourceType === 'system' ||
+        source.sourceType === 'runtime' ||
+        source.sourceType === 'rate_limit');
+    const pinnedLimit = Math.min(pinned.length, Math.max(1, Math.floor(limit / 4)));
+    const pinnedKept = pinned.slice(0, pinnedLimit);
+    const pinnedIds = new Set(pinnedKept.map((source) => source.id));
+    const remaining = sources.filter((source) => !pinnedIds.has(source.id));
+    const latest = remaining.slice(-(limit - pinnedKept.length));
+    const keepIds = new Set([...pinnedKept, ...latest].map((source) => source.id));
+    return sources.filter((source) => keepIds.has(source.id));
+}
+function latestModel(events) {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const model = events[i].message?.model;
+        if (model)
+            return model;
+    }
+    return undefined;
+}
+function providerLabel(providerId) {
+    switch (providerId) {
+        case 'claude-code':
+            return 'Claude Code';
+        case 'codex':
+            return 'Codex';
+        case 'opencode':
+            return 'OpenCode';
+        default:
+            return undefined;
+    }
+}
+function describeUsage(usage, rateLimits) {
+    const parts = [];
+    if (usage) {
+        parts.push(`Input tokens: ${usage.input_tokens || 0}`);
+        parts.push(`Output tokens: ${usage.output_tokens || 0}`);
+        if (usage.cache_read_input_tokens)
+            parts.push(`Cache read: ${usage.cache_read_input_tokens}`);
+        if (usage.cache_creation_input_tokens)
+            parts.push(`Cache write: ${usage.cache_creation_input_tokens}`);
+        if (usage.reasoning_tokens)
+            parts.push(`Reasoning tokens: ${usage.reasoning_tokens}`);
+    }
+    if (rateLimits?.primary) {
+        parts.push(`Primary limit: ${rateLimits.primary.usedPercent}% used`);
+    }
+    if (rateLimits?.secondary) {
+        parts.push(`Secondary limit: ${rateLimits.secondary.usedPercent}% used`);
+    }
+    return parts.join('\n') || 'Runtime metadata';
+}
+function inferSourceFile(input) {
+    for (const key of ['file_path', 'path', 'filename', 'notebook_path', 'target_file']) {
+        const value = input[key];
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+    }
+    const files = input.files;
+    if (Array.isArray(files)) {
+        const first = files.find((value) => typeof value === 'string' && value.trim());
+        if (typeof first === 'string')
+            return first.trim();
+    }
+    return undefined;
+}
+function inferCommand(input) {
+    const command = input.command ?? input.cmd;
+    if (typeof command === 'string' && command.trim())
+        return command.trim();
+    if (Array.isArray(command)) {
+        return (command
+            .map((part) => String(part))
+            .join(' ')
+            .trim() || undefined);
+    }
+    return undefined;
+}
+function inferMcpServer(toolName, input) {
+    const explicit = input._sidekickMcpServerName ?? input.server_name ?? input.serverName;
+    if (typeof explicit === 'string' && explicit.trim())
+        return explicit.trim();
+    return parseMcpToolName(toolName)?.serverName;
+}
+function extractText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((block) => (isRecord(block) ? blockText(block) : ''))
+            .filter(Boolean)
+            .join('\n');
+    }
+    if (content == null)
+        return '';
+    return stringifyValue(content);
+}
+function blockText(block) {
+    for (const key of ['text', 'thinking', 'content']) {
+        const value = block[key];
+        if (typeof value === 'string')
+            return value;
+    }
+    return '';
+}
+function stringifyValue(value) {
+    if (value == null)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function clean(text) {
+    return text.replace(/\s+/g, ' ').trim();
+}
+function truncateClean(text, maxChars) {
+    return truncateWithInfo(text, maxChars).text;
+}
+function truncateWithInfo(text, maxChars) {
+    if (!Number.isFinite(maxChars) || maxChars <= 0)
+        return { text: '', truncated: text.length > 0 };
+    if (text.length <= maxChars)
+        return { text, truncated: false };
+    if (maxChars <= 3)
+        return { text: text.slice(0, maxChars), truncated: true };
+    return { text: `${text.slice(0, maxChars - 3)}...`, truncated: true };
+}
+function estimateTokens(text) {
+    return estimateTextTokens(text).count;
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}