agen-vektor 0.1.0

package/dist/tui/app.js

@@ -0,0 +1,913 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.App = void 0;
+/**
+ * TUI App — the main interactive loop.
+ *
+ * Layout (top to bottom):
+ *   header      VECTOR ● status            provider · model
+ *   project bar Project: ~/x  Mode: ask
+ *   ───────────────────────────────────────────────
+ *   chat        scrollable message area
+ *   ───────────────────────────────────────────────
+ *   input       ❯ _
+ *   statusbar   ENTER Send · TAB Commands · CTRL+C Stop · ? Help
+ *
+ * Modals (diff, selector, help, permission) overlay the chat area.
+ */
+const terminal_1 = require("../utils/terminal");
+const chat_1 = require("./chat");
+const input_1 = require("./input");
+const statusbar_1 = require("./statusbar");
+const components_1 = require("./components");
+const diff_1 = require("./diff");
+const planner_1 = require("../agent/planner");
+const session_1 = require("../agent/session");
+const factory_1 = require("../providers/factory");
+const models_1 = require("../config/models");
+const config_1 = require("../config/config");
+const credentials_1 = require("../config/credentials");
+class App {
+    agent;
+    opts;
+    messages = [];
+    input = new input_1.InputBox();
+    scroll = 0;
+    status = 'Ready';
+    statusColor = terminal_1.ANSI.green;
+    connected = false;
+    running = false;
+    exitRequested = false;
+    modal = { type: 'none' };
+    sessionName;
+    pendingPrompt = '';
+    planToExecute = null;
+    abortController = null;
+    constructor(agent, opts) {
+        this.agent = agent;
+        this.opts = opts;
+        this.sessionName = opts.sessionName || null;
+        if (opts.askPermission) {
+            agent.setPermissionAsk(opts.askPermission);
+        }
+    }
+    // ─── Public API ───────────────────────────────────────────────
+    start() {
+        this.connected = true;
+        this.status = 'Ready';
+        this.addSystem('VECTOR ready. Type a request or press ? for help.');
+        if (this.opts.continueSession && this.sessionName) {
+            const sess = (0, session_1.loadSession)(this.sessionName);
+            if (sess) {
+                this.addSystem(`Continuing session "${this.sessionName}" (${sess.messages.length} messages)`);
+            }
+            else {
+                this.addSystem(`No saved session "${this.sessionName}" — starting fresh.`);
+            }
+        }
+        if (this.opts.initialPrompt) {
+            // Defer to after first render
+            this.pendingPrompt = this.opts.initialPrompt;
+        }
+    }
+    async handleKey(ev) {
+        if (this.modal.type !== 'none') {
+            await this.handleModalKey(ev);
+            return;
+        }
+        if (this.running) {
+            // Only allow stop while running
+            if (ev.name === 'ctrl_c' || ev.name === 'escape') {
+                this.abortController?.abort();
+                this.status = 'Stopping…';
+                this.statusColor = terminal_1.ANSI.yellow;
+                this.running = false;
+            }
+            return;
+        }
+        switch (ev.name) {
+            case 'char':
+                if (ev.char === '?')
+                    this.modal = { type: 'help' };
+                else if (ev.char)
+                    this.input.insert(ev.char);
+                break;
+            case 'enter': {
+                const text = this.input.value.trim();
+                if (text) {
+                    this.input.pushHistory(text);
+                    this.input.clear();
+                    await this.submit(text);
+                }
+                break;
+            }
+            case 'backspace':
+                this.input.backspace();
+                break;
+            case 'delete':
+                this.input.deleteForward();
+                break;
+            case 'left':
+                this.input.moveLeft();
+                break;
+            case 'right':
+                this.input.moveRight();
+                break;
+            case 'home':
+                this.input.moveHome();
+                break;
+            case 'end':
+                this.input.moveEnd();
+                break;
+            case 'up':
+                this.input.historyPrev();
+                break;
+            case 'down':
+                this.input.historyNext();
+                break;
+            case 'pageup':
+                this.scroll = (0, chat_1.clampScroll)(this.scroll - 10, this.messages, this.cols(), this.chatHeight());
+                break;
+            case 'pagedown':
+                this.scroll = (0, chat_1.clampScroll)(this.scroll + 10, this.messages, this.cols(), this.chatHeight());
+                break;
+            case 'ctrl_u':
+                this.input.deleteToStart();
+                break;
+            case 'ctrl_w':
+                this.input.deleteWordBack();
+                break;
+            case 'ctrl_a':
+                this.input.moveHome();
+                break;
+            case 'ctrl_e':
+                this.input.moveEnd();
+                break;
+            case 'ctrl_l':
+                this.messages = [];
+                this.scroll = 0;
+                this.addSystem('Conversation cleared.');
+                break;
+            case 'tab':
+                this.modal = { type: 'commands' };
+                break;
+            case 'ctrl_c':
+                this.exitRequested = true;
+                break;
+            case 'escape':
+                this.input.clear();
+                break;
+            default:
+                break;
+        }
+    }
+    async tick() {
+        if (this.pendingPrompt) {
+            const p = this.pendingPrompt;
+            this.pendingPrompt = '';
+            await this.submit(p);
+        }
+        if (this.planToExecute) {
+            const plan = this.planToExecute;
+            this.planToExecute = null;
+            await this.executeWithPlan(plan);
+        }
+        if (this.exitRequested) {
+            await this.shutdown();
+        }
+    }
+    // ─── Submission ───────────────────────────────────────────────
+    async submit(text) {
+        if (text.startsWith('/')) {
+            await this.handleCommand(text);
+            return;
+        }
+        this.messages.push({ kind: 'user', content: text });
+        this.scroll = 0;
+        this.running = true;
+        this.status = 'Thinking';
+        this.statusColor = terminal_1.ANSI.yellow;
+        this.abortController = new AbortController();
+        // Show plan first if requested
+        if (this.opts.showPlan) {
+            this.status = 'Planning…';
+            try {
+                const plan = await (0, planner_1.generatePlan)(this.agent.provider, text, this.agent.cwd, this.agent.config.model, this.abortController.signal);
+                if (plan.steps.length > 0) {
+                    this.modal = {
+                        type: 'plan',
+                        plan,
+                        resolve: async (ok) => {
+                            if (ok) {
+                                this.planToExecute = plan;
+                            }
+                            else {
+                                this.running = false;
+                                this.status = 'Ready';
+                                this.statusColor = terminal_1.ANSI.green;
+                                this.addSystem('Plan cancelled.');
+                            }
+                        },
+                    };
+                    return;
+                }
+            }
+            catch {
+                /* fall through to direct execution */
+            }
+        }
+        await this.runTask(text);
+    }
+    async runTask(text, planSteps) {
+        const task = planSteps
+            ? `TASK: ${text}\n\nFollow this plan:\n${planSteps.map((s, i) => `${i + 1}. ${s}`).join('\n')}`
+            : text;
+        const msgIndex = this.messages.push({
+            kind: 'assistant',
+            content: '',
+            streaming: true,
+        }) - 1;
+        this.agent.setCallbacks({
+            onDelta: (delta) => {
+                const m = this.messages[msgIndex];
+                if (m)
+                    m.content += delta;
+            },
+            onStatus: (status) => {
+                this.status = status;
+                this.statusColor = status.startsWith('✗') || status.includes('error') || status.includes('Error') ? terminal_1.ANSI.red : terminal_1.ANSI.yellow;
+            },
+            onToolCall: (tool, args) => {
+                let preview = '';
+                try {
+                    const parsed = JSON.parse(args);
+                    preview = Object.entries(parsed)
+                        .map(([k, v]) => `${k}=${String(v).slice(0, 60)}`)
+                        .join(' ');
+                }
+                catch {
+                    preview = args.slice(0, 80);
+                }
+                this.messages.push({ kind: 'tool', tool, content: `→ ${preview}` });
+            },
+            onToolResult: (tool, result) => {
+                const last = this.messages[this.messages.length - 1];
+                if (last && last.kind === 'tool' && last.tool === tool) {
+                    last.content = result.split('\n').slice(0, 12).join('\n');
+                    if (result.split('\n').length > 12)
+                        last.content += '\n…';
+                }
+            },
+            onError: (err) => {
+                const m = this.messages[msgIndex];
+                if (m) {
+                    m.kind = 'error';
+                    m.content = `⚠️ ${err.message}`;
+                    m.streaming = false;
+                }
+            },
+            onFinal: (result) => {
+                const m = this.messages[msgIndex];
+                if (m) {
+                    m.content = result.content || m.content;
+                    m.streaming = false;
+                }
+            },
+        });
+        try {
+            await this.agent.run(task, this.abortController?.signal);
+        }
+        catch (err) {
+            if (err.message === 'aborted') {
+                const m = this.messages[msgIndex];
+                if (m) {
+                    m.content += '\n\n⏹ (stopped by user)';
+                    m.streaming = false;
+                }
+            }
+            else {
+                const m = this.messages[msgIndex];
+                if (m) {
+                    m.kind = 'error';
+                    m.content = `⚠️ ${err.message}`;
+                    m.streaming = false;
+                }
+            }
+        }
+        finally {
+            const m = this.messages[msgIndex];
+            if (m) {
+                m.streaming = false;
+                if (!m.content.trim())
+                    m.content = '(no response)';
+            }
+            this.running = false;
+            if (this.statusColor !== terminal_1.ANSI.red) {
+                this.status = 'Ready';
+                this.statusColor = terminal_1.ANSI.green;
+            }
+            if (this.sessionName) {
+                try {
+                    (0, session_1.saveSession)(this.sessionName, this.messagesToSession(), {
+                        cwd: this.agent.cwd,
+                        model: this.agent.config.model,
+                        provider: this.agent.config.provider,
+                    });
+                }
+                catch {
+                    /* ignore */
+                }
+            }
+        }
+    }
+    messagesToSession() {
+        // Convert chat messages back to provider messages (approximation)
+        return this.messages
+            .filter((m) => m.kind === 'user' || m.kind === 'assistant')
+            .map((m) => ({
+            role: (m.kind === 'user' ? 'user' : 'assistant'),
+            content: m.content,
+        }));
+    }
+    async executeWithPlan(plan) {
+        this.running = true;
+        this.status = 'Executing plan';
+        this.statusColor = terminal_1.ANSI.yellow;
+        this.abortController = new AbortController();
+        await this.runTask(this.lastUserText() || 'Follow the plan.', plan.steps);
+    }
+    lastUserText() {
+        for (let i = this.messages.length - 1; i >= 0; i--) {
+            if (this.messages[i].kind === 'user')
+                return this.messages[i].content;
+        }
+        return '';
+    }
+    // ─── Commands ─────────────────────────────────────────────────
+    async handleCommand(cmd) {
+        const [name, ...rest] = cmd.split(/\s+/);
+        const arg = rest.join(' ').trim();
+        switch (name) {
+            case '/help':
+                this.modal = { type: 'help' };
+                break;
+            case '/commands':
+                this.modal = { type: 'commands' };
+                break;
+            case '/model':
+                this.modal = { type: 'model', selected: 0 };
+                break;
+            case '/provider':
+                this.modal = { type: 'provider', selected: 0 };
+                break;
+            case '/session':
+                this.modal = { type: 'session', selected: 0 };
+                break;
+            case '/settings':
+                this.modal = { type: 'settings' };
+                break;
+            case '/status':
+                this.modal = { type: 'status' };
+                break;
+            case '/clear':
+                this.messages = [];
+                this.scroll = 0;
+                this.addSystem('Conversation cleared.');
+                break;
+            case '/continue':
+                if (this.sessionName) {
+                    const sess = (0, session_1.loadSession)(this.sessionName);
+                    if (sess && sess.messages.length > 0) {
+                        this.addSystem(`Loaded ${sess.messages.length} messages from session "${this.sessionName}".`);
+                        this.opts.continueSession = true;
+                    }
+                }
+                else {
+                    const sessions = (0, session_1.listSessions)();
+                    if (sessions.length === 0) {
+                        this.addSystem('No saved sessions.');
+                    }
+                    else {
+                        this.modal = { type: 'session', selected: 0 };
+                    }
+                }
+                break;
+            case '/diff':
+                this.showLastDiff();
+                break;
+            case '/git':
+                await this.runGitStatus();
+                break;
+            case '/compact':
+                this.addSystem('Context compaction: truncating older messages.');
+                this.messages = this.messages.slice(-20);
+                break;
+            case '/yolo':
+                this.agent.setMode(this.agent.config.permissionMode === 'yolo' ? 'ask' : 'yolo');
+                this.addSystem(this.agent.config.permissionMode === 'yolo'
+                    ? 'YOLO mode enabled — permission prompts skipped for ask-level actions.'
+                    : 'Ask mode enabled.');
+                break;
+            case '/exit':
+            case '/quit':
+                this.exitRequested = true;
+                break;
+            case '/session-name':
+                if (arg) {
+                    this.sessionName = arg;
+                    this.addSystem(`Session set to "${arg}".`);
+                }
+                else {
+                    this.addSystem(`Current session: ${this.sessionName || '(none)'}`);
+                }
+                break;
+            default:
+                this.addSystem(`Unknown command: ${name} (type /help for commands)`);
+                break;
+        }
+    }
+    async runGitStatus() {
+        this.addTool('git', '$ git status --short');
+        const res = await Promise.resolve().then(() => __importStar(require('../tools/shell'))).then((m) => m.runShell('git status --short', this.agent.cwd, { timeoutMs: 30_000 }));
+        this.addTool('git', res.stdout || '(clean)');
+    }
+    showLastDiff() {
+        this.addSystem('Diff viewer: select a changed file (coming via git diff).');
+        this.addTool('git', '$ git diff --stat');
+    }
+    // ─── Modal key handling ───────────────────────────────────────
+    async handleModalKey(ev) {
+        const modal = this.modal;
+        switch (modal.type) {
+            case 'none':
+                return;
+            case 'help':
+            case 'commands':
+            case 'status':
+            case 'settings':
+                if (ev.name === 'escape' || ev.name === 'enter' || ev.name === 'ctrl_c' || (ev.name === 'char' && ev.char === '?')) {
+                    this.modal = { type: 'none' };
+                }
+                else if (ev.name === 'pageup') {
+                    this.scroll = (0, chat_1.clampScroll)(this.scroll - 10, this.messages, this.cols(), this.chatHeight());
+                }
+                else if (ev.name === 'pagedown') {
+                    this.scroll = (0, chat_1.clampScroll)(this.scroll + 10, this.messages, this.cols(), this.chatHeight());
+                }
+                break;
+            case 'provider':
+                await this.handleSelector(modal, ev, (0, factory_1.providerDisplayNames)().map((p) => ({ label: p.name, value: p.id })), async (opt) => {
+                    const pid = opt.value;
+                    this.agent.config.provider = pid;
+                    this.agent.rebuildProvider();
+                    (0, config_1.saveConfig)(this.agent.config);
+                    this.addSystem(`Provider set to ${opt.label}.`);
+                    if (!(0, credentials_1.hasApiKey)(pid) && pid !== 'ollama') {
+                        this.modal = { type: 'apikey', provider: pid, value: '' };
+                        return;
+                    }
+                    this.modal = { type: 'none' };
+                });
+                break;
+            case 'model': {
+                const models = (0, models_1.modelsForProvider)(this.agent.config.provider);
+                await this.handleSelector(modal, ev, models.map((m) => ({ label: m.id, value: m.id })), async (m) => {
+                    this.agent.config.model = m.value;
+                    (0, config_1.saveConfig)(this.agent.config);
+                    this.addSystem(`Model set to ${m.value}.`);
+                    this.modal = { type: 'none' };
+                });
+                break;
+            }
+            case 'session': {
+                const sessions = (0, session_1.listSessions)();
+                await this.handleSelector(modal, ev, sessions.map((s) => ({ label: s.name, value: s.name, hint: `${s.messageCount} msgs` })), async (s) => {
+                    this.sessionName = s.value;
+                    const sess = (0, session_1.loadSession)(s.value);
+                    if (sess) {
+                        this.opts.continueSession = true;
+                        this.addSystem(`Loaded session "${s.value}".`);
+                    }
+                    this.modal = { type: 'none' };
+                });
+                break;
+            }
+            case 'diff':
+                if (ev.name === 'escape' || ev.name === 'ctrl_c') {
+                    this.modal = { type: 'none' };
+                }
+                else if (ev.name === 'pageup') {
+                    this.modal = { ...modal, scroll: modal.scroll - 10 };
+                }
+                else if (ev.name === 'pagedown') {
+                    this.modal = { ...modal, scroll: modal.scroll + 10 };
+                }
+                else if (ev.name === 'left' || ev.name === 'right') {
+                    this.modal = { ...modal, accept: modal.accept === 'accept' ? 'reject' : 'accept' };
+                }
+                else if (ev.name === 'enter') {
+                    const m = modal;
+                    this.modal = { type: 'none' };
+                    if (m.accept === 'accept')
+                        m.action();
+                    else
+                        m.rejectAction();
+                }
+                break;
+            case 'permission':
+                if (ev.name === 'enter' || (ev.name === 'char' && (ev.char === 'y' || ev.char === 'Y'))) {
+                    const m = modal;
+                    this.modal = { type: 'none' };
+                    m.resolve({ allow: true, remember: false });
+                }
+                else if (ev.name === 'escape' || (ev.name === 'char' && (ev.char === 'n' || ev.char === 'N'))) {
+                    const m = modal;
+                    this.modal = { type: 'none' };
+                    m.resolve({ allow: false, remember: false });
+                }
+                else if (ev.name === 'char' && (ev.char === 'a' || ev.char === 'A')) {
+                    const m = modal;
+                    this.modal = { type: 'none' };
+                    m.resolve({ allow: true, remember: true });
+                }
+                break;
+            case 'plan':
+                if (ev.name === 'enter' || (ev.name === 'char' && (ev.char === 'y' || ev.char === 'Y'))) {
+                    const m = modal;
+                    this.modal = { type: 'none' };
+                    m.resolve(true);
+                }
+                else if (ev.name === 'escape' || (ev.name === 'char' && (ev.char === 'n' || ev.char === 'N'))) {
+                    const m = modal;
+                    this.modal = { type: 'none' };
+                    m.resolve(false);
+                }
+                break;
+            case 'confirm':
+                if (ev.name === 'enter' || (ev.name === 'char' && (ev.char === 'y' || ev.char === 'Y'))) {
+                    const m = modal;
+                    this.modal = { type: 'none' };
+                    m.resolve(true);
+                }
+                else if (ev.name === 'escape' || (ev.name === 'char' && (ev.char === 'n' || ev.char === 'N'))) {
+                    const m = modal;
+                    this.modal = { type: 'none' };
+                    m.resolve(false);
+                }
+                break;
+            case 'apikey':
+                this.handleTextInput(ev, (value) => {
+                    (0, credentials_1.setApiKey)(modal.provider, value);
+                    this.addSystem(`API key stored for ${modal.provider} (not printed).`);
+                    this.modal = { type: 'none' };
+                });
+                break;
+            case 'custom-url':
+                this.handleTextInput(ev, (value) => {
+                    this.agent.config.apiUrl = value;
+                    (0, config_1.saveConfig)(this.agent.config);
+                    this.addSystem('Custom API URL set.');
+                    this.modal = { type: 'none' };
+                });
+                break;
+            case 'custom-key':
+                this.handleTextInput(ev, (value) => {
+                    (0, credentials_1.setApiKey)('custom', value);
+                    this.addSystem('Custom API key stored (not printed).');
+                    this.modal = { type: 'none' };
+                });
+                break;
+            default:
+                break;
+        }
+    }
+    async handleSelector(modal, ev, options, onSelect) {
+        if (options.length === 0) {
+            this.modal = { type: 'none' };
+            this.addSystem('No options available.');
+            return;
+        }
+        if (ev.name === 'escape' || ev.name === 'ctrl_c') {
+            this.modal = { type: 'none' };
+        }
+        else if (ev.name === 'up') {
+            this.modal = { ...modal, selected: Math.max(0, modal.selected - 1) };
+        }
+        else if (ev.name === 'down') {
+            this.modal = { ...modal, selected: Math.min(options.length - 1, modal.selected + 1) };
+        }
+        else if (ev.name === 'enter') {
+            await onSelect(options[modal.selected]);
+        }
+    }
+    handleTextInput(ev, onEnter) {
+        const m = this.modal;
+        if (ev.name === 'char' && ev.char) {
+            m.value += ev.char;
+        }
+        else if (ev.name === 'backspace') {
+            m.value = m.value.slice(0, -1);
+        }
+        else if (ev.name === 'enter') {
+            onEnter(m.value);
+        }
+        else if (ev.name === 'escape') {
+            this.modal = { type: 'none' };
+        }
+    }
+    // ─── Message helpers ──────────────────────────────────────────
+    addSystem(text) {
+        this.messages.push({ kind: 'system', content: text });
+    }
+    /** Show a permission modal (called by the permission callback). */
+    setPermissionModal(req) {
+        this.modal = {
+            type: 'permission',
+            req,
+            resolve: (d) => {
+                this.permissionResolver?.(d);
+            },
+        };
+    }
+    permissionResolver = null;
+    setPermissionResolver(fn) {
+        this.permissionResolver = fn;
+    }
+    addTool(tool, content) {
+        this.messages.push({ kind: 'tool', tool, content });
+    }
+    // ─── Rendering ────────────────────────────────────────────────
+    cols() {
+        return (0, terminal_1.getTerminalSize)().cols;
+    }
+    chatHeight() {
+        return Math.max(1, (0, terminal_1.getTerminalSize)().rows - 6);
+    }
+    render() {
+        const { rows, cols } = (0, terminal_1.getTerminalSize)();
+        const info = {
+            status: this.status,
+            statusColor: this.statusColor,
+            model: this.agent.config.model,
+            provider: this.agent.config.provider,
+            project: this.agent.cwd,
+            connected: this.connected,
+            mode: this.agent.config.permissionMode,
+        };
+        const parts = [];
+        parts.push((0, statusbar_1.renderHeader)(cols, info));
+        parts.push((0, statusbar_1.renderProjectBar)(cols, info));
+        // Chat area
+        const chatH = this.chatHeight();
+        const chatW = cols;
+        const all = (0, chat_1.renderMessages)(this.messages, chatW);
+        const maxScroll = Math.max(0, all.length - chatH);
+        this.scroll = Math.min(this.scroll, maxScroll);
+        const visible = all.slice(this.scroll, this.scroll + chatH);
+        const chatTop = 3;
+        for (let i = 0; i < chatH; i++) {
+            const content = visible[i] !== undefined ? visible[i] : '';
+            parts.push((0, terminal_1.cursorTo)(chatTop + i, 1) + terminal_1.ANSI.clearLineEnd + content);
+        }
+        // Separator
+        const sepRow = chatTop + chatH;
+        parts.push((0, terminal_1.cursorTo)(sepRow, 1) + terminal_1.ANSI.clearLineEnd + terminal_1.ANSI.dim + terminal_1.BOX.h.repeat(Math.min(cols, 120)) + terminal_1.ANSI.reset);
+        // Input
+        const inputRow = sepRow + 1;
+        const rendered = this.input.render(cols);
+        parts.push((0, terminal_1.cursorTo)(inputRow, 1) + terminal_1.ANSI.clearLineEnd + rendered.line);
+        const cursorCol = rendered.cursorCol + 1;
+        // Status bar
+        const statusRow = inputRow + 1;
+        parts.push((0, terminal_1.cursorTo)(statusRow, 1) + terminal_1.ANSI.clearLineEnd + (0, statusbar_1.renderStatusBar)(info, cols));
+        // Modal overlay
+        if (this.modal.type !== 'none') {
+            const overlay = this.renderModal(rows, cols);
+            for (const l of overlay.lines)
+                parts.push(l);
+        }
+        // Cursor placement
+        if (this.modal.type === 'none') {
+            parts.push((0, terminal_1.cursorTo)(inputRow, cursorCol));
+            parts.push(terminal_1.ANSI.showCursor);
+        }
+        else {
+            parts.push(terminal_1.ANSI.hideCursor);
+        }
+        return parts.join('');
+    }
+    renderModal(rows, cols) {
+        const m = this.modal;
+        switch (m.type) {
+            case 'help':
+                return (0, components_1.renderModal)({
+                    title: 'Help',
+                    body: [
+                        'VECTOR — AI Coding Agent',
+                        '',
+                        'Type a task and press Enter. The agent inspects,',
+                        'plans, edits, runs tests, and iterates until done.',
+                        '',
+                        'Keys:',
+                        '  Enter    send message',
+                        '  Tab      commands menu',
+                        '  ↑/↓      input history',
+                        '  PgUp/Dn  scroll chat',
+                        '  ?        this help',
+                        '  Ctrl+C   stop agent / quit',
+                        '  Ctrl+L   clear conversation',
+                        '',
+                        'Commands: /model /provider /session /settings',
+                        '/status /clear /continue /diff /git /compact',
+                        '/yolo /exit',
+                    ],
+                }, rows, cols);
+            case 'commands':
+                return (0, components_1.renderModal)({
+                    title: 'Commands',
+                    body: [
+                        '/help     show help',
+                        '/model    select model',
+                        '/provider select provider',
+                        '/session  manage sessions',
+                        '/settings view settings',
+                        '/status   agent status',
+                        '/clear    clear chat',
+                        '/continue continue session',
+                        '/diff     show diff',
+                        '/git      git status',
+                        '/compact  compact context',
+                        '/yolo     toggle permission mode',
+                        '/exit     quit',
+                    ],
+                }, rows, cols);
+            case 'settings':
+                return (0, components_1.renderModal)({
+                    title: 'Settings',
+                    body: [
+                        `Provider: ${this.agent.config.provider}`,
+                        `Model: ${this.agent.config.model}`,
+                        `Mode: ${this.agent.config.permissionMode}`,
+                        `Max iterations: ${this.agent.config.maxIterations}`,
+                        `Max retries: ${this.agent.config.maxRetries}`,
+                        `API URL: ${this.agent.config.apiUrl || '(default)'}`,
+                        `Key configured: ${(0, credentials_1.hasApiKey)(this.agent.config.provider) ? 'yes' : 'no'}`,
+                        '',
+                        'Env vars: VECTOR_API_KEY, VECTOR_API_URL,',
+                        'VECTOR_MODEL, VECTOR_PROVIDER',
+                    ],
+                }, rows, cols);
+            case 'status':
+                return (0, components_1.renderModal)({
+                    title: 'Status',
+                    body: [
+                        `Status: ${this.status}`,
+                        `Running: ${this.running ? 'yes' : 'no'}`,
+                        `Provider: ${this.agent.config.provider}`,
+                        `Model: ${this.agent.config.model}`,
+                        `CWD: ${this.agent.cwd}`,
+                        `Session: ${this.sessionName || '(none)'}`,
+                        `Messages: ${this.messages.length}`,
+                    ],
+                }, rows, cols);
+            case 'provider':
+                return (0, components_1.renderSelector)({
+                    title: 'Select Provider',
+                    options: (0, factory_1.providerDisplayNames)().map((p) => ({
+                        label: p.name,
+                        value: p.id,
+                        hint: (0, credentials_1.hasApiKey)(p.id) || p.id === 'ollama' ? 'configured' : 'no key',
+                    })),
+                    selected: m.selected,
+                    rows,
+                    cols,
+                });
+            case 'model': {
+                const models = (0, models_1.modelsForProvider)(this.agent.config.provider);
+                return (0, components_1.renderSelector)({
+                    title: `Model (${this.agent.config.provider})`,
+                    options: models.map((mo) => ({ label: mo.id, value: mo.id })),
+                    selected: m.selected,
+                    rows,
+                    cols,
+                });
+            }
+            case 'session': {
+                const sessions = (0, session_1.listSessions)();
+                return (0, components_1.renderSelector)({
+                    title: 'Sessions',
+                    options: sessions.length > 0
+                        ? sessions.map((s) => ({ label: s.name, value: s.name, hint: `${s.messageCount} msgs` }))
+                        : [{ label: '(no sessions)', value: '' }],
+                    selected: m.selected,
+                    rows,
+                    cols,
+                });
+            }
+            case 'diff':
+                return (0, diff_1.renderDiffModal)(m.entries, rows, cols, m.scroll, m.accept);
+            case 'permission': {
+                const danger = m.req.level === 'dangerous' || m.req.level === 'blocked';
+                return (0, components_1.renderModal)({
+                    title: `Permission (${m.req.level})`,
+                    body: [
+                        `${danger ? terminal_1.ANSI.brightRed + '⚠' : terminal_1.ANSI.yellow + '⚠'}${terminal_1.ANSI.reset} VECTOR wants to:`,
+                        '',
+                        `${terminal_1.ANSI.bold}${m.req.summary}${terminal_1.ANSI.reset}`,
+                        '',
+                        m.req.level === 'blocked'
+                            ? 'This action is BLOCKED by policy and cannot be approved.'
+                            : 'Allow? [y/N]  (a = always for this session)',
+                    ],
+                    danger,
+                }, rows, cols);
+            }
+            case 'plan':
+                return (0, components_1.renderModal)({
+                    title: 'Plan',
+                    body: [
+                        'Proposed plan:',
+                        '',
+                        ...m.plan.steps.map((s, i) => `${i + 1}. ${s}`),
+                        '',
+                        'Execute? [y/N]',
+                    ],
+                }, rows, cols);
+            case 'confirm':
+                return (0, components_1.renderModal)({ title: m.title, body: m.body }, rows, cols);
+            case 'apikey':
+                return (0, components_1.renderModal)({
+                    title: `API key for ${m.provider}`,
+                    body: [
+                        'Paste your API key (masked as you type):',
+                        '',
+                        terminal_1.ANSI.bold + (m.value ? '•'.repeat(m.value.length) : '') + terminal_1.ANSI.reset,
+                        '',
+                        'Enter to save · Esc to cancel',
+                    ],
+                }, rows, cols);
+            case 'custom-url':
+                return (0, components_1.renderModal)({
+                    title: 'Custom API URL',
+                    body: ['Endpoint, e.g. https://example.com/v1', '', m.value || '_', '', 'Enter to save · Esc to cancel'],
+                }, rows, cols);
+            case 'custom-key':
+                return (0, components_1.renderModal)({
+                    title: 'Custom API key',
+                    body: ['API key (masked)', '', m.value ? '•'.repeat(m.value.length) : '', '', 'Enter to save · Esc to cancel'],
+                }, rows, cols);
+            default:
+                return { lines: [] };
+        }
+    }
+    async shutdown() {
+        this.exitRequested = false;
+        if (this.sessionName && this.messages.length > 0) {
+            try {
+                (0, session_1.saveSession)(this.sessionName, this.messagesToSession(), {
+                    cwd: this.agent.cwd,
+                    model: this.agent.config.model,
+                    provider: this.agent.config.provider,
+                });
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        this.opts.onExit?.();
+    }
+}
+exports.App = App;