agen-vektor 0.1.0

package/dist/security/permissions.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PermissionManager = void 0;
+/**
+ * Permission manager — gates tool execution behind user consent.
+ */
+const command_policy_1 = require("./command-policy");
+/**
+ * Session-scoped permission cache: remember "always allow" decisions
+ * for the current run only. Persisted rules are out of scope deliberately.
+ */
+class PermissionManager {
+    mode;
+    ask;
+    rememberedAllow = new Set();
+    constructor(opts) {
+        this.mode = opts.mode;
+        this.ask = opts.ask;
+    }
+    setMode(mode) {
+        this.mode = mode;
+    }
+    getMode() {
+        return this.mode;
+    }
+    static key(tool, summary) {
+        return `${tool}::${summary}`;
+    }
+    /**
+     * Decide whether a tool action is allowed.
+     *
+     * - blocked  → always refused
+     * - safe    → always allowed
+     * - ask     → allowed in yolo mode; otherwise prompt
+     * - dangerous → prompt even in yolo mode (yolo only auto-allows 'ask')
+     */
+    async decide(req) {
+        if (req.level === 'blocked')
+            return false;
+        if (req.level === 'safe')
+            return true;
+        const k = PermissionManager.key(req.tool, req.summary);
+        if (this.rememberedAllow.has(k))
+            return true;
+        if (this.mode === 'yolo') {
+            if (req.level === 'ask')
+                return true;
+            // dangerous: still prompt in yolo mode
+        }
+        if (!this.ask) {
+            // Non-interactive: default deny for anything requiring a prompt.
+            // --yolo in non-interactive mode still allows 'ask' (handled above).
+            return false;
+        }
+        const decision = await this.ask(req);
+        if (decision.allow && decision.remember) {
+            this.rememberedAllow.add(k);
+        }
+        return decision.allow;
+    }
+    /** Classify a shell command through the command policy. */
+    classifyCommand(command) {
+        return (0, command_policy_1.classifyCommand)(command).level;
+    }
+}
+exports.PermissionManager = PermissionManager;

package/dist/tools/filesystem.js

@@ -0,0 +1,297 @@
+"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.createFilesystemTools = createFilesystemTools;
+/**
+ * Filesystem tools — read, write, edit, list, delete.
+ * All paths are resolved relative to the working directory.
+ */
+const fs = __importStar(require("node:fs"));
+const fsp = __importStar(require("node:fs/promises"));
+const path = __importStar(require("node:path"));
+function resolve(cwd, p) {
+    return path.resolve(cwd, p);
+}
+function safeRelative(cwd, abs) {
+    return path.relative(cwd, abs) || '.';
+}
+function err(msg) {
+    return { output: `ERROR: ${msg}` };
+}
+function truncateOutput(text, max) {
+    if (text.length <= max)
+        return text;
+    return text.slice(0, max) + `\n... [truncated ${text.length - max} chars]`;
+}
+function createFilesystemTools(maxDefaultOutput = 30_000) {
+    return [
+        {
+            definition: {
+                name: 'read_file',
+                description: 'Read the contents of a file. Provide a relative path. Optionally set offset (1-based line) and limit (number of lines). Returns file content with line numbers.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Path to the file, relative to project root' },
+                        offset: { type: 'number', description: 'Line number to start from (1-based)' },
+                        limit: { type: 'number', description: 'Max lines to read' },
+                    },
+                    required: ['path'],
+                },
+            },
+            async execute(args, ctx) {
+                const p = resolve(ctx.cwd, String(args.path || ''));
+                try {
+                    const stat = await fsp.stat(p);
+                    if (stat.isDirectory()) {
+                        return err(`"${safeRelative(ctx.cwd, p)}" is a directory`);
+                    }
+                    const content = await fsp.readFile(p, 'utf8');
+                    let lines = content.split('\n');
+                    // A trailing newline produces an empty last element; don't count it.
+                    if (content.endsWith('\n'))
+                        lines = lines.slice(0, -1);
+                    const offset = Math.max(1, Number(args.offset) || 1);
+                    const limit = args.limit ? Math.max(1, Number(args.limit)) : lines.length;
+                    const slice = lines.slice(offset - 1, offset - 1 + limit);
+                    const numbered = slice
+                        .map((l, i) => `${String(offset + i).padStart(5)}| ${l}`)
+                        .join('\n');
+                    const total = lines.length;
+                    const header = `file: ${safeRelative(ctx.cwd, p)} (${total} lines)`;
+                    return {
+                        output: truncateOutput(`${header}\n${numbered}`, ctx.maxOutput || maxDefaultOutput),
+                        summary: `read ${safeRelative(ctx.cwd, p)}`,
+                        data: { path: safeRelative(ctx.cwd, p), lines: slice },
+                    };
+                }
+                catch (e) {
+                    return err(`cannot read "${args.path}": ${e.message}`);
+                }
+            },
+        },
+        {
+            definition: {
+                name: 'write_file',
+                description: 'Create a new file or overwrite an existing file with the given content. Creates parent directories as needed. Use for new files or full rewrites; prefer edit_file for small changes.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Path to the file, relative to project root' },
+                        content: { type: 'string', description: 'Full file content' },
+                    },
+                    required: ['path', 'content'],
+                },
+            },
+            async execute(args, ctx) {
+                const p = resolve(ctx.cwd, String(args.path || ''));
+                const content = String(args.content ?? '');
+                try {
+                    await fsp.mkdir(path.dirname(p), { recursive: true });
+                    await fsp.writeFile(p, content, 'utf8');
+                    return {
+                        output: `wrote ${content.length} bytes to ${safeRelative(ctx.cwd, p)}`,
+                        summary: `wrote ${safeRelative(ctx.cwd, p)}`,
+                        permission: 'ask',
+                    };
+                }
+                catch (e) {
+                    return err(`cannot write "${args.path}": ${e.message}`);
+                }
+            },
+        },
+        {
+            definition: {
+                name: 'edit_file',
+                description: 'Edit a file by replacing an exact string with a new string. The old string must match exactly (including whitespace). Use for small targeted changes.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Path to the file, relative to project root' },
+                        old_string: { type: 'string', description: 'Exact text to find and replace' },
+                        new_string: { type: 'string', description: 'Replacement text' },
+                        replace_all: { type: 'boolean', description: 'Replace all occurrences (default false)' },
+                    },
+                    required: ['path', 'old_string', 'new_string'],
+                },
+            },
+            async execute(args, ctx) {
+                const p = resolve(ctx.cwd, String(args.path || ''));
+                const oldStr = String(args.old_string ?? '');
+                const newStr = String(args.new_string ?? '');
+                if (!oldStr)
+                    return err('old_string must not be empty');
+                try {
+                    const content = await fsp.readFile(p, 'utf8');
+                    if (args.replace_all) {
+                        if (!content.includes(oldStr)) {
+                            return err(`old_string not found in ${safeRelative(ctx.cwd, p)}`);
+                        }
+                        const updated = content.split(oldStr).join(newStr);
+                        await fsp.writeFile(p, updated, 'utf8');
+                        return {
+                            output: `replaced all occurrences in ${safeRelative(ctx.cwd, p)}`,
+                            summary: `edited ${safeRelative(ctx.cwd, p)}`,
+                            permission: 'ask',
+                        };
+                    }
+                    const idx = content.indexOf(oldStr);
+                    if (idx === -1) {
+                        return err(`old_string not found in ${safeRelative(ctx.cwd, p)}. The string must match EXACTLY including whitespace.`);
+                    }
+                    const updated = content.slice(0, idx) + newStr + content.slice(idx + oldStr.length);
+                    await fsp.writeFile(p, updated, 'utf8');
+                    return {
+                        output: `edited ${safeRelative(ctx.cwd, p)} (1 replacement)`,
+                        summary: `edited ${safeRelative(ctx.cwd, p)}`,
+                        permission: 'ask',
+                    };
+                }
+                catch (e) {
+                    return err(`cannot edit "${args.path}": ${e.message}`);
+                }
+            },
+        },
+        {
+            definition: {
+                name: 'list_directory',
+                description: 'List files and directories in a path. Returns entries with type and size. Respects ignore rules.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Directory path, relative to project root (default ".")' },
+                        depth: { type: 'number', description: 'Max recursion depth (default 1)' },
+                    },
+                    required: [],
+                },
+            },
+            async execute(args, ctx) {
+                const p = resolve(ctx.cwd, String(args.path || '.'));
+                const depth = Math.min(3, Math.max(0, Number(args.depth) || 1));
+                const IGNORE = new Set(['.git', 'node_modules', 'vendor', 'dist', 'build', '.cache', '.env', '.next', 'target']);
+                const lines = [];
+                const walk = (dir, level) => {
+                    let entries;
+                    try {
+                        entries = fs.readdirSync(dir, { withFileTypes: true });
+                    }
+                    catch {
+                        return;
+                    }
+                    entries.sort((a, b) => {
+                        if (a.isDirectory() !== b.isDirectory())
+                            return a.isDirectory() ? -1 : 1;
+                        return a.name.localeCompare(b.name);
+                    });
+                    for (const e of entries) {
+                        if (e.name.startsWith('.') && e.name !== '.env.example')
+                            continue;
+                        if (IGNORE.has(e.name))
+                            continue;
+                        const rel = safeRelative(ctx.cwd, path.join(dir, e.name));
+                        if (e.isDirectory()) {
+                            lines.push(`${'  '.repeat(level)}📁 ${rel}/`);
+                            if (level < depth)
+                                walk(path.join(dir, e.name), level + 1);
+                        }
+                        else {
+                            let size = '';
+                            try {
+                                size = fmtSize(fs.statSync(path.join(dir, e.name)).size);
+                            }
+                            catch {
+                                /* ignore */
+                            }
+                            lines.push(`${'  '.repeat(level)}📄 ${rel} (${size})`);
+                        }
+                        if (lines.length > 500)
+                            return;
+                    }
+                };
+                walk(p, 0);
+                if (lines.length === 0) {
+                    return { output: `(empty or no visible entries in ${safeRelative(ctx.cwd, p)})`, summary: 'list directory' };
+                }
+                return {
+                    output: truncateOutput(`listing ${safeRelative(ctx.cwd, p)}:\n${lines.join('\n')}`, ctx.maxOutput || maxDefaultOutput),
+                    summary: `listed ${safeRelative(ctx.cwd, p)}`,
+                };
+            },
+        },
+        {
+            definition: {
+                name: 'delete_file',
+                description: 'Delete a file (or empty directory). Requires explicit permission. Never deletes outside the project or the project root itself.',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        path: { type: 'string', description: 'Path to the file/directory to delete, relative to project root' },
+                    },
+                    required: ['path'],
+                },
+            },
+            async execute(args, ctx) {
+                const p = resolve(ctx.cwd, String(args.path || ''));
+                const rel = safeRelative(ctx.cwd, p);
+                if (rel === '.' || rel === '')
+                    return err('refusing to delete project root');
+                try {
+                    const stat = await fsp.stat(p);
+                    if (stat.isDirectory()) {
+                        await fsp.rmdir(p);
+                    }
+                    else {
+                        await fsp.unlink(p);
+                    }
+                    return {
+                        output: `deleted ${rel}`,
+                        summary: `deleted ${rel}`,
+                        permission: 'dangerous',
+                    };
+                }
+                catch (e) {
+                    return err(`cannot delete "${args.path}": ${e.message}`);
+                }
+            },
+        },
+    ];
+}
+function fmtSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}K`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)}M`;
+}

package/dist/tools/git.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createGitTool = createGitTool;
+/**
+ * Git tool — read-only git operations by default.
+ * `commit` and `push` require explicit user permission (push is blocked by policy).
+ */
+const shell_1 = require("./shell");
+const ALLOWED_SUBCOMMANDS = new Set([
+    'status', 'diff', 'log', 'branch', 'show', 'remote', 'rev-parse',
+    'config', 'ls-files', 'check-ignore', 'shortlog', 'blame', 'grep',
+    'stash', 'tag', 'fetch', 'pull',
+]);
+const PERMISSION_NEEDED = new Set(['commit', 'add', 'reset', 'checkout', 'clean', 'rebase', 'merge', 'cherry-pick', 'switch', 'restore', 'push', 'init', 'mv', 'rm']);
+function classifyGit(args) {
+    const sub = args[0] || '';
+    if (sub === 'push')
+        return 'blocked';
+    if (ALLOWED_SUBCOMMANDS.has(sub))
+        return 'safe';
+    if (PERMISSION_NEEDED.has(sub))
+        return 'ask';
+    return 'ask';
+}
+function createGitTool() {
+    return {
+        definition: {
+            name: 'git',
+            description: 'Run a git operation: status, diff, log, branch, show, remote, rev-parse, config, ls-files, add, commit, etc. Read-only commands are safe; state-changing commands (add/commit/checkout/reset/etc.) require permission. push is blocked.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    args: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Git arguments, e.g. ["status"], ["diff"], ["log","--oneline","-5"], ["add","."]',
+                    },
+                },
+                required: ['args'],
+            },
+        },
+        async execute(args, ctx) {
+            const gitArgs = Array.isArray(args.args) ? args.args.map(String) : [String(args.args || '')];
+            if (gitArgs.length === 0 || gitArgs[0] === '') {
+                return { output: 'ERROR: git requires args, e.g. ["status"]' };
+            }
+            const cmd = ['git', ...gitArgs].join(' ');
+            ctx.onActivity?.('git', `$ ${cmd}`);
+            const level = classifyGit(gitArgs);
+            if (level === 'blocked') {
+                return { output: `BLOCKED: "git push" is not allowed — VECTOR never pushes without explicit user approval outside this policy.` };
+            }
+            const allowed = await ctx.permissions.decide({ tool: 'git', summary: cmd, level });
+            if (!allowed) {
+                return { output: `Permission denied by user: ${cmd}` };
+            }
+            const res = await (0, shell_1.runShell)(cmd, ctx.cwd, { timeoutMs: 60_000 });
+            const out = [res.stdout, res.stderr].filter(Boolean).join('\n[stderr]\n');
+            return {
+                output: `${res.exitCode === 0 ? 'exit 0' : `exit ${res.exitCode ?? '?'}`}${out ? '\n' + out : ''}`,
+                summary: `git ${gitArgs.join(' ')}`,
+                data: { exitCode: res.exitCode },
+            };
+        },
+    };
+}

package/dist/tools/registry.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolRegistry = void 0;
+class ToolRegistry {
+    tools = new Map();
+    register(tool) {
+        this.tools.set(tool.definition.name, tool);
+    }
+    registerMany(tools) {
+        for (const t of tools)
+            this.register(t);
+    }
+    get(name) {
+        return this.tools.get(name);
+    }
+    has(name) {
+        return this.tools.has(name);
+    }
+    definitions() {
+        return [...this.tools.values()].map((t) => t.definition);
+    }
+    async execute(name, rawArgs, ctx) {
+        const tool = this.tools.get(name);
+        if (!tool) {
+            return { output: `ERROR: unknown tool "${name}"` };
+        }
+        let args;
+        try {
+            args = rawArgs ? JSON.parse(rawArgs) : {};
+        }
+        catch {
+            return { output: `ERROR: invalid JSON arguments for tool "${name}": ${rawArgs.slice(0, 200)}` };
+        }
+        ctx.onActivity?.(name, `executing ${name}`);
+        const result = await tool.execute(args, ctx);
+        return result;
+    }
+}
+exports.ToolRegistry = ToolRegistry;

package/dist/tools/search.js

@@ -0,0 +1,184 @@
+"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.createSearchTools = createSearchTools;
+/**
+ * Search tools — search files by name or content.
+ * Implementation uses ripgrep (rg) when available, else a pure-Node
+ * recursive walk with string matching (slow but dependency-free).
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_child_process_1 = require("node:child_process");
+const node_util_1 = require("node:util");
+const execFileP = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const IGNORE = new Set(['.git', 'node_modules', 'vendor', 'dist', 'build', '.cache', '.env', '.next', 'target', 'coverage']);
+function hasRg() {
+    try {
+        execFileSyncCheck('rg', ['--version']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function execFileSyncCheck(cmd, args) {
+    (0, node_child_process_1.spawnSync)(cmd, args, { stdio: 'ignore' });
+}
+function walkFiles(dir, out, max) {
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (out.length >= max)
+            return;
+        if (IGNORE.has(e.name))
+            continue;
+        if (e.name.startsWith('.'))
+            continue;
+        const full = path.join(dir, e.name);
+        if (e.isDirectory())
+            walkFiles(full, out, max);
+        else
+            out.push(full);
+    }
+}
+function createSearchTools() {
+    const rg = hasRg();
+    return [
+        {
+            definition: {
+                name: 'search_files',
+                description: 'Search for files by filename pattern or by text content. Returns up to 30 matches with file paths (and line numbers for text search).',
+                parameters: {
+                    type: 'object',
+                    properties: {
+                        query: { type: 'string', description: 'Text to search for in file contents' },
+                        filename: { type: 'string', description: 'Filename pattern (substring or glob-like), e.g. "login", "*.ts"' },
+                        path: { type: 'string', description: 'Directory to search in, relative to project root (default ".")' },
+                        max_results: { type: 'number', description: 'Max results (default 30, max 100)' },
+                    },
+                    required: [],
+                },
+            },
+            async execute(args, ctx) {
+                const base = path.resolve(ctx.cwd, String(args.path || '.'));
+                const max = Math.min(100, Math.max(1, Number(args.max_results) || 30));
+                const query = String(args.query || '');
+                const filename = String(args.filename || '');
+                if (!query && !filename)
+                    return { output: 'ERROR: provide either "query" (text) or "filename" (pattern)' };
+                if (rg) {
+                    return runRg(base, query, filename, max);
+                }
+                return fallbackSearch(base, query, filename, max, ctx.cwd);
+            },
+        },
+    ];
+}
+async function runRg(base, query, filename, max) {
+    try {
+        const args = ['--no-ignore', '-m', '1', '--max-count', '3'];
+        for (const ig of IGNORE)
+            args.push('-g', `!${ig}/**`);
+        if (filename) {
+            args.push('-g', filename.includes('*') ? filename : `*${filename}*`);
+        }
+        if (query) {
+            args.push('--', query, base);
+        }
+        else {
+            args.push('-l', '--', '', base);
+        }
+        const { stdout } = await execFileP('rg', args, { maxBuffer: 10 * 1024 * 1024 });
+        const lines = stdout.split('\n').filter(Boolean).slice(0, max);
+        if (lines.length === 0) {
+            return { output: 'no matches found', summary: 'search: no matches' };
+        }
+        return {
+            output: `found ${lines.length} match(es):\n${lines.join('\n')}`,
+            summary: `search found ${lines.length} match(es)`,
+        };
+    }
+    catch (e) {
+        const code = e.code;
+        if (code === 1)
+            return { output: 'no matches found', summary: 'search: no matches' };
+        return { output: `search error: ${e.message}`, summary: 'search error' };
+    }
+}
+function fallbackSearch(base, query, filename, max, cwd) {
+    const files = [];
+    walkFiles(base, files, 2000);
+    const results = [];
+    for (const f of files) {
+        if (results.length >= max)
+            break;
+        const rel = path.relative(cwd, f);
+        const name = path.basename(f);
+        if (filename) {
+            if (filename.includes('*')) {
+                const re = new RegExp('^' + filename.replace(/[.+?^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*') + '$');
+                if (!re.test(name))
+                    continue;
+            }
+            else if (!name.includes(filename))
+                continue;
+            results.push(rel);
+            continue;
+        }
+        if (query) {
+            try {
+                const content = fs.readFileSync(f, 'utf8');
+                if (content.includes(query)) {
+                    results.push(rel);
+                }
+            }
+            catch {
+                /* binary/unreadable */
+            }
+        }
+    }
+    if (results.length === 0)
+        return { output: 'no matches found', summary: 'search: no matches' };
+    return {
+        output: `found ${results.length} match(es):\n${results.join('\n')}`,
+        summary: `search found ${results.length} match(es)`,
+    };
+}