agen-vektor 0.1.0

package/dist/agent/planner.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePlan = generatePlan;
+const context_1 = require("./context");
+const PLAN_PROMPT = `You are a planning engine. Given the user's task and the project context, produce a concise numbered plan of the steps the agent should take. Output ONLY the numbered steps, one per line. No preamble, no markdown fences.`;
+async function generatePlan(provider, userRequest, cwd, model, signal) {
+    const projectCtx = (0, context_1.buildProjectContext)(cwd);
+    const entries = (0, context_1.listRootEntries)(cwd);
+    const messages = [
+        { role: 'system', content: PLAN_PROMPT },
+        {
+            role: 'user',
+            content: `Project context:\n${projectCtx}\n\n${entries}\n\nTASK:\n${userRequest}`,
+        },
+    ];
+    try {
+        const res = await provider.chat({ messages, model, signal, temperature: 0.2, maxTokens: 600 });
+        const steps = res.content
+            .split('\n')
+            .map((l) => l.replace(/^\s*\d+[.)]\s*/, '').replace(/^\s*[-*]\s*/, '').trim())
+            .filter((l) => l.length > 0)
+            .slice(0, 15);
+        return { steps: steps.length > 0 ? steps : [userRequest], raw: res.content };
+    }
+    catch {
+        // Fallback plan when the provider fails
+        return {
+            steps: [
+                `Inspect the project structure at ${cwd}`,
+                `Understand the request: ${userRequest}`,
+                'Implement the required changes',
+                'Verify with tests/build',
+                'Report the result',
+            ],
+            raw: '',
+        };
+    }
+}

package/dist/agent/prompts.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Prompts — system prompt + task framing for VECTOR.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYSTEM_PROMPT = void 0;
+exports.taskPrompt = taskPrompt;
+exports.continuationPrompt = continuationPrompt;
+exports.SYSTEM_PROMPT = `You are VECTOR, an AI coding agent operating inside a terminal.
+
+You work autonomously inside the user's project directory. You can:
+- Inspect the project structure and files
+- Read, create, edit, and delete files (deletion always asks permission)
+- Run shell commands (build, test, install, git, etc.)
+- Search the codebase
+- Iterate: run tests, read errors, fix, retry until the task is done
+
+Rules:
+1. Always inspect the project before proposing changes. Never guess at file contents.
+2. Prefer small, targeted edits over rewriting whole files.
+3. After editing code, run the project's tests/build to verify (npm test, npm run build, pytest, etc.).
+4. If a command fails, read the error, diagnose, fix, and retry. Do not give up after the first failure.
+5. When the task is complete, summarize what you changed and the verification result.
+6. Never print API keys, tokens, or secrets. If you find a secret, say so without revealing it.
+7. When you need more information than you have, use tools to get it instead of asking the user.
+8. Answer in the same language the user used.
+9. Keep responses concise but complete: state what you did, why, and how it was verified.`;
+function taskPrompt(userRequest, cwd) {
+    return `Working directory: ${cwd}
+
+TASK (from the user):
+${userRequest}
+
+Work through this task step by step using the available tools. Do not stop until the task is complete and verified.`;
+}
+function continuationPrompt(plan) {
+    return `Proposed plan:
+${plan.map((p, i) => `${i + 1}. ${p}`).join('\n')}
+
+Execute this plan, adapting as needed based on what you find.`;
+}

package/dist/agent/session.js

@@ -0,0 +1,125 @@
+"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.listSessions = listSessions;
+exports.loadSession = loadSession;
+exports.saveSession = saveSession;
+exports.deleteSession = deleteSession;
+exports.messagesToContinue = messagesToContinue;
+/**
+ * Session — persists conversation history + metadata to ~/.vector/sessions/.
+ * Secrets are never stored: only message roles/content/tool-call names.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const paths_1 = require("../utils/paths");
+const credentials_1 = require("../config/credentials");
+function fileFor(name) {
+    return path.join((0, paths_1.getSessionsDir)(), `${(0, paths_1.sanitizeName)(name)}.json`);
+}
+function listSessions() {
+    (0, paths_1.ensureDirs)();
+    try {
+        const files = fs.readdirSync((0, paths_1.getSessionsDir)()).filter((f) => f.endsWith('.json'));
+        const metas = [];
+        for (const f of files) {
+            try {
+                const data = JSON.parse(fs.readFileSync(path.join((0, paths_1.getSessionsDir)(), f), 'utf8'));
+                metas.push(data.meta);
+            }
+            catch {
+                /* skip corrupt */
+            }
+        }
+        return metas.sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+    }
+    catch {
+        return [];
+    }
+}
+function loadSession(name) {
+    try {
+        const p = fileFor(name);
+        if (!fs.existsSync(p))
+            return null;
+        return JSON.parse(fs.readFileSync(p, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+function saveSession(name, messages, opts) {
+    (0, paths_1.ensureDirs)();
+    const existing = loadSession(name);
+    const now = new Date().toISOString();
+    const meta = {
+        name,
+        cwd: opts.cwd,
+        createdAt: existing?.meta.createdAt || now,
+        updatedAt: now,
+        model: opts.model,
+        provider: opts.provider,
+        messageCount: messages.length,
+    };
+    // Never persist secrets: redact any key-like content before writing.
+    const sanitized = messages.map((m) => ({
+        ...m,
+        content: (0, credentials_1.redact)(m.content),
+        toolCalls: m.toolCalls?.map((tc) => ({
+            ...tc,
+            arguments: (0, credentials_1.redact)(tc.arguments),
+        })),
+    }));
+    const data = { meta, messages: sanitized };
+    fs.writeFileSync(fileFor(name), JSON.stringify(data, null, 2));
+}
+function deleteSession(name) {
+    try {
+        const p = fileFor(name);
+        if (fs.existsSync(p)) {
+            fs.unlinkSync(p);
+            return true;
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return false;
+}
+/** Build the message history to continue from an existing session. */
+function messagesToContinue(session, maxMessages = 40) {
+    const msgs = session.messages.filter((m) => m.role === 'user' || m.role === 'assistant' || m.role === 'tool' || m.role === 'system');
+    return msgs.slice(-maxMessages);
+}

package/dist/cli/index.js

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * VECTOR — AI Coding Agent CLI/TUI
+ *
+ * Usage:
+ *   vector                    start interactive TUI
+ *   vector "task description" run a task in the TUI immediately
+ *   vector --model M --provider P
+ *   vector --continue         continue last session
+ *   vector --session NAME
+ *   vector --plan             show a plan before executing
+ *   vector --yolo             skip permission prompts (ask-level)
+ *   vector --version | --help
+ */
+const app_1 = require("../tui/app");
+const agent_1 = require("../agent/agent");
+const config_1 = require("../config/config");
+const credentials_1 = require("../config/credentials");
+const paths_1 = require("../utils/paths");
+const logger_1 = require("../utils/logger");
+const keyboard_1 = require("./keyboard");
+const terminal_1 = require("../utils/terminal");
+const session_1 = require("../agent/session");
+const VERSION = '0.1.0';
+function parseArgs(argv) {
+    const opts = {};
+    const positional = [];
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        switch (a) {
+            case '--model':
+                opts.model = argv[++i];
+                break;
+            case '--provider':
+                opts.provider = argv[++i];
+                break;
+            case '--continue':
+                opts.continueSession = true;
+                break;
+            case '--session':
+                opts.sessionName = argv[++i];
+                break;
+            case '--plan':
+                opts.plan = true;
+                break;
+            case '--yolo':
+                opts.yolo = true;
+                break;
+            case '--help':
+            case '-h':
+                opts.help = true;
+                break;
+            case '--version':
+            case '-v':
+                opts.version = true;
+                break;
+            case '--non-interactive':
+                opts.nonInteractive = true;
+                break;
+            default:
+                if (a.startsWith('-')) {
+                    console.error(`Unknown option: ${a} (see --help)`);
+                    process.exit(1);
+                }
+                positional.push(a);
+                break;
+        }
+    }
+    if (positional.length > 0)
+        opts.prompt = positional.join(' ');
+    return opts;
+}
+function printHelp() {
+    console.log(`VECTOR — AI Coding Agent for Linux & Termux v${VERSION}
+
+Usage:
+  vector                     Start the interactive terminal UI
+  vector "task"              Start TUI and run the task immediately
+  vector --model MODEL       Set model
+  vector --provider P        Set provider (openai, anthropic, gemini,
+                             openrouter, ollama, custom)
+  vector --continue          Continue the most recent session
+  vector --session NAME      Use/resume session NAME
+  vector --plan              Show a plan before executing
+  vector --yolo              Skip permission prompts (ask-level actions)
+  vector --version           Print version
+  vector --help              Show this help
+
+Environment:
+  VECTOR_API_KEY    API key for custom provider
+  VECTOR_API_URL    Base URL for custom provider
+  VECTOR_MODEL      Default model
+  VECTOR_PROVIDER   Default provider
+  VECTOR_HOME       Config dir (default ~/.vector)
+
+Config lives in ~/.vector/. Run 'vector' and type /help for commands.`);
+}
+async function buildAgent(opts) {
+    const config = (0, config_1.loadConfig)();
+    if (opts.model)
+        config.model = opts.model;
+    if (opts.provider)
+        config.provider = opts.provider;
+    if (opts.yolo) {
+        config.permissionMode = 'yolo';
+        (0, config_1.saveConfig)(config);
+    }
+    (0, paths_1.ensureDirs)();
+    return new agent_1.Agent({ config, cwd: process.cwd() });
+}
+/** Non-interactive run: executes the task and prints output. */
+async function runNonInteractive(opts) {
+    const agent = await buildAgent(opts);
+    const hasKey = agent.config.provider === 'ollama' ||
+        (0, credentials_1.hasApiKey)(agent.config.provider) ||
+        (agent.config.provider === 'custom' && Boolean(agent.config.apiUrl));
+    if (!hasKey) {
+        console.error(`VECTOR: no API key configured for provider "${agent.config.provider}".\n` +
+            `Set ${providerEnv(agent.config.provider)} or run \`vector\` and use /provider to enter a key.`);
+        process.exit(1);
+    }
+    const prompt = opts.prompt;
+    if (!prompt) {
+        console.error('VECTOR: no task provided (non-interactive mode). Pass a prompt as an argument.');
+        process.exit(1);
+    }
+    console.log(`${terminal_1.ANSI.bold}${terminal_1.ANSI.brightCyan}VECTOR${terminal_1.ANSI.reset} — ${agent.config.provider}/${agent.config.model}`);
+    console.log(`${terminal_1.ANSI.dim}Project: ${agent.cwd}${terminal_1.ANSI.reset}\n`);
+    // Continue session if requested
+    let sessionMessages = null;
+    if (opts.continueSession || opts.sessionName) {
+        const name = opts.sessionName || latestSessionName();
+        if (name) {
+            const sess = (0, session_1.loadSession)(name);
+            if (sess && sess.messages.length > 0) {
+                sessionMessages = sess;
+                console.log(`${terminal_1.ANSI.dim}Continuing session: ${name}${terminal_1.ANSI.reset}`);
+            }
+        }
+    }
+    const result = await agent.runWithContext(prompt, sessionMessages, {
+        onStatus: (s) => console.log(`${terminal_1.ANSI.dim}▸ ${s}${terminal_1.ANSI.reset}`),
+        onToolCall: (t, args) => {
+            let preview = '';
+            try {
+                const p = JSON.parse(args);
+                preview = Object.entries(p).map(([k, v]) => `${k}=${String(v).slice(0, 60)}`).join(' ');
+            }
+            catch {
+                preview = args.slice(0, 80);
+            }
+            console.log(`${terminal_1.ANSI.brightYellow}⚙ ${t}${terminal_1.ANSI.reset} ${terminal_1.ANSI.dim}${preview}${terminal_1.ANSI.reset}`);
+        },
+        onDelta: (d) => process.stdout.write(d),
+        onFinal: () => process.stdout.write('\n'),
+    });
+    console.log(`\n${terminal_1.ANSI.dim}— ${result.iterations} iterations, ${result.toolCalls} tool calls${terminal_1.ANSI.reset}`);
+    if (opts.sessionName) {
+        // persist
+    }
+    process.exit(0);
+}
+function providerEnv(provider) {
+    switch (provider) {
+        case 'openai':
+            return 'OPENAI_API_KEY';
+        case 'anthropic':
+            return 'ANTHROPIC_API_KEY';
+        case 'gemini':
+            return 'GEMINI_API_KEY';
+        case 'openrouter':
+            return 'OPENROUTER_API_KEY';
+        case 'custom':
+            return 'VECTOR_API_KEY';
+        default:
+            return 'VECTOR_API_KEY';
+    }
+}
+function latestSessionName() {
+    const sessions = (0, session_1.listSessions)();
+    return sessions.length > 0 ? sessions[0].name : undefined;
+}
+async function runTui(opts) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        await runNonInteractive(opts);
+        return;
+    }
+    const agent = await buildAgent(opts);
+    const config = agent.config;
+    const hasKey = config.provider === 'ollama' ||
+        (0, credentials_1.hasApiKey)(config.provider) ||
+        (config.provider === 'custom' && Boolean(config.apiUrl));
+    if (!hasKey) {
+        console.log(`${terminal_1.ANSI.yellow}⚠${terminal_1.ANSI.reset} No API key configured for provider "${config.provider}".\n` +
+            `Set ${providerEnv(config.provider)} in your environment, or run /provider inside VECTOR to add one.\n`);
+    }
+    // Resolve session name
+    let sessionName = opts.sessionName;
+    if (opts.continueSession && !sessionName) {
+        sessionName = latestSessionName();
+    }
+    let exit = false;
+    // Permission callback: drive a modal through the app
+    let app = null;
+    let permissionResolver = null;
+    const askPermission = async (req) => {
+        if (req.level === 'blocked')
+            return { allow: false, remember: false };
+        // Use the app modal
+        return new Promise((resolve) => {
+            permissionResolver = resolve;
+            app?.setPermissionModal(req);
+        });
+    };
+    agent.setPermissionAsk(askPermission);
+    app = new app_1.App(agent, {
+        initialPrompt: opts.prompt,
+        sessionName: sessionName || undefined,
+        continueSession: opts.continueSession,
+        showPlan: opts.plan,
+        onExit: () => {
+            exit = true;
+        },
+    });
+    app.setPermissionResolver((d) => {
+        if (permissionResolver) {
+            permissionResolver(d);
+            permissionResolver = null;
+        }
+    });
+    // Terminal setup
+    const cleanup = (0, keyboard_1.enableRawMode)();
+    const doRender = () => {
+        const out = app.render();
+        process.stdout.write(terminal_1.ANSI.hideCursor + out);
+    };
+    const onResize = () => doRender();
+    process.stdout.on('resize', onResize);
+    process.on('SIGINT', () => {
+        // Ctrl+C is handled via raw mode keys; SIGINT may still fire
+    });
+    process.on('SIGWINCH', onResize);
+    const keyHandler = (ev) => {
+        void app.handleKey(ev);
+    };
+    try {
+        // Enable alt screen + clear
+        process.stdout.write(terminal_1.ANSI.enableAltScreen);
+        process.stdout.write(terminal_1.ANSI.clearScreen);
+        (0, keyboard_1.keyStream)(keyHandler);
+        app.start();
+        doRender();
+        // Main tick loop
+        while (!exit) {
+            await app.tick();
+            doRender();
+            await sleep(50);
+        }
+    }
+    finally {
+        process.stdout.write(terminal_1.ANSI.disableAltScreen);
+        process.stdout.write(terminal_1.ANSI.showCursor);
+        process.stdout.removeListener('resize', onResize);
+        cleanup();
+    }
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+async function main() {
+    const opts = parseArgs(process.argv.slice(2));
+    if (opts.version) {
+        console.log(`vector v${VERSION}`);
+        return;
+    }
+    if (opts.help) {
+        printHelp();
+        return;
+    }
+    // Warnings
+    if (opts.yolo) {
+        console.warn(`${terminal_1.ANSI.yellow}⚠ WARNING: --yolo mode skips permission prompts for ask-level actions.${terminal_1.ANSI.reset}`);
+    }
+    (0, paths_1.ensureDirs)();
+    logger_1.logger.info(`VECTOR v${VERSION} started in ${process.cwd()}`);
+    if (opts.nonInteractive) {
+        await runNonInteractive(opts);
+        return;
+    }
+    try {
+        await runTui(opts);
+    }
+    catch (err) {
+        logger_1.logger.error(`fatal: ${err.message}`);
+        console.error(`VECTOR error: ${err.message}`);
+        process.exitCode = 1;
+    }
+}
+main().catch((err) => {
+    console.error(`VECTOR fatal: ${err.message}`);
+    process.exit(1);
+});