@compilr-dev/cli 0.4.0 → 0.5.1

package/dist/ui/overlay/impl/pending-overlay-v2.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Pending Requests Overlay V2
+ *
+ * Modal overlay for viewing and responding to pending requests from background agents.
+ * Users can approve, deny, or view details of each request.
+ *
+ * Phase 3b: Background Agents
+ */
+import { BaseOverlayV2 } from '../../base/index.js';
+import type { RenderContext, OverlayAction, KeyEvent } from '../index.js';
+import { type PendingRequest } from '../../../multi-agent/index.js';
+export type PendingOverlayResult = {
+    type: 'closed';
+} | {
+    type: 'respond';
+    request: PendingRequest;
+};
+interface PendingOverlayState {
+    /** Currently selected request index */
+    selectedIndex: number;
+    /** Requests snapshot at render time */
+    requests: PendingRequest[];
+    /** Whether we're showing a diff detail view */
+    showingDiff: boolean;
+    /** Scroll offset in diff view */
+    diffScrollOffset: number;
+    /** Pre-rendered diff lines (colored) */
+    diffLines: string[];
+    /** Which request the diff is for */
+    diffRequestId: string;
+}
+export declare class PendingOverlayV2 extends BaseOverlayV2<PendingOverlayState, PendingOverlayResult> {
+    readonly type: "inline";
+    readonly id = "pending-overlay-v2";
+    /** Active VS Code diff watchers, keyed by pending request ID */
+    private readonly vsDiffWatchers;
+    constructor();
+    protected renderContent(context: RenderContext): string[];
+    private renderListView;
+    private renderDiffView;
+    handleKey(key: KeyEvent): OverlayAction<PendingOverlayResult>;
+    private handleListKey;
+    /**
+     * Cancel an active VS Code diff for a pending request (if any).
+     * Called when the request is resolved from the terminal.
+     */
+    private cancelVSDiffForRequest;
+    private handleDiffKey;
+    getCloseSummary(result: PendingOverlayResult): string | null;
+}
+export {};

package/dist/ui/overlay/impl/pending-overlay-v2.js

@@ -0,0 +1,445 @@
+/**
+ * Pending Requests Overlay V2
+ *
+ * Modal overlay for viewing and responding to pending requests from background agents.
+ * Users can approve, deny, or view details of each request.
+ *
+ * Phase 3b: Background Agents
+ */
+import chalk from 'chalk';
+import { getStyles } from '../../../themes/index.js';
+import { BaseOverlayV2, truncate } from '../../base/index.js';
+import * as terminal from '../../terminal.js';
+import * as diff from '../../diff.js';
+import { isVSDiffAvailable } from '../../../utils/vscode-detect.js';
+import { openVSCodeDiffForTool, cancelDiffRequest, waitForDiffResponse, } from '../../vscode-diff-ipc.js';
+import { getPendingRequestsManager, } from '../../../multi-agent/index.js';
+// Fixed height for diff view content area
+const DIFF_VIEW_CONTENT_LINES = 15;
+// Tool names that support diff viewing
+const DIFFABLE_TOOLS = new Set(['edit', 'write_file', 'write']);
+// =============================================================================
+// Helpers
+// =============================================================================
+/**
+ * Check if a pending request has a diffable tool
+ */
+function isDiffableRequest(req) {
+    if (req.type !== 'permission' || !req.context)
+        return false;
+    const ctx = req.context;
+    return typeof ctx.toolName === 'string' && DIFFABLE_TOOLS.has(ctx.toolName);
+}
+/**
+ * Generate diff lines for a pending request.
+ * Returns an array of formatted lines, or null if diff can't be generated.
+ */
+function generateDiffForRequest(req) {
+    if (!req.context)
+        return null;
+    const ctx = req.context;
+    if (!ctx.toolName || !ctx.input)
+        return null;
+    const s = getStyles();
+    const toolName = ctx.toolName;
+    const input = ctx.input;
+    if (toolName === 'edit') {
+        const filePath = (input.filePath ?? input.file_path ?? input.path ?? '');
+        const oldText = (input.oldString ?? input.old_string ?? input.old_text ?? '');
+        const newText = (input.newString ?? input.new_string ?? input.new_text ?? '');
+        const replaceAll = Boolean(input.replaceAll ?? input.replace_all);
+        if (!filePath || !oldText)
+            return null;
+        const editDiff = diff.generateEditDiff(filePath, oldText, newText, replaceAll);
+        if (!editDiff) {
+            // Fallback: show raw old/new text
+            const lines = [];
+            lines.push(s.primary(`File: ${filePath}`));
+            lines.push('');
+            lines.push(s.muted('Could not read file to generate diff.'));
+            lines.push('');
+            lines.push(s.muted('Old text:'));
+            for (const line of oldText.split('\n').slice(0, 20)) {
+                lines.push('  ' + line);
+            }
+            lines.push('');
+            lines.push(s.muted('New text:'));
+            for (const line of newText.split('\n').slice(0, 20)) {
+                lines.push('  ' + line);
+            }
+            return lines;
+        }
+        const header = diff.formatDiffHeader(filePath, editDiff.additions, editDiff.removals);
+        return [header, '', ...editDiff.lines];
+    }
+    if (toolName === 'write_file' || toolName === 'write') {
+        const filePath = (input.path ?? input.file_path ?? input.filePath ?? '');
+        const content = (input.content ?? '');
+        if (!filePath || !content)
+            return null;
+        const writeDiff = diff.generateWriteDiff(filePath, content, true);
+        const header = diff.formatWriteHeader(filePath, writeDiff.additions, true);
+        return [header, '', ...writeDiff.lines];
+    }
+    return null;
+}
+// =============================================================================
+// Pending Overlay V2 Class
+// =============================================================================
+export class PendingOverlayV2 extends BaseOverlayV2 {
+    type = 'inline';
+    id = 'pending-overlay-v2';
+    /** Active VS Code diff watchers, keyed by pending request ID */
+    vsDiffWatchers = new Map();
+    constructor() {
+        const manager = getPendingRequestsManager();
+        const requests = manager.getAll();
+        super({
+            selectedIndex: 0,
+            requests,
+            showingDiff: false,
+            diffScrollOffset: 0,
+            diffLines: [],
+            diffRequestId: '',
+        });
+        // Set minimum height for stable rendering
+        this.minHeight = 10;
+    }
+    renderContent(context) {
+        if (this.state.showingDiff) {
+            return this.renderDiffView(context);
+        }
+        return this.renderListView(context);
+    }
+    renderListView(context) {
+        const s = context.styles;
+        const lines = [];
+        const cols = terminal.getTerminalWidth();
+        const border = s.muted('─'.repeat(Math.max(1, cols - 1)));
+        // Refresh requests each render
+        const manager = getPendingRequestsManager();
+        this.state.requests = manager.getAll();
+        // Header
+        lines.push(border);
+        lines.push(' ' + chalk.bold('Pending Requests') + s.muted(` (${String(this.state.requests.length)} total)`));
+        lines.push(border);
+        lines.push('');
+        if (this.state.requests.length === 0) {
+            lines.push(s.muted('  No pending requests from background agents.'));
+            lines.push('');
+        }
+        else {
+            // Render each request
+            for (let i = 0; i < this.state.requests.length; i++) {
+                const req = this.state.requests[i];
+                const isSelected = i === this.state.selectedIndex;
+                const prefix = isSelected ? ' ❯ ' : '   ';
+                // Request header: [mascot] agent: prompt
+                const header = `${req.mascot} $${req.agentId}: ${req.prompt}`;
+                const maxHeaderLen = cols - 6;
+                const truncHeader = truncate(header, maxHeaderLen);
+                if (isSelected) {
+                    lines.push(s.primary(prefix + `${String(i + 1)}. ${truncHeader}`));
+                }
+                else {
+                    lines.push(s.muted(prefix + `${String(i + 1)}. ${truncHeader}`));
+                }
+                // Type indicator
+                const typeLabel = req.type === 'permission' ? 'Permission request' : 'Question';
+                lines.push(s.muted(`      Type: ${typeLabel}`));
+                // Actions line (only for selected)
+                if (isSelected) {
+                    if (req.type === 'question') {
+                        lines.push(s.info('      [r]espond · [d]eny/skip'));
+                    }
+                    else if (isDiffableRequest(req)) {
+                        lines.push(s.info('      [a]pprove  [d]eny  [v] diff'));
+                    }
+                    else {
+                        lines.push(s.info('      [a]pprove  [d]eny'));
+                    }
+                }
+                else {
+                    lines.push('');
+                }
+                lines.push('');
+            }
+        }
+        // Footer
+        lines.push(border);
+        if (this.state.requests.length > 0) {
+            // Check if selected request is a question
+            const selectedReq = this.state.requests[this.state.selectedIndex];
+            if (selectedReq && selectedReq.type === 'question') {
+                lines.push(s.muted(' ↑↓ Navigate · r/Enter Respond · d Deny/Skip · Esc Close'));
+            }
+            else if (selectedReq && isDiffableRequest(selectedReq)) {
+                lines.push(s.muted(' ↑↓ Navigate · a Approve · d Deny · v View diff · Esc Close'));
+            }
+            else {
+                lines.push(s.muted(' ↑↓ Navigate · a Approve · d Deny · Esc Close'));
+            }
+        }
+        else {
+            lines.push(s.muted(' Esc Close'));
+        }
+        return lines;
+    }
+    renderDiffView(context) {
+        const s = context.styles;
+        const cols = terminal.getTerminalWidth();
+        const lines = [];
+        const border = s.muted('─'.repeat(Math.max(1, cols - 1)));
+        // Refresh requests each render
+        const manager = getPendingRequestsManager();
+        this.state.requests = manager.getAll();
+        // Find the request this diff is for (may have been resolved externally via VS Code)
+        const req = this.state.requests.find(r => r.id === this.state.diffRequestId);
+        if (!req) {
+            // Request was resolved externally — return to list view
+            this.state.showingDiff = false;
+            return this.renderListView(context);
+        }
+        const agentLabel = `$${req.agentId}`;
+        const ctx = req.context;
+        const filePath = ctx?.input
+            ? (ctx.input.filePath ?? ctx.input.file_path ?? ctx.input.path ?? '')
+            : '';
+        const fileName = filePath.split('/').pop() || filePath;
+        // Header
+        lines.push(border);
+        lines.push(' ' + chalk.bold('Diff: ') + s.primary(fileName) + s.muted(agentLabel ? ` (${agentLabel})` : ''));
+        lines.push(border);
+        lines.push('');
+        // Content with scroll
+        const contentLines = this.state.diffLines;
+        const visibleLines = DIFF_VIEW_CONTENT_LINES;
+        const endLine = Math.min(this.state.diffScrollOffset + visibleLines, contentLines.length);
+        for (let i = this.state.diffScrollOffset; i < endLine; i++) {
+            const line = contentLines[i];
+            const safeLine = truncate(line, cols - 2);
+            lines.push(' ' + safeLine);
+        }
+        // Pad to fixed height
+        const renderedLines = endLine - this.state.diffScrollOffset;
+        for (let i = renderedLines; i < DIFF_VIEW_CONTENT_LINES; i++) {
+            lines.push('');
+        }
+        // Footer with scroll indicator
+        lines.push('');
+        const scrollInfo = contentLines.length > visibleLines
+            ? s.muted(` [${String(this.state.diffScrollOffset + 1)}-${String(endLine)}/${String(contentLines.length)}]`)
+            : '';
+        lines.push(border);
+        lines.push(s.muted(' ↑↓/PgUp/PgDn Scroll · a Approve · d Deny · Esc Back') + scrollInfo);
+        return lines;
+    }
+    handleKey(key) {
+        if (this.state.showingDiff) {
+            return this.handleDiffKey(key);
+        }
+        return this.handleListKey(key);
+    }
+    handleListKey(key) {
+        // Escape or Ctrl+C = close
+        if (key.name === 'escape' || (key.ctrl && key.name === 'c')) {
+            // Cancel all active VS Code diff watchers
+            for (const [, watcher] of this.vsDiffWatchers) {
+                watcher.abort();
+                cancelDiffRequest(watcher.diffReqId);
+            }
+            this.vsDiffWatchers.clear();
+            return this.close({ type: 'closed' });
+        }
+        // No requests - just allow closing
+        if (this.state.requests.length === 0) {
+            return this.rerender();
+        }
+        const keyStr = key.char?.toLowerCase() ?? '';
+        // Arrow navigation
+        if (key.name === 'up') {
+            this.state.selectedIndex = Math.max(0, this.state.selectedIndex - 1);
+            return this.rerender();
+        }
+        if (key.name === 'down') {
+            this.state.selectedIndex = Math.min(this.state.requests.length - 1, this.state.selectedIndex + 1);
+            return this.rerender();
+        }
+        // View diff (for permission-type with diffable tool)
+        if (keyStr === 'v') {
+            const req = this.state.requests[this.state.selectedIndex];
+            if (req && isDiffableRequest(req)) {
+                // Open VS Code diff if available
+                if (isVSDiffAvailable() && !this.vsDiffWatchers.has(req.id)) {
+                    const ctx = req.context;
+                    const diffReqId = openVSCodeDiffForTool({
+                        toolName: ctx.toolName,
+                        input: ctx.input,
+                        agentId: req.agentId,
+                    });
+                    if (diffReqId) {
+                        // Start background watcher for VS Code approve/deny response
+                        const { promise, abort } = waitForDiffResponse(diffReqId, 120_000);
+                        this.vsDiffWatchers.set(req.id, { abort, diffReqId });
+                        promise.then((response) => {
+                            if (response && !response.cancelled) {
+                                const manager = getPendingRequestsManager();
+                                const pending = manager.getAll().find(r => r.id === req.id);
+                                if (pending) {
+                                    manager.respond(req.id, { approved: response.accepted });
+                                    // Trigger overlay re-render to reflect the change
+                                    this.requestRender();
+                                }
+                            }
+                            this.vsDiffWatchers.delete(req.id);
+                        }).catch(() => {
+                            this.vsDiffWatchers.delete(req.id);
+                        });
+                    }
+                }
+                // Also show terminal diff view (for terminal-based approve/deny)
+                const terminalDiffLines = generateDiffForRequest(req);
+                if (terminalDiffLines) {
+                    this.state.showingDiff = true;
+                    this.state.diffScrollOffset = 0;
+                    this.state.diffLines = terminalDiffLines;
+                    this.state.diffRequestId = req.id;
+                    return this.rerender();
+                }
+            }
+            return this.rerender();
+        }
+        // Approve selected request (for permission-type only)
+        if (keyStr === 'a') {
+            const req = this.state.requests[this.state.selectedIndex];
+            if (req && req.type === 'permission') {
+                this.cancelVSDiffForRequest(req.id);
+                const manager = getPendingRequestsManager();
+                manager.respond(req.id, { approved: true });
+                // Auto-close if no requests remain
+                if (manager.getCount() === 0) {
+                    return this.close({ type: 'closed' });
+                }
+                // Update selection if needed
+                if (this.state.selectedIndex >= this.state.requests.length - 1) {
+                    this.state.selectedIndex = Math.max(0, this.state.selectedIndex - 1);
+                }
+            }
+            return this.rerender();
+        }
+        // Deny selected request
+        if (keyStr === 'd') {
+            const req = this.state.requests[this.state.selectedIndex];
+            if (req) {
+                this.cancelVSDiffForRequest(req.id);
+                const manager = getPendingRequestsManager();
+                manager.respond(req.id, { approved: false });
+                // Auto-close if no requests remain
+                if (manager.getCount() === 0) {
+                    return this.close({ type: 'closed' });
+                }
+                // Update selection if needed
+                if (this.state.selectedIndex >= this.state.requests.length - 1) {
+                    this.state.selectedIndex = Math.max(0, this.state.selectedIndex - 1);
+                }
+            }
+            return this.rerender();
+        }
+        // Respond to question with standard overlay (r or Enter)
+        if (keyStr === 'r' || key.name === 'return') {
+            const req = this.state.requests[this.state.selectedIndex];
+            if (req && req.type === 'question') {
+                // Close overlay and return the request to show standard overlay
+                return this.close({ type: 'respond', request: req });
+            }
+        }
+        return this.rerender();
+    }
+    /**
+     * Cancel an active VS Code diff for a pending request (if any).
+     * Called when the request is resolved from the terminal.
+     */
+    cancelVSDiffForRequest(pendingReqId) {
+        const watcher = this.vsDiffWatchers.get(pendingReqId);
+        if (watcher) {
+            watcher.abort();
+            cancelDiffRequest(watcher.diffReqId);
+            this.vsDiffWatchers.delete(pendingReqId);
+        }
+    }
+    handleDiffKey(key) {
+        const keyStr = key.char?.toLowerCase() ?? '';
+        // Escape or q = go back to list view
+        if (key.name === 'escape' || keyStr === 'q') {
+            this.state.showingDiff = false;
+            return this.rerender();
+        }
+        // Approve from diff view
+        if (keyStr === 'a') {
+            const req = this.state.requests.find(r => r.id === this.state.diffRequestId);
+            if (req && req.type === 'permission') {
+                this.cancelVSDiffForRequest(req.id);
+                const manager = getPendingRequestsManager();
+                manager.respond(req.id, { approved: true });
+                this.state.showingDiff = false;
+                // Auto-close if no requests remain
+                if (manager.getCount() === 0) {
+                    return this.close({ type: 'closed' });
+                }
+                // Update selection if needed
+                if (this.state.selectedIndex >= this.state.requests.length - 1) {
+                    this.state.selectedIndex = Math.max(0, this.state.selectedIndex - 1);
+                }
+            }
+            return this.rerender();
+        }
+        // Deny from diff view
+        if (keyStr === 'd') {
+            const req = this.state.requests.find(r => r.id === this.state.diffRequestId);
+            if (req) {
+                this.cancelVSDiffForRequest(req.id);
+                const manager = getPendingRequestsManager();
+                manager.respond(req.id, { approved: false });
+                this.state.showingDiff = false;
+                // Auto-close if no requests remain
+                if (manager.getCount() === 0) {
+                    return this.close({ type: 'closed' });
+                }
+                // Update selection if needed
+                if (this.state.selectedIndex >= this.state.requests.length - 1) {
+                    this.state.selectedIndex = Math.max(0, this.state.selectedIndex - 1);
+                }
+            }
+            return this.rerender();
+        }
+        // Scroll
+        const visibleLines = DIFF_VIEW_CONTENT_LINES;
+        const maxOffset = Math.max(0, this.state.diffLines.length - visibleLines);
+        if (key.name === 'up') {
+            this.state.diffScrollOffset = Math.max(0, this.state.diffScrollOffset - 1);
+        }
+        else if (key.name === 'pageup') {
+            this.state.diffScrollOffset = Math.max(0, this.state.diffScrollOffset - visibleLines);
+        }
+        else if (key.name === 'down') {
+            this.state.diffScrollOffset = Math.min(maxOffset, this.state.diffScrollOffset + 1);
+        }
+        else if (key.name === 'pagedown') {
+            this.state.diffScrollOffset = Math.min(maxOffset, this.state.diffScrollOffset + visibleLines);
+        }
+        return this.rerender();
+    }
+    getCloseSummary(result) {
+        // Don't show summary if we're responding to a question (will show overlay)
+        if (result.type === 'respond') {
+            return null;
+        }
+        const s = getStyles();
+        const manager = getPendingRequestsManager();
+        const remaining = manager.getCount();
+        if (remaining > 0) {
+            return s.muted(`Pending requests: ${String(remaining)} remaining`);
+        }
+        return s.success('All pending requests resolved.');
+    }
+}

package/dist/ui/overlay/impl/permission-overlay-v2.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Permission Overlay V2
+ *
+ * Modal overlay for tool permission requests.
+ * Uses BaseOverlayV2 for the new TerminalUI-based REPL.
+ */
+import { BaseOverlayV2 } from '../../base/index.js';
+import type { RenderContext, OverlayAction, KeyEvent } from '../index.js';
+export type PermissionResult = 'allow' | 'deny' | 'allow-always';
+export interface PermissionOverlayV2Options {
+    toolName: string;
+    args: Record<string, unknown>;
+    description?: string;
+    /** Pre-rendered diff lines (for edit tool) */
+    diffLines?: string[];
+}
+interface PermissionState {
+    selectedIndex: number;
+    showingDetail: boolean;
+    detailScrollOffset: number;
+    detailContentLines: string[];
+}
+export declare class PermissionOverlayV2 extends BaseOverlayV2<PermissionState, PermissionResult> {
+    readonly type: "inline";
+    readonly id = "permission-overlay-v2";
+    private readonly options;
+    constructor(options: PermissionOverlayV2Options);
+    protected renderContent(context: RenderContext): string[];
+    private renderMainView;
+    private renderDetailView;
+    handleKey(key: KeyEvent): OverlayAction<PermissionResult>;
+    private handleMainKey;
+    private handleDetailKey;
+    getCloseSummary(result: PermissionResult): string | null;
+}
+export {};