sidekick-shared 0.27.6 → 0.28.0

package/dist/esm/turns/assistantTurn.js

@@ -0,0 +1,373 @@
+import { formatToolSummary, truncate } from '../formatters/toolSummary';
+const DEFAULT_NARRATION_CHARS = 4000;
+const DEFAULT_REASONING_CHARS = 8000;
+const DEFAULT_PROCESS_STEPS = 60;
+const DEFAULT_REASONING_BLOCKS = 24;
+const DEFAULT_TOOL_INPUT_CHARS = 200;
+const SUBAGENT_TOOL_NAMES = new Set(['Task']);
+const LABEL_MAX = 80;
+const TITLE_RE = /^\s*\*\*([^*\n]+)\*\*[ \t]*(?:\n+([\s\S]*))?$/;
+const TITLE_MAX = 100;
+export function reasoningSummary(text) {
+    const normalized = text.replace(/\r\n/g, '\n');
+    const trimmed = normalized.trim();
+    if (trimmed === '')
+        return { title: null, body: '' };
+    const match = TITLE_RE.exec(normalized);
+    if (match) {
+        const title = match[1].trim();
+        if (title !== '' && title.length <= TITLE_MAX) {
+            return { title, body: (match[2] ?? '').trim() };
+        }
+    }
+    return { title: null, body: trimmed };
+}
+export function isAssistantTurnSubagentTool(toolName) {
+    return toolName != null && SUBAGENT_TOOL_NAMES.has(toolName);
+}
+export function segmentAssistantTurn(events, options = {}) {
+    const maxNarrationChars = options.maxNarrationChars ?? DEFAULT_NARRATION_CHARS;
+    const maxReasoningChars = options.maxReasoningChars ?? DEFAULT_REASONING_CHARS;
+    const maxProcessSteps = options.maxProcessSteps ?? DEFAULT_PROCESS_STEPS;
+    const maxReasoningBlocks = options.maxReasoningBlocks ?? DEFAULT_REASONING_BLOCKS;
+    const subagentStatus = options.subagentStatus ?? 'completed';
+    const reasoningParts = [];
+    const steps = [];
+    const timelineItems = [];
+    let textBuffer = [];
+    let toolGroup = null;
+    function closeToolGroup() {
+        if (toolGroup != null && toolGroup.tools.length > 0) {
+            const processStepIndex = steps.length;
+            steps.push(toolGroup);
+            timelineItems.push({ kind: 'toolGroup', tools: toolGroup.tools, processStepIndex });
+        }
+        toolGroup = null;
+    }
+    function sealTextAsNarration() {
+        const text = joinText(textBuffer);
+        if (text !== '') {
+            const processStepIndex = steps.length;
+            const step = { kind: 'narration', text: capText(text, maxNarrationChars) };
+            steps.push(step);
+            timelineItems.push({ kind: 'narration', text: step.text, processStepIndex });
+        }
+        textBuffer = [];
+    }
+    for (const event of events) {
+        switch (event.eventType) {
+            case 'text': {
+                if (event.content.trim() === '')
+                    break;
+                closeToolGroup();
+                textBuffer.push(event.content);
+                break;
+            }
+            case 'thinking': {
+                if (event.content.trim() === '')
+                    break;
+                sealTextAsNarration();
+                closeToolGroup();
+                const reasoningIndex = reasoningParts.length;
+                reasoningParts.push(event.content);
+                timelineItems.push({
+                    kind: 'reasoning',
+                    text: capText(event.content, maxReasoningChars),
+                    reasoningIndex,
+                });
+                break;
+            }
+            case 'tool_use': {
+                sealTextAsNarration();
+                if (toolGroup == null)
+                    toolGroup = { kind: 'toolGroup', tools: [] };
+                const toolName = event.toolName ?? 'tool';
+                const tool = { toolName };
+                const toolInput = formatTurnToolInput(toolName, event.toolInput, event.toolUseId, options);
+                if (toolInput != null && toolInput !== '')
+                    tool.toolInput = toolInput;
+                if (event.toolUseId != null && event.toolUseId !== '')
+                    tool.toolUseId = event.toolUseId;
+                toolGroup.tools.push(tool);
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    const answer = joinText(textBuffer);
+    closeToolGroup();
+    const cappedReasoning = capReasoningBlocks(reasoningParts.map((part) => capText(part, maxReasoningChars)), maxReasoningBlocks);
+    const cappedProcess = capProcessSteps(steps, maxProcessSteps);
+    const process = { steps: cappedProcess.steps };
+    return {
+        schemaVersion: 2,
+        answer,
+        reasoning: capText(joinText(reasoningParts), maxReasoningChars),
+        reasoningBlocks: cappedReasoning.blocks,
+        process,
+        timeline: capTimelineItems(timelineItems, cappedReasoning, cappedProcess),
+        subagents: extractTurnSubagents(flattenProcessTools(process), { status: subagentStatus }),
+    };
+}
+export function assistantTurnEventsFromSessionEvents(events) {
+    const result = [];
+    for (const event of events) {
+        if (event.type === 'assistant') {
+            appendMessageContentEvents(result, event.message.content);
+            continue;
+        }
+        if (event.type === 'tool_use' && event.tool != null) {
+            result.push({
+                eventType: 'tool_use',
+                content: '',
+                toolName: event.tool.name,
+                toolInput: event.tool.input,
+            });
+            continue;
+        }
+        if (event.type === 'tool_result') {
+            result.push({
+                eventType: 'tool_result',
+                content: stringifyValue(event.result?.output),
+                toolUseId: event.result?.tool_use_id,
+            });
+        }
+    }
+    return result;
+}
+export function extractTurnSubagents(tools, options) {
+    const result = [];
+    for (const tool of tools) {
+        if (!isAssistantTurnSubagentTool(tool.toolName))
+            continue;
+        const input = parseSubagentInput(tool.toolInput);
+        const index = result.length;
+        const label = capLabel(input.description ?? input.agentType ?? `Agent ${index + 1}`);
+        const ref = {
+            id: tool.toolUseId && tool.toolUseId !== '' ? tool.toolUseId : `subagent-${index}`,
+            label,
+            status: options.status,
+        };
+        if (input.agentType != null)
+            ref.agentType = input.agentType;
+        result.push(ref);
+    }
+    return result;
+}
+function appendMessageContentEvents(result, content) {
+    if (typeof content === 'string') {
+        if (content !== '')
+            result.push({ eventType: 'text', content });
+        return;
+    }
+    if (!Array.isArray(content))
+        return;
+    for (const block of content) {
+        if (!isRecord(block))
+            continue;
+        const type = stringValue(block.type);
+        if (type === 'text') {
+            const text = stringValue(block.text) ?? stringValue(block.content);
+            if (text != null)
+                result.push({ eventType: 'text', content: text });
+            continue;
+        }
+        if (type === 'thinking' || type === 'reasoning') {
+            const text = stringValue(block.thinking) ?? stringValue(block.text) ?? stringValue(block.content);
+            if (text != null)
+                result.push({ eventType: 'thinking', content: text });
+            continue;
+        }
+        if (type === 'tool_use') {
+            const toolName = stringValue(block.name) ?? 'tool';
+            const event = {
+                eventType: 'tool_use',
+                content: '',
+                toolName,
+                toolInput: block.input,
+            };
+            const toolUseId = stringValue(block.id);
+            if (toolUseId != null)
+                event.toolUseId = toolUseId;
+            result.push(event);
+            continue;
+        }
+        if (type === 'tool_result') {
+            const event = {
+                eventType: 'tool_result',
+                content: stringifyValue(block.content),
+            };
+            const toolUseId = stringValue(block.tool_use_id);
+            if (toolUseId != null)
+                event.toolUseId = toolUseId;
+            result.push(event);
+        }
+    }
+}
+function formatTurnToolInput(toolName, toolInput, toolUseId, options) {
+    if (options.sanitizeToolInput != null) {
+        return options.sanitizeToolInput({ toolName, toolInput, toolUseId });
+    }
+    if (toolInput == null)
+        return undefined;
+    const maxChars = options.toolInputMaxChars ?? DEFAULT_TOOL_INPUT_CHARS;
+    if (isAssistantTurnSubagentTool(toolName)) {
+        const input = parseSubagentInput(toolInput);
+        const projection = {};
+        if (input.agentType != null)
+            projection.subagent_type = truncate(input.agentType, LABEL_MAX);
+        if (input.description != null)
+            projection.description = truncate(input.description, maxChars);
+        return JSON.stringify(projection);
+    }
+    const record = coerceRecord(toolInput);
+    if (record != null) {
+        const summary = formatToolSummary(toolName, record);
+        return summary === '' ? undefined : truncate(summary, maxChars);
+    }
+    if (typeof toolInput === 'string') {
+        return truncate(toolInput, maxChars);
+    }
+    return truncate(stringifyValue(toolInput), maxChars);
+}
+function flattenProcessTools(process) {
+    const result = [];
+    for (const step of process.steps) {
+        if (step.kind === 'toolGroup')
+            result.push(...step.tools);
+    }
+    return result;
+}
+function capProcessSteps(steps, maxRetainedSteps) {
+    const retainedIndexes = new Set();
+    if (!Number.isFinite(maxRetainedSteps) || maxRetainedSteps < 0)
+        return { steps: [], retainedIndexes };
+    const retainedCount = Math.floor(maxRetainedSteps);
+    if (steps.length <= retainedCount) {
+        steps.forEach((_step, index) => retainedIndexes.add(index));
+        return { steps, retainedIndexes };
+    }
+    const firstKeptIndex = Math.max(steps.length - retainedCount, 0);
+    const kept = retainedCount > 0 ? steps.slice(firstKeptIndex) : [];
+    for (let index = firstKeptIndex; index < steps.length; index += 1) {
+        retainedIndexes.add(index);
+    }
+    const omitted = steps.length - kept.length;
+    const omittedMarker = `... ${omitted} earlier process step${omitted === 1 ? '' : 's'} omitted`;
+    return {
+        steps: [{ kind: 'narration', text: omittedMarker }, ...kept],
+        retainedIndexes,
+        omittedMarker,
+    };
+}
+function capReasoningBlocks(blocks, maxRetainedBlocks) {
+    const retainedIndexes = new Set();
+    if (!Number.isFinite(maxRetainedBlocks) || maxRetainedBlocks < 0)
+        return { blocks: [], retainedIndexes };
+    const retainedCount = Math.floor(maxRetainedBlocks);
+    if (blocks.length <= retainedCount) {
+        blocks.forEach((_block, index) => retainedIndexes.add(index));
+        return { blocks, retainedIndexes };
+    }
+    const kept = retainedCount > 0 ? blocks.slice(0, retainedCount) : [];
+    for (let index = 0; index < kept.length; index += 1) {
+        retainedIndexes.add(index);
+    }
+    const omitted = blocks.length - kept.length;
+    const omittedMarker = `... ${omitted} more reasoning block${omitted === 1 ? '' : 's'} omitted`;
+    return { blocks: [...kept, omittedMarker], retainedIndexes, omittedMarker };
+}
+function capTimelineItems(items, reasoning, process) {
+    const result = [];
+    let insertedReasoningOmission = false;
+    let insertedProcessOmission = false;
+    for (const item of items) {
+        if (item.kind === 'reasoning') {
+            if (reasoning.retainedIndexes.has(item.reasoningIndex)) {
+                result.push({ kind: 'reasoning', text: item.text });
+            }
+            else if (reasoning.omittedMarker != null && !insertedReasoningOmission) {
+                result.push({ kind: 'reasoning', text: reasoning.omittedMarker });
+                insertedReasoningOmission = true;
+            }
+            continue;
+        }
+        if (!process.retainedIndexes.has(item.processStepIndex)) {
+            if (process.omittedMarker != null && !insertedProcessOmission) {
+                result.push({ kind: 'narration', text: process.omittedMarker });
+                insertedProcessOmission = true;
+            }
+            continue;
+        }
+        if (process.omittedMarker != null && !insertedProcessOmission) {
+            result.push({ kind: 'narration', text: process.omittedMarker });
+            insertedProcessOmission = true;
+        }
+        if (item.kind === 'narration') {
+            result.push({ kind: 'narration', text: item.text });
+        }
+        else {
+            result.push({ kind: 'toolGroup', tools: item.tools });
+        }
+    }
+    return result;
+}
+function parseSubagentInput(input) {
+    const record = coerceRecord(input);
+    if (record == null)
+        return {};
+    const description = stringValue(record.description)?.trim();
+    const agentType = (stringValue(record.subagent_type) ?? stringValue(record.subagentType))?.trim();
+    return {
+        ...(description != null && description !== '' ? { description } : {}),
+        ...(agentType != null && agentType !== '' ? { agentType } : {}),
+    };
+}
+function coerceRecord(value) {
+    if (isRecord(value))
+        return value;
+    if (typeof value !== 'string' || value.trim() === '')
+        return null;
+    try {
+        const parsed = JSON.parse(value);
+        return isRecord(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function capLabel(label) {
+    return label.length <= LABEL_MAX ? label : `${label.slice(0, LABEL_MAX - 3).trimEnd()}...`;
+}
+function capText(text, maxChars) {
+    if (!Number.isFinite(maxChars) || maxChars < 0)
+        return '';
+    const limit = Math.floor(maxChars);
+    if (text.length <= limit)
+        return text;
+    if (limit <= 3)
+        return '.'.repeat(limit);
+    return `${text.slice(0, limit - 3).trimEnd()}...`;
+}
+function joinText(parts) {
+    return parts.filter((part) => part.trim() !== '').join('\n\n');
+}
+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 : undefined;
+}
+function isRecord(value) {
+    return value != null && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/esm/types/codex.js

@@ -0,0 +1,23 @@
+/**
+ * @fileoverview Type definitions for Codex CLI (OpenAI) session rollout format.
+ *
+ * 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.
+ *
+ * Each line is a JSON object: { timestamp, type, payload }
+ * with 5 top-level types: session_meta, response_item, compacted, turn_context, event_msg.
+ *
+ * @module types/codex
+ */
+/**
+ * Codex reports several rate-limit families per session, keyed by `limit_id`.
+ * The aggregate plan quota — what the usage API surfaces — is `limit_id: "codex"`
+ * (or absent on older payloads). Model/feature-specific families (e.g.
+ * `codex_bengalfox`, `premium`) report their own windows and can read 0% while the
+ * plan is heavily used, so they must never mask the aggregate in the standard
+ * quota view. Returns true only for the aggregate family.
+ */
+export function isAggregateCodexLimit(limitId) {
+    return !limitId || limitId === 'codex';
+}

package/dist/esm/types/decisionLog.js

@@ -0,0 +1,5 @@
+/**
+ * On-disk schema types for cross-session decision log.
+ * Canonical source: sidekick-vscode/src/types/decisionLog.ts
+ */
+export const DECISION_LOG_SCHEMA_VERSION = 1;

package/dist/esm/types/historicalData.js

@@ -0,0 +1,47 @@
+/**
+ * On-disk schema types for historical session data.
+ * Canonical source: sidekick-vscode/src/types/historicalData.ts
+ *
+ * Schema version 2 (2026-04-17) adds optional pricing-honesty fields:
+ *   - ModelUsageRecord.priced: false when the model had no known pricing
+ *     at the time the record was written. When false, `cost` is 0 and UIs
+ *     render "—".
+ *   - SessionSummary.unpricedModelIds: list of model IDs that fell back to
+ *     $0 because pricing was unknown — surfaced in the dashboard footer.
+ * Legacy records (schemaVersion 1 or missing) have neither field and should
+ * be treated as fully priced.
+ *
+ * Schema version 3 (2026-07-18) adds a capped per-session record list with
+ * provider/project dimensions, beta quality factors, churn, and impact cost.
+ */
+export const HISTORICAL_DATA_SCHEMA_VERSION = 3;
+export const HISTORICAL_SESSION_RETENTION_LIMIT = 500;
+export function createEmptyTokenTotals() {
+    return {
+        inputTokens: 0,
+        outputTokens: 0,
+        cacheWriteTokens: 0,
+        cacheReadTokens: 0,
+    };
+}
+export function createEmptyDataStore() {
+    const now = new Date().toISOString();
+    return {
+        schemaVersion: HISTORICAL_DATA_SCHEMA_VERSION,
+        daily: {},
+        monthly: {},
+        sessions: [],
+        allTime: {
+            tokens: createEmptyTokenTotals(),
+            totalCost: 0,
+            messageCount: 0,
+            sessionCount: 0,
+            firstDate: '',
+            lastDate: '',
+            modelUsage: [],
+            toolUsage: [],
+            updatedAt: now,
+        },
+        lastSaved: now,
+    };
+}

package/dist/esm/types/knowledgeNote.js

@@ -0,0 +1,15 @@
+/**
+ * On-disk schema types for knowledge notes.
+ * Canonical source: sidekick-vscode/src/types/knowledgeNote.ts
+ */
+export const KNOWLEDGE_NOTE_SCHEMA_VERSION = 1;
+export const IMPORTANCE_DECAY_FACTORS = {
+    critical: 2.0,
+    high: 1.5,
+    medium: 1.0,
+    low: 0.5,
+};
+export const STALENESS_THRESHOLDS = {
+    needsReview: 30,
+    stale: 90,
+};