@compilr-dev/cli 0.5.0 → 0.5.1

package/dist/ui/tool-formatters.js

@@ -4,6 +4,7 @@
  * Extracts content, summary, and success from tool results.
  * Each tool type has its own formatter to produce human-readable output.
  */
+import { truncate } from './base/index.js';
 /**
  * Format tool result for display.
  * Handles the agent's structured result format.
@@ -16,6 +17,10 @@ export function formatToolResult(toolName, result) {
         // Check for success/result wrapper
         const success = obj.success !== false;
         const innerResult = (obj.result ?? obj);
+        // Handle delegated results — large tool outputs that were auto-summarized
+        if (innerResult._delegated === true) {
+            return formatDelegated(toolName, innerResult);
+        }
         // Extract content based on tool type
         let content = '';
         let summary = '';
@@ -95,6 +100,84 @@ export function formatToolResult(toolName, result) {
         else if (toolLower === 'task') {
             ({ content, summary } = formatTask(innerResult));
         }
+        else if (toolLower === 'plan_get') {
+            ({ content, summary } = formatPlanGet(innerResult));
+        }
+        else if (toolLower === 'plan_list') {
+            ({ content, summary } = formatPlanList(innerResult));
+        }
+        else if (toolLower === 'plan_create') {
+            ({ content, summary } = formatPlanCreate(innerResult));
+        }
+        else if (toolLower === 'plan_update') {
+            ({ content, summary } = formatPlanUpdate(innerResult));
+        }
+        else if (toolLower === 'plan_delete') {
+            ({ content, summary } = formatPlanDelete(innerResult));
+        }
+        else if (toolLower === 'delegate_background') {
+            ({ content, summary } = formatDelegateBackground(innerResult));
+        }
+        else if (toolLower === 'delegate' || toolLower === 'handoff') {
+            ({ content, summary } = formatDelegate(innerResult));
+        }
+        else if (toolLower === 'todo_claim' || toolLower === 'todo_handoff') {
+            ({ content, summary } = formatTodoClaim(innerResult));
+        }
+        else if (toolLower === 'recall_work') {
+            ({ content, summary } = formatRecallWork(innerResult));
+        }
+        else if (toolLower.startsWith('artifact_')) {
+            ({ content, summary } = formatArtifact(toolLower, innerResult));
+        }
+        else if (toolLower === 'list_tools') {
+            ({ content, summary } = formatListTools(innerResult));
+        }
+        else if (toolLower === 'get_tool_info') {
+            ({ content, summary } = formatGetToolInfo(innerResult));
+        }
+        else if (toolLower === 'git_stash') {
+            ({ content, summary } = formatGitStash(innerResult));
+        }
+        else if (toolLower === 'git_blame') {
+            ({ content, summary } = formatGitBlame(innerResult));
+        }
+        else if (toolLower === 'git_file_history') {
+            ({ content, summary } = formatGitFileHistory(innerResult));
+        }
+        else if (toolLower === 'run_build') {
+            ({ content, summary } = formatRunBuild(innerResult));
+        }
+        else if (toolLower === 'run_format') {
+            ({ content, summary } = formatRunFormat(innerResult));
+        }
+        else if (toolLower === 'find_definition') {
+            ({ content, summary } = formatFindDefinition(innerResult));
+        }
+        else if (toolLower === 'find_references') {
+            ({ content, summary } = formatFindReferences(innerResult));
+        }
+        else if (toolLower === 'find_todos') {
+            ({ content, summary } = formatFindTodos(innerResult));
+        }
+        else if (toolLower === 'check_outdated') {
+            ({ content, summary } = formatCheckOutdated(innerResult));
+        }
+        else if (toolLower === 'find_vulnerabilities') {
+            ({ content, summary } = formatFindVulnerabilities(innerResult));
+        }
+        else if (toolLower === 'analyze_test_coverage') {
+            ({ content, summary } = formatAnalyzeTestCoverage(innerResult));
+        }
+        else if (toolLower === 'get_file_structure') {
+            ({ content, summary } = formatGetFileStructure(innerResult));
+        }
+        else if (toolLower === 'get_complexity') {
+            ({ content, summary } = formatGetComplexity(innerResult));
+        }
+        else if (toolLower === 'read_function' || toolLower === 'read_class' || toolLower === 'read_type') {
+            ({ content, summary } = formatReadSymbol(innerResult));
+        }
         else {
             // Generic handling
             ({ content, summary } = formatGeneric(innerResult));
@@ -458,7 +541,7 @@ function formatProjectDocument(toolName, result) {
         }
         const docType = document.docType || 'unknown';
         const content = document.content || '';
-        const preview = content.length > 200 ? content.slice(0, 200) + '...' : content;
+        const preview = truncate(content, 200);
         return { content: preview, summary: `Document: ${docType}` };
     }
     // Handle document_list - return list of documents
@@ -504,6 +587,421 @@ function formatTask(result) {
     const content = response || '';
     return { content, summary };
 }
+// =============================================================================
+// Plan Formatters
+// =============================================================================
+function formatPlanGet(result) {
+    const plan = result.plan;
+    if (!plan) {
+        const message = result.message;
+        return { content: '', summary: message || 'Plan not found' };
+    }
+    const name = plan.name || 'Unknown';
+    const status = plan.status || 'draft';
+    const planContent = plan.content || '';
+    const workItem = plan.workItem;
+    // Build summary
+    let summary = `${name} [${status}]`;
+    if (workItem) {
+        const itemId = workItem.itemId || '';
+        summary += ` → ${itemId}`;
+    }
+    // For content, show a preview of the plan (first 500 chars with section headers visible)
+    const lines = planContent.split('\n');
+    const previewLines = [];
+    let charCount = 0;
+    const maxChars = 500;
+    for (const line of lines) {
+        if (charCount >= maxChars) {
+            previewLines.push('...');
+            break;
+        }
+        previewLines.push(line);
+        charCount += line.length + 1;
+    }
+    const content = previewLines.join('\n');
+    return { content, summary };
+}
+function formatPlanList(result) {
+    const plans = result.plans;
+    const count = result.count;
+    const statusCounts = result.statusCounts;
+    if (!plans?.length) {
+        return { content: '', summary: 'No plans found' };
+    }
+    // Build summary with status counts
+    let summary = `${String(count ?? plans.length)} plan(s)`;
+    if (statusCounts) {
+        const statuses = [];
+        if (statusCounts.draft)
+            statuses.push(`${String(statusCounts.draft)} draft`);
+        if (statusCounts.approved)
+            statuses.push(`${String(statusCounts.approved)} approved`);
+        if (statusCounts.in_progress)
+            statuses.push(`${String(statusCounts.in_progress)} in progress`);
+        if (statusCounts.completed)
+            statuses.push(`${String(statusCounts.completed)} completed`);
+        if (statuses.length)
+            summary += ` (${statuses.join(', ')})`;
+    }
+    // Build content with plan list
+    const lines = plans.slice(0, 10).map((p) => {
+        const status = p.status ? `[${p.status}]` : '';
+        const workItem = p.workItemItemId ? ` → ${p.workItemItemId}` : '';
+        return `${p.name || '?'} ${status}${workItem}`;
+    });
+    if (plans.length > 10) {
+        lines.push(`... and ${String(plans.length - 10)} more`);
+    }
+    return { content: lines.join('\n'), summary };
+}
+function formatPlanCreate(result) {
+    const message = result.message;
+    const plan = result.plan;
+    if (message) {
+        return { content: '', summary: message };
+    }
+    if (plan) {
+        const name = plan.name || 'Unknown';
+        const id = plan.id;
+        return { content: '', summary: `Created plan: ${name}${id ? ` (ID: ${String(id)})` : ''}` };
+    }
+    return { content: '', summary: 'Plan created' };
+}
+function formatPlanUpdate(result) {
+    const message = result.message;
+    const plan = result.plan;
+    if (message) {
+        return { content: '', summary: message };
+    }
+    if (plan) {
+        const name = plan.name || 'Unknown';
+        const status = plan.status || '';
+        return { content: '', summary: `Updated plan: ${name}${status ? ` [${status}]` : ''}` };
+    }
+    return { content: '', summary: 'Plan updated' };
+}
+function formatPlanDelete(result) {
+    const message = result.message;
+    return { content: '', summary: message || 'Plan deleted' };
+}
+// =============================================================================
+// agents-coding Tool Formatters
+// =============================================================================
+function formatGitStash(result) {
+    const message = result.message;
+    const stashes = result.stashes;
+    if (message) {
+        return { content: '', summary: message };
+    }
+    if (stashes?.length) {
+        const lines = stashes.slice(0, 5).map((s) => `stash@{${String(s.index ?? 0)}}: ${(s.message || '').slice(0, 50)}`);
+        if (stashes.length > 5)
+            lines.push(`... and ${String(stashes.length - 5)} more`);
+        return { content: lines.join('\n'), summary: `${String(stashes.length)} stash(es)` };
+    }
+    return { content: '', summary: 'No stashes' };
+}
+function formatGitBlame(result) {
+    const lines = result.lines;
+    const authors = result.authorSummary;
+    if (authors?.length) {
+        const topAuthors = authors.slice(0, 3).map((a) => `${a.author || '?'}: ${String(a.lines ?? 0)} lines`).join(', ');
+        const summary = `${String(lines?.length ?? 0)} lines, ${topAuthors}`;
+        return { content: '', summary };
+    }
+    return { content: '', summary: `${String(lines?.length ?? 0)} lines analyzed` };
+}
+function formatGitFileHistory(result) {
+    const commits = result.commits;
+    const file = result.file;
+    if (!commits?.length) {
+        return { content: '', summary: 'No history found' };
+    }
+    const summary = `${String(commits.length)} commit(s) for ${file || 'file'}`;
+    const lines = commits.slice(0, 5).map((c) => `${c.shortHash || '?'} ${(c.subject || '').slice(0, 50)}`);
+    if (commits.length > 5)
+        lines.push(`... and ${String(commits.length - 5)} more`);
+    return { content: lines.join('\n'), summary };
+}
+function formatRunBuild(result) {
+    const success = result.success;
+    const command = result.command;
+    const stdout = result.stdout;
+    const status = success === false ? 'Build failed' : 'Build succeeded';
+    const summary = command ? `${status} (${command})` : status;
+    return { content: stdout || '', summary };
+}
+function formatRunFormat(result) {
+    const filesFormatted = result.filesFormatted;
+    const command = result.command;
+    if (filesFormatted !== undefined) {
+        return { content: '', summary: `Formatted ${String(filesFormatted)} file(s)` };
+    }
+    return { content: '', summary: command ? `Ran ${command}` : 'Format complete' };
+}
+function formatFindDefinition(result) {
+    const definitions = result.definitions;
+    if (!definitions?.length) {
+        return { content: '', summary: 'No definitions found' };
+    }
+    const summary = `Found ${String(definitions.length)} definition(s)`;
+    const lines = definitions.slice(0, 5).map((d) => `${d.path || '?'}:${String(d.line ?? 0)} [${d.type || '?'}] ${d.name || ''}`);
+    if (definitions.length > 5)
+        lines.push(`... and ${String(definitions.length - 5)} more`);
+    return { content: lines.join('\n'), summary };
+}
+function formatFindReferences(result) {
+    const references = result.references;
+    const totalCount = result.totalCount;
+    const count = totalCount ?? references?.length ?? 0;
+    if (count === 0) {
+        return { content: '', summary: 'No references found' };
+    }
+    const summary = `Found ${String(count)} reference(s)`;
+    if (references?.length) {
+        const lines = references.slice(0, 5).map((r) => `${r.path || '?'}:${String(r.line ?? 0)}`);
+        if (references.length > 5)
+            lines.push(`... and ${String(references.length - 5)} more`);
+        return { content: lines.join('\n'), summary };
+    }
+    return { content: '', summary };
+}
+function formatFindTodos(result) {
+    const todos = result.todos;
+    if (!todos?.length) {
+        return { content: '', summary: 'No TODOs found' };
+    }
+    const summary = `Found ${String(todos.length)} TODO(s)`;
+    const lines = todos.slice(0, 5).map((t) => `${t.path || '?'}:${String(t.line ?? 0)} [${t.type || 'TODO'}] ${(t.text || '').slice(0, 40)}`);
+    if (todos.length > 5)
+        lines.push(`... and ${String(todos.length - 5)} more`);
+    return { content: lines.join('\n'), summary };
+}
+function formatCheckOutdated(result) {
+    const packages = result.packages;
+    if (!packages?.length) {
+        return { content: '', summary: 'All packages up to date' };
+    }
+    const summary = `${String(packages.length)} outdated package(s)`;
+    const lines = packages.slice(0, 5).map((p) => `${p.name || '?'}: ${p.current || '?'} → ${p.latest || '?'} (${p.type || 'update'})`);
+    if (packages.length > 5)
+        lines.push(`... and ${String(packages.length - 5)} more`);
+    return { content: lines.join('\n'), summary };
+}
+function formatFindVulnerabilities(result) {
+    const vulnerabilities = result.vulnerabilities;
+    if (!vulnerabilities?.length) {
+        return { content: '', summary: 'No vulnerabilities found' };
+    }
+    // Count by severity
+    const bySeverity = {};
+    vulnerabilities.forEach((v) => {
+        const sev = v.severity || 'unknown';
+        bySeverity[sev] = (bySeverity[sev] || 0) + 1;
+    });
+    const sevParts = Object.entries(bySeverity).map(([k, v]) => `${String(v)} ${k}`).join(', ');
+    const summary = `${String(vulnerabilities.length)} vulnerabilities (${sevParts})`;
+    const lines = vulnerabilities.slice(0, 5).map((v) => `[${v.severity || '?'}] ${v.name || '?'}: ${(v.title || '').slice(0, 40)}`);
+    if (vulnerabilities.length > 5)
+        lines.push(`... and ${String(vulnerabilities.length - 5)} more`);
+    return { content: lines.join('\n'), summary };
+}
+function formatAnalyzeTestCoverage(result) {
+    const summary_data = result.summary;
+    const meetsThreshold = result.meetsThreshold;
+    if (summary_data) {
+        const lineCov = summary_data.lines?.pct ?? summary_data.statements?.pct ?? 0;
+        const funcCov = summary_data.functions?.pct ?? 0;
+        const branchCov = summary_data.branches?.pct ?? 0;
+        const status = meetsThreshold === false ? ' (below threshold)' : '';
+        const summary = `Coverage: ${lineCov.toFixed(1)}% lines, ${funcCov.toFixed(1)}% functions, ${branchCov.toFixed(1)}% branches${status}`;
+        return { content: '', summary };
+    }
+    return { content: '', summary: 'Coverage analysis complete' };
+}
+function formatGetFileStructure(result) {
+    const classes = result.classes;
+    const functions = result.functions;
+    const imports = result.imports;
+    const exports = result.exports;
+    const parts = [];
+    if (classes?.length)
+        parts.push(`${String(classes.length)} class(es)`);
+    if (functions?.length)
+        parts.push(`${String(functions.length)} function(s)`);
+    if (imports?.length)
+        parts.push(`${String(imports.length)} import(s)`);
+    if (exports?.length)
+        parts.push(`${String(exports.length)} export(s)`);
+    const summary = parts.length > 0 ? parts.join(', ') : 'Empty file';
+    // Build detailed content
+    const lines = [];
+    if (classes?.length) {
+        lines.push('Classes:');
+        classes.slice(0, 5).forEach((c) => lines.push(`  - ${c.name || '?'}`));
+        if (classes.length > 5)
+            lines.push(`  ... and ${String(classes.length - 5)} more`);
+    }
+    if (functions?.length) {
+        lines.push('Functions:');
+        functions.slice(0, 5).forEach((f) => lines.push(`  - ${f.name || '?'}`));
+        if (functions.length > 5)
+            lines.push(`  ... and ${String(functions.length - 5)} more`);
+    }
+    return { content: lines.join('\n'), summary };
+}
+function formatGetComplexity(result) {
+    const files = result.files;
+    const functions_data = result.functions;
+    if (functions_data?.length) {
+        const highComplexity = functions_data.filter((f) => (f.complexity ?? 0) > 10);
+        if (highComplexity.length > 0) {
+            const summary = `${String(highComplexity.length)} high-complexity function(s)`;
+            const lines = highComplexity.slice(0, 5).map((f) => `${f.name || '?'}: complexity ${String(f.complexity ?? 0)}`);
+            if (highComplexity.length > 5)
+                lines.push(`... and ${String(highComplexity.length - 5)} more`);
+            return { content: lines.join('\n'), summary };
+        }
+        return { content: '', summary: 'All functions within complexity threshold' };
+    }
+    if (files?.length) {
+        const summary = `Analyzed ${String(files.length)} file(s)`;
+        return { content: '', summary };
+    }
+    return { content: '', summary: 'Complexity analysis complete' };
+}
+function formatReadSymbol(result) {
+    const name = result.name;
+    const kind = result.kind;
+    const startLine = result.startLine;
+    const endLine = result.endLine;
+    const codeContent = result.content;
+    const signature = result.signature;
+    const container = result.container;
+    // Build summary: [kind] name (lines X-Y)
+    const kindLabel = kind || 'symbol';
+    const lineRange = startLine && endLine ? ` (lines ${String(startLine)}-${String(endLine)})` : '';
+    const containerInfo = container ? ` in ${container}` : '';
+    const summary = `[${kindLabel}] ${name || '?'}${containerInfo}${lineRange}`;
+    // Content is the actual source code
+    // Format it nicely with line numbers
+    if (codeContent) {
+        const lines = codeContent.split('\n');
+        const start = startLine ?? 1;
+        const numberedLines = lines.map((line, i) => {
+            const lineNum = String(start + i).padStart(4, ' ');
+            return `${lineNum} │ ${line}`;
+        });
+        return { content: numberedLines.join('\n'), summary };
+    }
+    // Fallback to signature if no content
+    if (signature) {
+        return { content: signature, summary };
+    }
+    return { content: '', summary };
+}
+function formatTodoClaim(result) {
+    const message = result.message;
+    return { content: '', summary: message || 'Done' };
+}
+function formatRecallWork(result) {
+    const episodes = result.episodes;
+    const totalEpisodes = result.totalEpisodes;
+    const totalEffort = result.totalEffort;
+    const uncommittedCount = result.uncommittedCount;
+    if (!episodes?.length) {
+        return { content: '', summary: 'No work history' };
+    }
+    // Summary line
+    const uncommittedInfo = uncommittedCount ? `, ${String(uncommittedCount)} uncommitted` : '';
+    const summary = `${String(totalEpisodes ?? episodes.length)} episode(s), effort: ${totalEffort || '?'}${uncommittedInfo}`;
+    // Build detailed content
+    const lines = [];
+    for (const ep of episodes.slice(0, 10)) {
+        const time = ep.timestamp ? new Date(ep.timestamp).toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' }) : '?';
+        const agent = ep.agentId || '?';
+        const action = ep.summary || ep.action || '?';
+        const effort = ep.effort ? `[${ep.effort}]` : '';
+        lines.push(`${time} ${agent} ${effort} ${action}`);
+    }
+    if (episodes.length > 10) {
+        lines.push(`... and ${String(episodes.length - 10)} more`);
+    }
+    return { content: lines.join('\n'), summary };
+}
+function formatArtifact(toolName, result) {
+    const action = toolName.replace('artifact_', '');
+    // artifact_list
+    if (action === 'list') {
+        const content = typeof result.content === 'string' ? result.content : '';
+        const lines = content.split('\n').filter((l) => l.length > 0);
+        // First line is typically "Found N artifacts:"
+        const summary = lines.length > 0 ? lines[0].slice(0, 60) : 'No artifacts';
+        return { content: '', summary };
+    }
+    // artifact_save
+    if (action === 'save') {
+        const content = typeof result.content === 'string' ? result.content : '';
+        const match = /Created artifact "([^"]+)"/.exec(content);
+        return { content: '', summary: match ? `Saved: ${match[1]}` : 'Artifact saved' };
+    }
+    // artifact_get
+    if (action === 'get') {
+        const content = typeof result.content === 'string' ? result.content : '';
+        const match = /Artifact: (.+)/.exec(content);
+        return { content, summary: match ? match[1].slice(0, 60) : 'Artifact retrieved' };
+    }
+    // artifact_delete
+    if (action === 'delete') {
+        const content = typeof result.content === 'string' ? result.content : '';
+        const match = /Deleted artifact "([^"]+)"/.exec(content);
+        return { content: '', summary: match ? `Deleted: ${match[1]}` : 'Artifact deleted' };
+    }
+    // Fallback
+    const message = typeof result.content === 'string' ? result.content.split('\n')[0] : '';
+    return { content: '', summary: message.slice(0, 60) || 'Done' };
+}
+function formatListTools(result) {
+    const count = result.count;
+    const tools = result.tools;
+    if (tools?.length) {
+        const names = tools.slice(0, 8).map((t) => t.name || '?').join(', ');
+        const more = tools.length > 8 ? `, +${String(tools.length - 8)} more` : '';
+        return { content: '', summary: `${String(count ?? tools.length)} tools: ${names}${more}` };
+    }
+    return { content: '', summary: count ? `${String(count)} tools available` : 'No tools' };
+}
+function formatGetToolInfo(result) {
+    const name = result.name;
+    const description = result.description;
+    if (name && description) {
+        // First sentence of description
+        const firstSentence = description.split('.')[0].slice(0, 60);
+        return { content: '', summary: `${name}: ${firstSentence}` };
+    }
+    return { content: '', summary: name || 'Tool info' };
+}
+function formatDelegateBackground(result) {
+    const delegated = result.delegated;
+    const delegationId = result.delegationId;
+    const status = result.status;
+    const message = result.message;
+    const error = result.error;
+    if (error) {
+        return { content: '', summary: error };
+    }
+    if (delegated && delegationId) {
+        const shortId = delegationId.replace('del_', '');
+        const statusLabel = status === 'queued' ? 'queued' : 'running';
+        return { content: '', summary: `${shortId} ${statusLabel}` };
+    }
+    return { content: '', summary: message || 'Delegated' };
+}
+function formatDelegate(result) {
+    const message = result.message;
+    return { content: '', summary: message || 'Delegated' };
+}
 function formatGeneric(result) {
     const content = typeof result.content === 'string'
         ? result.content
@@ -514,3 +1012,16 @@ function formatGeneric(result) {
     const summary = lines.length > 0 ? lines[0].slice(0, 60) : 'Completed';
     return { content, summary };
 }
+function formatDelegated(toolName, result) {
+    const originalTokens = result._originalTokens;
+    const summaryTokens = result._summaryTokens;
+    const summaryText = result.summary;
+    // Summary line: "Delegated (24,921 → 800 tokens)"
+    const tokenInfo = originalTokens && summaryTokens
+        ? ` (${originalTokens.toLocaleString()} → ${summaryTokens.toLocaleString()} tokens)`
+        : '';
+    const summary = `Delegated${tokenInfo}`;
+    // Content: the summary text (truncated for display, full in Ctrl+O)
+    const content = summaryText || `[${toolName} result was auto-summarized to conserve context]`;
+    return { content, summary, success: true };
+}

package/dist/ui/turn-metrics.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Per-turn token and tool call tracking.
+ *
+ * Extracted from TerminalUI — a standalone data container with zero
+ * coupling to other subsystems.
+ */
+export interface TurnMetricsSnapshot {
+    inputTokens: number;
+    outputTokens: number;
+    thinkingTokens: number;
+    cacheReadTokens: number;
+    durationMs: number;
+    toolCalls: number;
+    apiCalls: number;
+    debugPayload?: {
+        systemChars: number;
+        contentsChars: number;
+        toolsChars: number;
+    };
+}
+export declare class TurnMetrics {
+    inputTokens: number;
+    outputTokens: number;
+    thinkingTokens: number;
+    cacheReadTokens: number;
+    debugPayload?: {
+        systemChars: number;
+        contentsChars: number;
+        toolsChars: number;
+    };
+    startTime: number;
+    toolCalls: number;
+    apiCalls: number;
+    isThinking: boolean;
+    /**
+     * Add input/output tokens for live display.
+     * @param thinkingTokens - Optional thinking tokens (Gemini 2.5+ models)
+     * @param cacheReadTokens - Optional cache read tokens (Anthropic/Gemini)
+     * @param debugPayload - Optional debug payload sizes (char counts)
+     */
+    addTokens(inputTokens: number, outputTokens: number, thinkingTokens?: number, cacheReadTokens?: number, debugPayload?: {
+        systemChars: number;
+        contentsChars: number;
+        toolsChars: number;
+    }): void;
+    incrementToolCalls(): void;
+    incrementApiCalls(): void;
+    /**
+     * Reset all metrics (call when agent starts a new turn).
+     */
+    reset(): void;
+    /**
+     * Get a snapshot of current metrics.
+     */
+    getSnapshot(): TurnMetricsSnapshot;
+}

package/dist/ui/turn-metrics.js

@@ -0,0 +1,75 @@
+/**
+ * Per-turn token and tool call tracking.
+ *
+ * Extracted from TerminalUI — a standalone data container with zero
+ * coupling to other subsystems.
+ */
+export class TurnMetrics {
+    inputTokens = 0;
+    outputTokens = 0;
+    thinkingTokens = 0;
+    cacheReadTokens = 0;
+    debugPayload;
+    startTime = 0;
+    toolCalls = 0;
+    apiCalls = 0;
+    isThinking = false;
+    /**
+     * Add input/output tokens for live display.
+     * @param thinkingTokens - Optional thinking tokens (Gemini 2.5+ models)
+     * @param cacheReadTokens - Optional cache read tokens (Anthropic/Gemini)
+     * @param debugPayload - Optional debug payload sizes (char counts)
+     */
+    addTokens(inputTokens, outputTokens, thinkingTokens, cacheReadTokens, debugPayload) {
+        this.inputTokens += inputTokens;
+        this.outputTokens += outputTokens;
+        if (thinkingTokens) {
+            this.thinkingTokens += thinkingTokens;
+        }
+        if (cacheReadTokens) {
+            this.cacheReadTokens += cacheReadTokens;
+        }
+        if (debugPayload) {
+            if (!this.debugPayload) {
+                this.debugPayload = { systemChars: 0, contentsChars: 0, toolsChars: 0 };
+            }
+            this.debugPayload.systemChars += debugPayload.systemChars;
+            this.debugPayload.contentsChars += debugPayload.contentsChars;
+            this.debugPayload.toolsChars += debugPayload.toolsChars;
+        }
+    }
+    incrementToolCalls() {
+        this.toolCalls++;
+    }
+    incrementApiCalls() {
+        this.apiCalls++;
+    }
+    /**
+     * Reset all metrics (call when agent starts a new turn).
+     */
+    reset() {
+        this.inputTokens = 0;
+        this.outputTokens = 0;
+        this.thinkingTokens = 0;
+        this.cacheReadTokens = 0;
+        this.debugPayload = undefined;
+        this.startTime = Date.now();
+        this.toolCalls = 0;
+        this.apiCalls = 0;
+    }
+    /**
+     * Get a snapshot of current metrics.
+     */
+    getSnapshot() {
+        return {
+            inputTokens: this.inputTokens,
+            outputTokens: this.outputTokens,
+            thinkingTokens: this.thinkingTokens,
+            cacheReadTokens: this.cacheReadTokens,
+            durationMs: this.startTime > 0 ? Date.now() - this.startTime : 0,
+            toolCalls: this.toolCalls,
+            apiCalls: this.apiCalls,
+            debugPayload: this.debugPayload,
+        };
+    }
+}