@compilr-dev/cli 0.4.0 → 0.5.1

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,
+        };
+    }
+}

package/dist/ui/types.d.ts

@@ -25,12 +25,40 @@ export interface TodoItem {
     content: string;
     status: 'pending' | 'in_progress' | 'completed';
     activeForm?: string;
+    owner?: string;
+    blockedBy?: number[];
 }
+import type { TokenBreakdown as _TokenBreakdown } from '../utils/token-types.js';
+export type { TokenBreakdown } from '../utils/token-types.js';
+export { emptyTokenBreakdown } from '../utils/token-types.js';
+type TokenBreakdown = _TokenBreakdown;
 export interface SpinnerState {
     text: string;
     tool?: string;
     tokens: number;
+    inputTokens: number;
+    outputTokens: number;
     startTime: number;
+    breakdown?: TokenBreakdown;
+}
+export interface TurnMetrics {
+    turnNumber: number;
+    inputTokens: number;
+    outputTokens: number;
+    /** Thinking tokens (Gemini 2.5+ models) */
+    thinkingTokens: number;
+    /** Cache read tokens (Anthropic/Gemini) */
+    cacheReadTokens: number;
+    subagentInputTokens: number;
+    subagentOutputTokens: number;
+    toolCalls: number;
+    durationMs: number;
+    /** Debug payload info - char counts sent to provider (for debugging token discrepancies) */
+    debugPayload?: {
+        systemChars: number;
+        contentsChars: number;
+        toolsChars: number;
+    };
 }
 export interface CommandOption {
     command: string;

package/dist/ui/types.js

@@ -3,6 +3,7 @@
  *
  * Shared types used across all UI modules.
  */
+export { emptyTokenBreakdown } from '../utils/token-types.js';
 /**
  * Get display info for a mode
  */

package/dist/ui/vscode-diff-ipc.d.ts

@@ -0,0 +1,102 @@
+/**
+ * VS Code Diff IPC
+ *
+ * File-based IPC protocol for communicating diff requests/responses between
+ * the CLI and the compilr-diff-companion VS Code extension.
+ *
+ * Directory structure:
+ *   ~/.compilr-dev/diff-ipc/
+ *     requests/   - CLI writes request JSON files
+ *     responses/  - Extension writes response JSON files
+ *
+ * Temp files for original/modified content in os.tmpdir()/compilr-diff/
+ *
+ * Domain layer — imports from foundation layer only.
+ */
+export interface VSDiffRequest {
+    id: string;
+    sessionId: string;
+    agentId: string;
+    sessionLabel: string;
+    originalPath: string;
+    modifiedPath: string;
+    targetPath: string;
+    toolName: string;
+    title: string;
+    timestamp: number;
+}
+export interface VSDiffResponse {
+    id: string;
+    accepted: boolean;
+    cancelled?: boolean;
+    timestamp: number;
+}
+/**
+ * Generate a unique diff request ID.
+ * Format: diff-{sessionPrefix}-{timestamp}
+ */
+export declare function generateDiffRequestId(sessionPrefix: string): string;
+/**
+ * Write original and modified content to temp files for VS Code's diff view.
+ * Returns { originalPath, modifiedPath }.
+ */
+export declare function writeTempDiffFiles(requestId: string, originalContent: string, modifiedContent: string, targetPath: string): {
+    originalPath: string;
+    modifiedPath: string;
+};
+/**
+ * Send a diff request to the VS Code extension.
+ * Writes the request JSON to diff-ipc/requests/.
+ */
+export declare function sendDiffRequest(request: VSDiffRequest): void;
+/**
+ * Result of waitForDiffResponse — includes an abort function to stop the poll.
+ * Abort MUST be called when the terminal wins the Promise.race, BEFORE calling
+ * cancelDiffRequest, to prevent the CLI poll from eating the cancel response
+ * before the VS Code extension can read it.
+ */
+export interface DiffResponseWaiter {
+    promise: Promise<VSDiffResponse | null>;
+    abort: () => void;
+}
+/**
+ * Poll for a diff response from the VS Code extension.
+ * Checks diff-ipc/responses/ at 200ms intervals for a matching response file.
+ * Returns { promise, abort } — call abort() to stop the poll early.
+ */
+export declare function waitForDiffResponse(requestId: string, timeoutMs: number): DiffResponseWaiter;
+/**
+ * Cancel a diff request.
+ * Writes a cancel response so the extension closes the diff tab.
+ * Temp file cleanup is deferred (2s) to give the extension time to
+ * read the cancel response and close the tab before the files disappear.
+ */
+export declare function cancelDiffRequest(requestId: string): void;
+/**
+ * Clean up all IPC files for a specific session prefix.
+ * Called when a terminal session unregisters.
+ */
+export declare function cleanupSessionDiffs(sessionPrefix: string): void;
+/**
+ * Clean up stale IPC files older than the given threshold.
+ * Called on CLI startup to prevent accumulation from crashed sessions.
+ */
+export declare function cleanupStaleDiffs(maxAgeMs: number): void;
+/**
+ * Open a VS Code diff tab for a tool permission request.
+ *
+ * Computes original/modified content from the tool input, writes temp files,
+ * and sends the IPC request for the compilr-diff-companion extension.
+ *
+ * Caller is responsible for checking isVSDiffAvailable() / vsDiffEnabled
+ * before calling this function.
+ *
+ * @returns The diff request ID (for use with waitForDiffResponse/cancelDiffRequest),
+ *          or null if content could not be computed.
+ */
+export declare function openVSCodeDiffForTool(options: {
+    toolName: string;
+    input: Record<string, unknown>;
+    agentId?: string;
+    sessionId?: string;
+}): string | null;

package/dist/ui/vscode-diff-ipc.js

@@ -0,0 +1,385 @@
+/**
+ * VS Code Diff IPC
+ *
+ * File-based IPC protocol for communicating diff requests/responses between
+ * the CLI and the compilr-diff-companion VS Code extension.
+ *
+ * Directory structure:
+ *   ~/.compilr-dev/diff-ipc/
+ *     requests/   - CLI writes request JSON files
+ *     responses/  - Extension writes response JSON files
+ *
+ * Temp files for original/modified content in os.tmpdir()/compilr-diff/
+ *
+ * Domain layer — imports from foundation layer only.
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { getDataPath } from '../settings/paths.js';
+import { computeModifiedContent } from './diff.js';
+// =============================================================================
+// Paths
+// =============================================================================
+function getIpcBasePath() {
+    return path.join(getDataPath(), 'diff-ipc');
+}
+function getRequestsDir() {
+    return path.join(getIpcBasePath(), 'requests');
+}
+function getResponsesDir() {
+    return path.join(getIpcBasePath(), 'responses');
+}
+function getTempDir() {
+    return path.join(os.tmpdir(), 'compilr-diff');
+}
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+}
+// =============================================================================
+// Request ID Generation
+// =============================================================================
+/**
+ * Generate a unique diff request ID.
+ * Format: diff-{sessionPrefix}-{timestamp}
+ */
+export function generateDiffRequestId(sessionPrefix) {
+    return `diff-${sessionPrefix}-${String(Date.now())}`;
+}
+// =============================================================================
+// Temp File Management
+// =============================================================================
+/**
+ * Write original and modified content to temp files for VS Code's diff view.
+ * Returns { originalPath, modifiedPath }.
+ */
+export function writeTempDiffFiles(requestId, originalContent, modifiedContent, targetPath) {
+    const tmpDir = getTempDir();
+    ensureDir(tmpDir);
+    const ext = path.extname(targetPath) || '.txt';
+    const basename = path.basename(targetPath, ext);
+    const originalPath = path.join(tmpDir, `${basename}.original-${requestId}${ext}`);
+    const modifiedPath = path.join(tmpDir, `${basename}.modified-${requestId}${ext}`);
+    fs.writeFileSync(originalPath, originalContent, 'utf-8');
+    fs.writeFileSync(modifiedPath, modifiedContent, 'utf-8');
+    return { originalPath, modifiedPath };
+}
+/**
+ * Clean up temp files for a specific request.
+ */
+function cleanupTempFiles(requestId) {
+    const tmpDir = getTempDir();
+    if (!fs.existsSync(tmpDir))
+        return;
+    try {
+        const files = fs.readdirSync(tmpDir);
+        for (const file of files) {
+            if (file.includes(requestId)) {
+                try {
+                    fs.unlinkSync(path.join(tmpDir, file));
+                }
+                catch {
+                    // Best effort
+                }
+            }
+        }
+    }
+    catch {
+        // Best effort
+    }
+}
+// =============================================================================
+// IPC API
+// =============================================================================
+/**
+ * Send a diff request to the VS Code extension.
+ * Writes the request JSON to diff-ipc/requests/.
+ */
+export function sendDiffRequest(request) {
+    const requestsDir = getRequestsDir();
+    ensureDir(requestsDir);
+    const filePath = path.join(requestsDir, `${request.id}.json`);
+    fs.writeFileSync(filePath, JSON.stringify(request, null, 2), 'utf-8');
+}
+/**
+ * Poll for a diff response from the VS Code extension.
+ * Checks diff-ipc/responses/ at 200ms intervals for a matching response file.
+ * Returns { promise, abort } — call abort() to stop the poll early.
+ */
+export function waitForDiffResponse(requestId, timeoutMs) {
+    const responsesDir = getResponsesDir();
+    ensureDir(responsesDir);
+    const responsePath = path.join(responsesDir, `${requestId}.json`);
+    let aborted = false;
+    const promise = new Promise((resolve) => {
+        const startTime = Date.now();
+        const poll = setInterval(() => {
+            // If aborted (terminal won the race), stop immediately
+            if (aborted) {
+                clearInterval(poll);
+                resolve(null);
+                return;
+            }
+            // Check for timeout
+            if (Date.now() - startTime > timeoutMs) {
+                clearInterval(poll);
+                resolve(null);
+                return;
+            }
+            // Check for response file
+            try {
+                if (fs.existsSync(responsePath)) {
+                    const content = fs.readFileSync(responsePath, 'utf-8');
+                    const response = JSON.parse(content);
+                    // Clean up response file (only if this is a real response from the extension,
+                    // not a cancel response written by the CLI)
+                    if (!response.cancelled) {
+                        try {
+                            fs.unlinkSync(responsePath);
+                        }
+                        catch {
+                            // Best effort
+                        }
+                    }
+                    clearInterval(poll);
+                    resolve(response);
+                }
+            }
+            catch {
+                // File may be partially written, retry next tick
+            }
+        }, 200);
+        // Don't let the poll interval keep the process alive
+        poll.unref();
+    });
+    return {
+        promise,
+        abort: () => { aborted = true; },
+    };
+}
+/**
+ * Cancel a diff request.
+ * Writes a cancel response so the extension closes the diff tab.
+ * Temp file cleanup is deferred (2s) to give the extension time to
+ * read the cancel response and close the tab before the files disappear.
+ */
+export function cancelDiffRequest(requestId) {
+    // Write a cancel response so the extension can close the tab
+    const responsesDir = getResponsesDir();
+    ensureDir(responsesDir);
+    const response = {
+        id: requestId,
+        accepted: false,
+        cancelled: true,
+        timestamp: Date.now(),
+    };
+    try {
+        fs.writeFileSync(path.join(responsesDir, `${requestId}.json`), JSON.stringify(response, null, 2), 'utf-8');
+    }
+    catch {
+        // Best effort
+    }
+    // Remove the request file (if it still exists)
+    try {
+        const requestPath = path.join(getRequestsDir(), `${requestId}.json`);
+        if (fs.existsSync(requestPath)) {
+            fs.unlinkSync(requestPath);
+        }
+    }
+    catch {
+        // Best effort
+    }
+    // Defer temp file cleanup — the extension needs the files to match/close the tab.
+    // The extension polls at 500ms; 2s gives it plenty of time.
+    const timer = setTimeout(() => { cleanupTempFiles(requestId); }, 2000);
+    timer.unref();
+}
+/**
+ * Clean up all IPC files for a specific session prefix.
+ * Called when a terminal session unregisters.
+ */
+export function cleanupSessionDiffs(sessionPrefix) {
+    const pattern = `diff-${sessionPrefix}-`;
+    // Clean up request files
+    cleanupDirByPrefix(getRequestsDir(), pattern);
+    // Clean up response files
+    cleanupDirByPrefix(getResponsesDir(), pattern);
+    // Clean up temp files
+    const tmpDir = getTempDir();
+    if (fs.existsSync(tmpDir)) {
+        try {
+            const files = fs.readdirSync(tmpDir);
+            for (const file of files) {
+                if (file.includes(sessionPrefix)) {
+                    try {
+                        fs.unlinkSync(path.join(tmpDir, file));
+                    }
+                    catch {
+                        // Best effort
+                    }
+                }
+            }
+        }
+        catch {
+            // Best effort
+        }
+    }
+}
+/**
+ * Clean up stale IPC files older than the given threshold.
+ * Called on CLI startup to prevent accumulation from crashed sessions.
+ */
+export function cleanupStaleDiffs(maxAgeMs) {
+    const now = Date.now();
+    cleanupStaleInDir(getRequestsDir(), now, maxAgeMs);
+    cleanupStaleInDir(getResponsesDir(), now, maxAgeMs);
+    // Also clean stale temp files
+    const tmpDir = getTempDir();
+    if (fs.existsSync(tmpDir)) {
+        try {
+            const files = fs.readdirSync(tmpDir);
+            for (const file of files) {
+                try {
+                    const filePath = path.join(tmpDir, file);
+                    const stat = fs.statSync(filePath);
+                    if (now - stat.mtimeMs > maxAgeMs) {
+                        fs.unlinkSync(filePath);
+                    }
+                }
+                catch {
+                    // Best effort
+                }
+            }
+        }
+        catch {
+            // Best effort
+        }
+    }
+}
+// =============================================================================
+// Helpers
+// =============================================================================
+function cleanupDirByPrefix(dir, prefix) {
+    if (!fs.existsSync(dir))
+        return;
+    try {
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+            if (file.startsWith(prefix)) {
+                try {
+                    fs.unlinkSync(path.join(dir, file));
+                }
+                catch {
+                    // Best effort
+                }
+            }
+        }
+    }
+    catch {
+        // Best effort
+    }
+}
+function cleanupStaleInDir(dir, now, maxAgeMs) {
+    if (!fs.existsSync(dir))
+        return;
+    try {
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+            try {
+                const filePath = path.join(dir, file);
+                const stat = fs.statSync(filePath);
+                if (now - stat.mtimeMs > maxAgeMs) {
+                    fs.unlinkSync(filePath);
+                }
+            }
+            catch {
+                // Best effort
+            }
+        }
+    }
+    catch {
+        // Best effort
+    }
+}
+function extractStringParam(input, ...keys) {
+    for (const key of keys) {
+        if (typeof input[key] === 'string')
+            return input[key];
+    }
+    return '';
+}
+// =============================================================================
+// High-Level API
+// =============================================================================
+/**
+ * Open a VS Code diff tab for a tool permission request.
+ *
+ * Computes original/modified content from the tool input, writes temp files,
+ * and sends the IPC request for the compilr-diff-companion extension.
+ *
+ * Caller is responsible for checking isVSDiffAvailable() / vsDiffEnabled
+ * before calling this function.
+ *
+ * @returns The diff request ID (for use with waitForDiffResponse/cancelDiffRequest),
+ *          or null if content could not be computed.
+ */
+export function openVSCodeDiffForTool(options) {
+    const { toolName, input, agentId = 'default', sessionId = 'pending' } = options;
+    let originalContent = '';
+    let modifiedContent = '';
+    let targetPath = '';
+    if (toolName === 'edit') {
+        const filePath = extractStringParam(input, 'filePath', 'file_path', 'path');
+        const oldText = extractStringParam(input, 'oldString', 'old_string', 'old_text');
+        const newText = extractStringParam(input, 'newString', 'new_string', 'new_text');
+        const replaceAll = Boolean(input.replaceAll ?? input.replace_all);
+        if (!filePath || !oldText)
+            return null;
+        try {
+            originalContent = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch {
+            originalContent = '';
+        }
+        modifiedContent = computeModifiedContent(filePath, oldText, newText, replaceAll) ?? originalContent;
+        targetPath = filePath;
+    }
+    else if (toolName === 'write_file' || toolName === 'write') {
+        const writePath = extractStringParam(input, 'path', 'file_path', 'filePath');
+        const writeContent = extractStringParam(input, 'content');
+        if (!writePath || !writeContent)
+            return null;
+        try {
+            originalContent = fs.readFileSync(writePath, 'utf-8');
+        }
+        catch {
+            originalContent = '';
+        }
+        modifiedContent = writeContent;
+        targetPath = writePath;
+    }
+    else {
+        return null;
+    }
+    if (!targetPath || !modifiedContent)
+        return null;
+    const requestId = generateDiffRequestId(sessionId);
+    const { originalPath, modifiedPath } = writeTempDiffFiles(requestId, originalContent, modifiedContent, targetPath);
+    const fileName = targetPath.split('/').pop() ?? 'unknown';
+    const vsDiffReq = {
+        id: requestId,
+        sessionId,
+        agentId,
+        sessionLabel: '',
+        originalPath,
+        modifiedPath,
+        targetPath,
+        toolName,
+        title: `Review: ${fileName}`,
+        timestamp: Date.now(),
+    };
+    sendDiffRequest(vsDiffReq);
+    return requestId;
+}