@compilr-dev/cli 0.4.0 → 0.5.1

package/dist/ui/overlay/impl/session-mode-overlay-v2.js

@@ -0,0 +1,124 @@
+/**
+ * Session Mode Overlay V2
+ *
+ * Modal overlay shown at startup when projectSessionMode='ask' and a previous session exists.
+ * Gives the user control over how to handle the existing session:
+ * - Resume full: Continue where you left off (conversation + context)
+ * - Resume messages: Keep conversation, refresh project context
+ * - Start fresh: Clear conversation, fresh project context
+ */
+import { BaseOverlayV2, renderBorder, truncate } from '../../base/index.js';
+const SESSION_MODE_OPTIONS = [
+    {
+        id: 'resume-full',
+        label: 'Resume full',
+        description: 'Continue where you left off',
+    },
+    {
+        id: 'resume-messages',
+        label: 'Resume messages',
+        description: 'Keep conversation, refresh project context',
+    },
+    {
+        id: 'start-fresh',
+        label: 'Start fresh',
+        description: 'Clear conversation, fresh project context',
+    },
+];
+// =============================================================================
+// Session Mode Overlay V2 Class
+// =============================================================================
+export class SessionModeOverlayV2 extends BaseOverlayV2 {
+    type = 'inline';
+    id = 'session-mode-overlay-v2';
+    projectName;
+    messageCount;
+    lastActivity;
+    lastMessagePreview;
+    constructor(options) {
+        super({ selectedIndex: 0 });
+        this.projectName = options.projectName;
+        this.messageCount = options.messageCount;
+        this.lastActivity = options.lastActivity;
+        this.lastMessagePreview = options.lastMessagePreview;
+        this.minHeight = 18;
+    }
+    renderContent(context) {
+        const s = context.styles;
+        const border = renderBorder(context.width, s);
+        const lines = [];
+        lines.push(border);
+        lines.push(`  ${s.primaryBold('Previous Session Found')}`);
+        lines.push('');
+        // Session info
+        lines.push(`  ${s.muted('Project:')} ${s.primary(this.projectName)}`);
+        lines.push(`  ${s.muted('Messages:')} ${s.secondary(String(this.messageCount))}`);
+        // Format time ago
+        const timeAgo = this.formatTimeAgo(this.lastActivity);
+        lines.push(`  ${s.muted('Last active:')} ${s.secondary(timeAgo)}`);
+        // Last message preview if available
+        if (this.lastMessagePreview) {
+            const preview = truncate(this.lastMessagePreview, 50);
+            lines.push(`  ${s.muted('Last message:')} ${s.secondary(`"${preview}"`)}`);
+        }
+        lines.push('');
+        lines.push(`  ${s.muted('How would you like to continue?')}`);
+        lines.push('');
+        // Options
+        for (let i = 0; i < SESSION_MODE_OPTIONS.length; i++) {
+            const opt = SESSION_MODE_OPTIONS[i];
+            const isSelected = i === this.state.selectedIndex;
+            const prefix = isSelected ? s.primary('> ') : '  ';
+            const label = isSelected ? s.primaryBold(opt.label) : s.secondary(opt.label);
+            const desc = s.muted(` - ${opt.description}`);
+            lines.push(`  ${prefix}${label}${desc}`);
+        }
+        lines.push('');
+        lines.push(border);
+        lines.push(`  ${s.muted('j/k Navigate  Enter Select')}`);
+        lines.push(border);
+        return lines;
+    }
+    handleKey(key) {
+        // Ctrl+C closes with start-fresh (safest default for interrupt)
+        if (key.ctrl && key.name === 'c') {
+            return this.close({ option: 'start-fresh' });
+        }
+        // Escape defaults to resume-full (most common expectation)
+        if (key.name === 'escape') {
+            return this.close({ option: 'resume-full' });
+        }
+        // Navigation with j/k
+        if (key.char === 'j' || key.name === 'down') {
+            this.state.selectedIndex = Math.min(this.state.selectedIndex + 1, SESSION_MODE_OPTIONS.length - 1);
+            return this.rerender();
+        }
+        if (key.char === 'k' || key.name === 'up') {
+            this.state.selectedIndex = Math.max(this.state.selectedIndex - 1, 0);
+            return this.rerender();
+        }
+        // Enter selects
+        if (key.name === 'return') {
+            const selected = SESSION_MODE_OPTIONS[this.state.selectedIndex];
+            return this.close({ option: selected.id });
+        }
+        return this.rerender();
+    }
+    formatTimeAgo(date) {
+        const now = new Date();
+        const diffMs = now.getTime() - date.getTime();
+        const diffMins = Math.floor(diffMs / (1000 * 60));
+        const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+        const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+        if (diffMins < 1)
+            return 'just now';
+        if (diffMins < 60)
+            return `${String(diffMins)} minute${diffMins === 1 ? '' : 's'} ago`;
+        if (diffHours < 24)
+            return `${String(diffHours)} hour${diffHours === 1 ? '' : 's'} ago`;
+        if (diffDays < 7)
+            return `${String(diffDays)} day${diffDays === 1 ? '' : 's'} ago`;
+        // For older sessions, show the date
+        return date.toLocaleDateString();
+    }
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Tasks Overlay V2 - View and manage background shell tasks
+ *
+ * Shows background shells started via `bash` with `run_in_background=true`.
+ * Allows viewing output, killing running tasks, and clearing completed ones.
+ */
+import { BaseOverlayV2 } from '../../base/overlay-base-v2.js';
+import type { RenderContext, OverlayAction, KeyEvent } from '../index.js';
+interface TasksOverlayState {
+    selectedIndex: number;
+    screen: 'list' | 'detail';
+    detailShellId: string | null;
+    lastRefresh: number;
+}
+export declare class TasksOverlayV2 extends BaseOverlayV2<TasksOverlayState> {
+    readonly type: "inline";
+    readonly id = "tasks-overlay";
+    constructor();
+    protected renderContent(context: RenderContext): string[];
+    private renderList;
+    private formatShellLine;
+    private formatDuration;
+    private renderDetail;
+    handleKey(key: KeyEvent): OverlayAction<void>;
+    private handleListKey;
+    private handleDetailKey;
+}
+export {};

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

@@ -0,0 +1,283 @@
+/**
+ * Tasks Overlay V2 - View and manage background shell tasks
+ *
+ * Shows background shells started via `bash` with `run_in_background=true`.
+ * Allows viewing output, killing running tasks, and clearing completed ones.
+ */
+import { getDefaultShellManager } from '@compilr-dev/sdk';
+import { BaseOverlayV2 } from '../../base/overlay-base-v2.js';
+import { wrapText, truncate } from '../../base/render-utils.js';
+export class TasksOverlayV2 extends BaseOverlayV2 {
+    type = 'inline';
+    id = 'tasks-overlay';
+    constructor() {
+        super({
+            selectedIndex: 0,
+            screen: 'list',
+            detailShellId: null,
+            lastRefresh: Date.now(),
+        });
+    }
+    renderContent(context) {
+        // Set minHeight for stable rendering
+        this.minHeight = this.state.screen === 'detail' ? 20 : 15;
+        if (this.state.screen === 'detail') {
+            return this.renderDetail(context);
+        }
+        return this.renderList(context);
+    }
+    renderList(context) {
+        const s = context.styles;
+        const lines = [];
+        const innerWidth = context.width - 4;
+        // Header
+        lines.push(...this.renderHeader('Background Tasks'));
+        const manager = getDefaultShellManager();
+        const shells = manager.list();
+        // Sort: running first, then by start time (newest first)
+        shells.sort((a, b) => {
+            if (a.status === 'running' && b.status !== 'running')
+                return -1;
+            if (a.status !== 'running' && b.status === 'running')
+                return 1;
+            return b.startTime.getTime() - a.startTime.getTime();
+        });
+        // Ensure selected index is valid
+        if (this.state.selectedIndex >= shells.length) {
+            this.state.selectedIndex = Math.max(0, shells.length - 1);
+        }
+        if (shells.length === 0) {
+            lines.push(s.muted('  No background tasks.'));
+            lines.push('');
+            lines.push(s.muted('  Start a task with the agent using:'));
+            lines.push(s.muted('  bash command with run_in_background=true'));
+            lines.push('');
+        }
+        else {
+            for (let i = 0; i < shells.length; i++) {
+                const shell = shells[i];
+                const isSelected = i === this.state.selectedIndex;
+                const line = this.formatShellLine(shell, innerWidth - 4, s);
+                if (isSelected) {
+                    lines.push(s.selected(` ${s.primary('›')} ${line} `));
+                }
+                else {
+                    lines.push(`   ${line}`);
+                }
+            }
+            lines.push('');
+        }
+        // Footer
+        if (shells.length > 0) {
+            lines.push(...this.renderFooter('↑↓ navigate · Enter view · x kill · c clear done · Esc close'));
+        }
+        else {
+            lines.push(...this.renderFooter('Esc close'));
+        }
+        return lines;
+    }
+    formatShellLine(shell, maxWidth, s) {
+        // Status icon and color based on status
+        let statusIcon = '?';
+        let statusColor = s.muted;
+        switch (shell.status) {
+            case 'running':
+                statusIcon = '●';
+                statusColor = s.warning;
+                break;
+            case 'completed':
+                statusIcon = '✓';
+                statusColor = s.success;
+                break;
+            case 'failed':
+                statusIcon = '✗';
+                statusColor = s.error;
+                break;
+            case 'killed':
+                statusIcon = '⊘';
+                statusColor = s.muted;
+                break;
+        }
+        // Duration
+        const duration = this.formatDuration(shell);
+        // Command (truncate)
+        const cmdMaxLen = Math.max(10, maxWidth - 35); // space for id, status, duration
+        const cmd = truncate(shell.command, cmdMaxLen);
+        // Status text
+        const statusText = shell.status.padEnd(10);
+        return `${statusColor(statusIcon)} ${s.secondary(shell.id)}  ${cmd.padEnd(cmdMaxLen)}  ${statusText}  ${s.muted(duration)}`;
+    }
+    formatDuration(shell) {
+        const endTime = shell.endTime ?? new Date();
+        const durationMs = endTime.getTime() - shell.startTime.getTime();
+        const seconds = Math.floor(durationMs / 1000);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        if (hours > 0) {
+            return `${String(hours)}h ${String(minutes % 60)}m`;
+        }
+        else if (minutes > 0) {
+            return `${String(minutes)}m ${String(seconds % 60)}s`;
+        }
+        else {
+            return `${String(seconds)}s`;
+        }
+    }
+    renderDetail(context) {
+        const s = context.styles;
+        const lines = [];
+        const innerWidth = context.width - 4;
+        const manager = getDefaultShellManager();
+        const shell = this.state.detailShellId ? manager.get(this.state.detailShellId) : null;
+        // Header
+        lines.push(...this.renderHeader(`Task: ${this.state.detailShellId ?? 'unknown'}`));
+        if (!shell) {
+            lines.push(s.error('  Task not found (may have been cleaned up)'));
+            lines.push('');
+            lines.push(...this.renderFooter('Esc back'));
+            return lines;
+        }
+        // Info section
+        lines.push(`  ${s.primaryBold('Command:')} ${shell.command}`);
+        let statusLine = `  ${s.primaryBold('Status:')} `;
+        switch (shell.status) {
+            case 'running':
+                statusLine += s.warning('running');
+                break;
+            case 'completed':
+                statusLine += s.success('completed');
+                if (shell.exitCode !== undefined) {
+                    statusLine += s.muted(` (exit ${String(shell.exitCode)})`);
+                }
+                break;
+            case 'failed':
+                statusLine += s.error('failed');
+                if (shell.exitCode !== undefined) {
+                    statusLine += s.muted(` (exit ${String(shell.exitCode)})`);
+                }
+                break;
+            case 'killed':
+                statusLine += s.muted('killed');
+                break;
+        }
+        statusLine += s.muted(` · Started: ${this.formatDuration(shell)} ago`);
+        lines.push(statusLine);
+        if (shell.cwd) {
+            lines.push(`  ${s.primaryBold('Directory:')} ${s.muted(shell.cwd)}`);
+        }
+        lines.push('');
+        lines.push(this.renderBorder());
+        // Output section
+        const output = this.state.detailShellId ? manager.getAllOutput(this.state.detailShellId) : null;
+        if (output) {
+            const combined = (output.stdout + output.stderr).trim();
+            if (combined) {
+                const outputLines = combined.split('\n');
+                const maxOutputLines = 10;
+                // Show last N lines
+                const displayLines = outputLines.slice(-maxOutputLines);
+                if (outputLines.length > maxOutputLines) {
+                    lines.push(s.muted(`  ... (${String(outputLines.length - maxOutputLines)} lines hidden)`));
+                }
+                for (const line of displayLines) {
+                    const wrapped = wrapText(line, innerWidth - 2);
+                    for (const wl of wrapped) {
+                        lines.push(`  ${wl}`);
+                    }
+                }
+            }
+            else {
+                lines.push(s.muted('  (no output yet)'));
+            }
+        }
+        else {
+            lines.push(s.muted('  (output not available)'));
+        }
+        lines.push('');
+        // Footer
+        const hints = ['r refresh'];
+        if (shell.status === 'running') {
+            hints.push('x kill');
+        }
+        hints.push('Esc back');
+        lines.push(...this.renderFooter(hints.join(' · ')));
+        return lines;
+    }
+    handleKey(key) {
+        if (this.isCloseKey(key)) {
+            if (this.state.screen === 'detail') {
+                this.state.screen = 'list';
+                this.state.detailShellId = null;
+                return this.rerender();
+            }
+            return this.close(undefined);
+        }
+        if (this.state.screen === 'detail') {
+            return this.handleDetailKey(key);
+        }
+        return this.handleListKey(key);
+    }
+    handleListKey(key) {
+        const manager = getDefaultShellManager();
+        const shells = manager.list();
+        // Sort same as render
+        shells.sort((a, b) => {
+            if (a.status === 'running' && b.status !== 'running')
+                return -1;
+            if (a.status !== 'running' && b.status === 'running')
+                return 1;
+            return b.startTime.getTime() - a.startTime.getTime();
+        });
+        if (this.isUpKey(key)) {
+            if (this.state.selectedIndex > 0) {
+                this.state.selectedIndex--;
+            }
+            return this.rerender();
+        }
+        if (this.isDownKey(key)) {
+            if (this.state.selectedIndex < shells.length - 1) {
+                this.state.selectedIndex++;
+            }
+            return this.rerender();
+        }
+        if (this.isEnterKey(key)) {
+            if (shells.length > 0 && shells[this.state.selectedIndex]) {
+                this.state.screen = 'detail';
+                this.state.detailShellId = shells[this.state.selectedIndex].id;
+            }
+            return this.rerender();
+        }
+        // 'x' for kill (not 'k' since that's vim-up)
+        if (key.name === 'x' && shells.length > 0 && this.state.selectedIndex < shells.length) {
+            const selected = shells[this.state.selectedIndex];
+            if (selected.status === 'running') {
+                manager.kill(selected.id);
+            }
+            return this.rerender();
+        }
+        // 'c' for clear completed
+        if (key.name === 'c') {
+            manager.clearCompleted();
+            this.state.selectedIndex = 0;
+            return this.rerender();
+        }
+        return this.noAction();
+    }
+    handleDetailKey(key) {
+        const manager = getDefaultShellManager();
+        // 'r' for refresh
+        if (key.name === 'r') {
+            this.state.lastRefresh = Date.now();
+            return this.rerender();
+        }
+        // 'x' for kill
+        if (key.name === 'x' && this.state.detailShellId) {
+            const shell = manager.get(this.state.detailShellId);
+            if (shell?.status === 'running') {
+                manager.kill(this.state.detailShellId);
+            }
+            return this.rerender();
+        }
+        return this.noAction();
+    }
+}

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

@@ -0,0 +1,86 @@
+/**
+ * Team Overlay V2
+ *
+ * Modal overlay for managing the multi-agent team.
+ * Uses TabbedListOverlayV2 for consistent list/tab behavior.
+ *
+ * Features:
+ * - Members tab: List team agents, switch, add, remove
+ * - Roles tab: Available roles to add
+ * - Context tab: View per-agent context usage and shared context status
+ */
+import { TabbedListOverlayV2, BaseScreen } from '../../base/index.js';
+import type { AgentTeam, AgentRole } from '../../../multi-agent/index.js';
+import { type ToolProfile } from '../../../multi-agent/tool-config.js';
+import { type ModelTier } from '../../../models/index.js';
+interface TeamMemberItem {
+    id: string;
+    displayName: string;
+    mascot: string;
+    role: AgentRole;
+    description?: string;
+    isActive: boolean;
+    isCoordinator: boolean;
+    hasToolRestrictions: boolean;
+    toolProfile?: string;
+    enabledSkills?: string[];
+    modelTier?: ModelTier;
+    modelId?: string;
+    isMember: true;
+    isContext: false;
+}
+interface RoleItem {
+    role: AgentRole;
+    displayName: string;
+    mascot: string;
+    description: string;
+    alreadyInTeam: boolean;
+    defaultProfile?: ToolProfile;
+    defaultModelTier?: ModelTier;
+    isCustomCreate: false;
+    isMember: false;
+    isContext: false;
+}
+interface CustomCreateItem {
+    displayName: string;
+    mascot: string;
+    description: string;
+    isCustomCreate: true;
+    isMember: false;
+    isContext: false;
+}
+interface ContextItem {
+    id: string;
+    displayName: string;
+    mascot: string;
+    utilization: number;
+    currentTokens: number;
+    maxTokens: number;
+    messageCount: number;
+    lastActive?: Date;
+    isSharedContext: boolean;
+    isMember: false;
+    isContext: true;
+}
+type TeamItem = TeamMemberItem | RoleItem | CustomCreateItem | ContextItem;
+interface TeamOverlayOptions {
+    onAgentSwitch?: (agentId: string) => Promise<void>;
+}
+export interface TeamOverlayV2Result {
+    action?: 'switch' | 'add' | 'remove' | 'compact' | 'create-custom' | 'change-tier';
+    agentId?: string;
+    role?: AgentRole;
+    customId?: string;
+    modelTier?: ModelTier;
+}
+export declare class TeamOverlayV2 extends TabbedListOverlayV2<TeamItem, TeamOverlayV2Result> {
+    readonly type: "inline";
+    readonly id = "team-overlay-v2";
+    constructor(team: AgentTeam, _options?: TeamOverlayOptions);
+    private static buildMemberItems;
+    private static buildRoleItems;
+    private static buildContextItems;
+    protected createDetailScreen(item: TeamItem): BaseScreen | null;
+    handleKey(key: import('../types.js').KeyEvent): import('../types.js').OverlayAction<TeamOverlayV2Result>;
+}
+export {};