cli-surf 0.11.0

package/cliTools.js

@@ -0,0 +1,490 @@
+/**
+ * Локальные инструменты coding-агента (surf code): read, glob, grep,
+ * edit, write, bash. Исполняются на машине пользователя в пределах cwd;
+ * сервер их только описывает модели и считает токены в общий лимит.
+ * Без внешних зависимостей.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import { exec } from 'node:child_process';
+import readline from 'node:readline/promises';
+import { stdin as input, stdout as output } from 'node:process';
+import { paint } from './cliUi.js';
+import { discoverSkills, loadSkill, builtinSkillsDir, userSkillsDir, projectSkillsDir } from './cliSkills.js';
+export const CODE_TOOLS = [
+    {
+        type: 'function',
+        function: {
+            name: 'read',
+            description: 'Read a text file (returns numbered lines) or list a directory. Paths are relative to the working directory.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'File or directory path, relative to cwd' },
+                    offset: { type: 'number', description: 'First line (1-based), for files' },
+                    limit: { type: 'number', description: 'Max lines, for files' },
+                },
+                required: ['path'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'glob',
+            description: 'Find files by glob pattern (*, ?, **). Searches recursively from cwd, skips node_modules and .git.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: { type: 'string', description: 'Glob like src/**/*.ts' },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'grep',
+            description: 'Search file contents by regex. Returns path:line matches. Skips node_modules, .git and binary files.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    pattern: { type: 'string', description: 'JavaScript regex' },
+                    include: { type: 'string', description: 'Optional glob filter, e.g. *.ts' },
+                    dir: { type: 'string', description: 'Subdirectory to search, default cwd' },
+                },
+                required: ['pattern'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'edit',
+            description: 'Exact string replacement in a file. The file MUST be read first. oldString must match exactly once (or use replaceAll). Prefer small replacements.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'File path, relative to cwd' },
+                    oldString: { type: 'string', description: 'Exact text to replace' },
+                    newString: { type: 'string', description: 'Replacement text' },
+                    replaceAll: { type: 'boolean', description: 'Replace every occurrence' },
+                },
+                required: ['path', 'oldString', 'newString'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'write',
+            description: 'Create a new file or overwrite an existing one. Parent directories are created. The local permission mode determines whether confirmation is needed.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'File path, relative to cwd' },
+                    content: { type: 'string', description: 'Full file content' },
+                },
+                required: ['path', 'content'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'bash',
+            description: 'Run a shell command (tests, builds, git status, etc.). The local permission mode determines whether confirmation is needed. Output is truncated.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    command: { type: 'string', description: 'Shell command' },
+                    timeout: { type: 'number', description: 'Timeout in ms, default 60000, max 300000' },
+                    workdir: { type: 'string', description: 'Subdirectory to run in, default cwd' },
+                },
+                required: ['command'],
+            },
+        },
+    },
+    {
+        type: 'function',
+        function: {
+            name: 'skill',
+            description: 'Agent Skills: list installed skills or read a skill\'s SKILL.md instructions. When a task matches an installed skill, read it first and follow it exactly, including running its bundled scripts via bash.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    action: { type: 'string', description: "'list' shows the catalog, 'read' returns full instructions" },
+                    name: { type: 'string', description: 'Skill name for action=read' },
+                },
+                required: ['action'],
+            },
+        },
+    },
+];
+export function createToolContext(cwd, yesAll, permissionMode = 'important') {
+    return { cwd: path.resolve(cwd), yesAll, permissionMode, readFiles: new Set() };
+}
+const RESULT_CAP = 12000;
+function truncateResult(text) {
+    if (text.length <= RESULT_CAP)
+        return text;
+    return `${text.slice(0, RESULT_CAP)}\n…(обрезано, всего ${text.length} символов)`;
+}
+function resolveInCwd(ctx, p) {
+    if (typeof p !== 'string' || !p)
+        throw new Error('нужен path');
+    const abs = path.resolve(ctx.cwd, p);
+    const root = path.resolve(ctx.cwd);
+    if (abs === root || abs.startsWith(root + path.sep))
+        return abs;
+    // Доверенные корни скиллов (свои скрипты/ресурсы): builtin, user, project.
+    const builtin = builtinSkillsDir();
+    const roots = [builtin, userSkillsDir(), projectSkillsDir(ctx.cwd)]
+        .filter((d) => !!d)
+        .map(d => path.resolve(d));
+    if (roots.some(r => abs === r || abs.startsWith(r + path.sep)))
+        return abs;
+    throw new Error(`только внутри рабочей папки ${ctx.cwd}`);
+}
+function toolRead(ctx, args) {
+    const abs = resolveInCwd(ctx, String(args.path ?? ''));
+    const stat = fs.statSync(abs);
+    if (stat.isDirectory()) {
+        const entries = fs.readdirSync(abs, { withFileTypes: true })
+            .map(e => (e.isDirectory() ? `${e.name}/` : e.name)).sort();
+        ctx.readFiles.add(abs);
+        return [`каталог ${path.relative(ctx.cwd, abs) || '.'}:`, ...entries].join('\n');
+    }
+    if (stat.size > 1024 * 1024)
+        throw new Error('файл больше 1 МБ');
+    const content = fs.readFileSync(abs, 'utf8');
+    if (content.includes('\0'))
+        throw new Error('бинарный файл, пропущен');
+    ctx.readFiles.add(abs);
+    const lines = content.split('\n');
+    const offset = Math.max(1, Number(args.offset) || 1);
+    const limit = Math.min(500, Math.max(1, Number(args.limit) || 500));
+    const slice = lines.slice(offset - 1, offset - 1 + limit);
+    const numbered = slice.map((l, i) => `${offset + i}| ${l.length > 500 ? l.slice(0, 500) + '…' : l}`);
+    const tail = offset - 1 + limit < lines.length ? `\n…(ещё ${lines.length - (offset - 1 + limit)} строк)` : '';
+    return `${path.relative(ctx.cwd, abs)} (${lines.length} строк):\n${numbered.join('\n')}${tail}`;
+}
+function globToRegExp(pattern) {
+    let re = '';
+    for (let i = 0; i < pattern.length; i += 1) {
+        const c = pattern[i];
+        if (c === '*') {
+            if (pattern[i + 1] === '*') {
+                re += '.*';
+                i += 1;
+                if (pattern[i + 1] === '/')
+                    i += 1;
+            }
+            else {
+                re += '[^/]*';
+            }
+        }
+        else if (c === '?') {
+            re += '[^/]';
+        }
+        else {
+            re += c.replace(/[.+^${}()|[\]\\]/g, '\\$&');
+        }
+    }
+    return new RegExp(`^${re}$`);
+}
+const WALK_SKIP = new Set(['node_modules', '.git']);
+function walkFiles(root, out) {
+    let entries;
+    try {
+        entries = fs.readdirSync(root, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const e of entries) {
+        if (WALK_SKIP.has(e.name))
+            continue;
+        const full = path.join(root, e.name);
+        if (e.isDirectory())
+            walkFiles(full, out);
+        else if (e.isFile())
+            out.push(full);
+    }
+}
+function toolGlob(ctx, args) {
+    const pattern = String(args.pattern ?? '');
+    if (!pattern)
+        throw new Error('нужен pattern');
+    const re = globToRegExp(pattern);
+    const all = [];
+    walkFiles(ctx.cwd, all);
+    const matched = all
+        .map(f => path.relative(ctx.cwd, f).split(path.sep).join('/'))
+        .filter(rel => re.test(rel) || re.test(`./${rel}`) || re.test(rel.split('/').pop() ?? ''))
+        .slice(0, 100);
+    if (!matched.length)
+        return 'ничего не найдено';
+    const tail = matched.length === 100 ? '\n…(первые 100)' : '';
+    return `${matched.join('\n')}${tail}`;
+}
+function toolGrep(ctx, args) {
+    const pattern = String(args.pattern ?? '');
+    if (!pattern)
+        throw new Error('нужен pattern');
+    let re;
+    try {
+        re = new RegExp(pattern, 'gm');
+    }
+    catch {
+        throw new Error('невалидный regex');
+    }
+    const include = typeof args.include === 'string' && args.include ? globToRegExp(args.include) : null;
+    const dir = typeof args.dir === 'string' && args.dir ? resolveInCwd(ctx, args.dir) : ctx.cwd;
+    const all = [];
+    walkFiles(dir, all);
+    const hits = [];
+    for (const f of all) {
+        if (hits.length >= 60)
+            break;
+        const rel = path.relative(ctx.cwd, f).split(path.sep).join('/');
+        if (include && !include.test(rel) && !include.test(rel.split('/').pop() ?? ''))
+            continue;
+        let stat;
+        try {
+            stat = fs.statSync(f);
+        }
+        catch {
+            continue;
+        }
+        if (stat.size > 1024 * 1024)
+            continue;
+        let content;
+        try {
+            content = fs.readFileSync(f, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        if (content.includes('\0'))
+            continue;
+        const lines = content.split('\n');
+        lines.forEach((line, i) => {
+            if (hits.length >= 60)
+                return;
+            re.lastIndex = 0;
+            if (re.test(line))
+                hits.push(`${rel}:${i + 1}: ${line.trim().slice(0, 200)}`);
+        });
+    }
+    if (!hits.length)
+        return 'ничего не найдено';
+    return hits.join('\n');
+}
+function toolSkill(ctx, args) {
+    const action = args.action;
+    if (action === 'list') {
+        const { skills } = discoverSkills(ctx.cwd);
+        if (skills.length === 0)
+            return 'навыков не установлено';
+        return skills.map(s => `- ${s.name}: ${s.description} [${s.source}]`).join('\n');
+    }
+    if (action === 'read') {
+        const name = typeof args.name === 'string' ? args.name : '';
+        const skill = loadSkill(ctx.cwd, name);
+        if (!skill)
+            return `ошибка: навык «${name}» не найден`;
+        const files = skill.files.length > 0
+            ? `\n\nПриложенные файлы (пути от корня скилла ${skill.meta.dir}, запускай скрипты через bash):\n${skill.files.map(f => `- ${f}`).join('\n')}`
+            : '';
+        return `# ${skill.meta.name}${skill.meta.version ? ` v${skill.meta.version}` : ''}\n\n${skill.instructions}${files}`;
+    }
+    return 'ошибка: action должен быть list или read';
+}
+function diffPreview(fileLines, at, oldBlock, newBlock) {
+    const show = (prefix, lines, color) => lines.slice(0, 12).map(l => paint(`${prefix} ${l.length > 300 ? l.slice(0, 300) + '…' : l}`, color)).join('\n');
+    return `${show('-', oldBlock, 'red')}\n${show('+', newBlock, 'green')}\n${paint(`(контекст: строка ${at + 1})`, 'gray')}`;
+}
+/**
+ * В режиме «только важное» обычные правки и проверочные команды не прерывают
+ * работу. Спрашиваем перед необратимыми/внешними действиями и установкой ПО.
+ * Это намеренно консервативный список: при сомнении агент всё ещё ограничен cwd
+ * и системными правилами, а «всегда» остаётся для полного контроля.
+ */
+function isImportantShellCommand(command) {
+    const value = command.toLowerCase();
+    return /(?:^|[;&|\n]\s*)(?:rm|rmdir|del|erase|remove-item|clear-content|format|rd|git\s+(?:reset|clean|push|commit|rebase)|npm\s+(?:publish|install|uninstall|update)|pnpm\s+(?:publish|add|remove|install|update)|yarn\s+(?:publish|add|remove|install|upgrade)|pip(?:3)?\s+install|cargo\s+(?:install|publish)|(?:docker|kubectl|terraform)\s+(?:push|apply|destroy)|(?:vercel|netlify|flyctl)\s+(?:deploy|publish)|curl\b[^\n|]*\|\s*(?:sh|bash|zsh)|wget\b[^\n|]*\|\s*(?:sh|bash|zsh))\b/i.test(value)
+        || /(?:^|[;&|\n])\s*(?:move-item|mv|rename-item|ren)\b/i.test(value)
+        || /(?:^|[^>&])>{1,2}(?!&)/.test(value);
+}
+function requiresApproval(ctx, kind, bashCommand) {
+    if (ctx.yesAll || ctx.permissionMode === 'never')
+        return false;
+    if (ctx.permissionMode === 'always')
+        return true;
+    return kind === 'bash' && !!bashCommand && isImportantShellCommand(bashCommand);
+}
+async function askApproval(question, ctx) {
+    if (ctx.yesAll)
+        return 'yes';
+    if (!process.stdin.isTTY)
+        return 'no';
+    const rl = readline.createInterface({ input, output });
+    try {
+        const answer = (await rl.question(`${paint('❓', 'accent')} ${question} ${paint('[y/n]', 'gray')} `)).trim().toLowerCase();
+        if (['y', 'yes', 'д', 'да'].includes(answer))
+            return 'yes';
+        return 'no';
+    }
+    catch {
+        return 'no';
+    }
+    finally {
+        rl.close();
+    }
+}
+function toolEdit(ctx, args) {
+    const abs = resolveInCwd(ctx, String(args.path ?? ''));
+    const oldString = typeof args.oldString === 'string' ? args.oldString : null;
+    const newString = typeof args.newString === 'string' ? args.newString : null;
+    if (oldString === null || oldString === '' || newString === null) {
+        return Promise.resolve('ошибка: нужны непустые oldString и newString');
+    }
+    let content;
+    try {
+        content = fs.readFileSync(abs, 'utf8');
+    }
+    catch {
+        return Promise.resolve(`ошибка: файл не читается: ${args.path}`);
+    }
+    if (!ctx.readFiles.has(abs))
+        return Promise.resolve('ошибка: сначала прочитайте файл инструментом read');
+    if (oldString === newString)
+        return Promise.resolve('ошибка: oldString и newString одинаковые');
+    const replaceAll = args.replaceAll === true;
+    const occurrences = content.split(oldString).length - 1;
+    if (occurrences === 0)
+        return Promise.resolve('ошибка: oldString не найден');
+    if (occurrences > 1 && !replaceAll) {
+        return Promise.resolve(`ошибка: найдено совпадений: ${occurrences}, уточните контекст или используйте replaceAll`);
+    }
+    const at = content.indexOf(oldString);
+    const before = content.slice(0, at).split('\n');
+    const startLine = Math.max(0, before.length - 4);
+    const oldBlock = oldString.split('\n');
+    const newBlock = newString.split('\n');
+    const preview = diffPreview(content.split('\n'), startLine, oldBlock, newBlock);
+    const apply = () => {
+        const next = replaceAll ? content.split(oldString).join(newString) : content.replace(oldString, newString);
+        fs.writeFileSync(abs, next);
+        ctx.readFiles.add(abs);
+        return `готово: заменено ${replaceAll ? occurrences : 1} в ${path.relative(ctx.cwd, abs)}`;
+    };
+    if (!requiresApproval(ctx, 'edit'))
+        return Promise.resolve(apply());
+    if (!process.stdin.isTTY)
+        return Promise.resolve('отклонено: неинтерактивный режим без --yes');
+    return (async () => {
+        console.log(`${paint('edit', 'white')} ${paint(String(args.path), 'accent')}\n${preview}`);
+        const decision = await askApproval('Применить правку?', ctx);
+        if (decision === 'no')
+            return 'отклонено пользователем';
+        return apply();
+    })();
+}
+function toolWrite(ctx, args) {
+    const abs = resolveInCwd(ctx, String(args.path ?? ''));
+    const content = typeof args.content === 'string' ? args.content : null;
+    if (content === null)
+        return Promise.resolve('ошибка: нужен content');
+    const exists = fs.existsSync(abs);
+    const head = content.split('\n').slice(0, 20).join('\n').slice(0, 2000);
+    const apply = () => {
+        fs.mkdirSync(path.dirname(abs), { recursive: true });
+        fs.writeFileSync(abs, content);
+        ctx.readFiles.add(abs);
+        return `готово: ${exists ? 'перезаписан' : 'создан'} ${path.relative(ctx.cwd, abs)} (${content.length} символов)`;
+    };
+    if (!requiresApproval(ctx, 'write'))
+        return Promise.resolve(apply());
+    if (!process.stdin.isTTY)
+        return Promise.resolve('отклонено: неинтерактивный режим без --yes');
+    return (async () => {
+        console.log(`${paint(exists ? 'overwrite' : 'write', 'white')} ${paint(String(args.path), 'accent')}\n${paint(head, 'gray')}`);
+        const decision = await askApproval(exists ? 'Перезаписать файл?' : 'Создать файл?', ctx);
+        if (decision === 'no')
+            return 'отклонено пользователем';
+        return apply();
+    })();
+}
+function toolBash(ctx, args) {
+    const command = typeof args.command === 'string' ? args.command : '';
+    if (!command)
+        return Promise.resolve('ошибка: нужен command');
+    const timeout = Math.min(300000, Math.max(1000, Number(args.timeout) || 60000));
+    let workdir = ctx.cwd;
+    if (typeof args.workdir === 'string' && args.workdir) {
+        try {
+            workdir = resolveInCwd(ctx, args.workdir);
+        }
+        catch (err) {
+            return Promise.resolve(`ошибка: ${err.message}`);
+        }
+    }
+    const run = () => new Promise(resolve => {
+        exec(command, { cwd: workdir, timeout, maxBuffer: 1024 * 1024, windowsHide: true }, (err, stdout, stderr) => {
+            const out = `${stdout || ''}${stderr ? `\n[stderr]\n${stderr}` : ''}`.trim().slice(0, 30000);
+            if (err) {
+                const code = err.code;
+                resolve(`exit ${typeof code === 'number' ? code : 'ошибка'}: ${err.message.split('\n')[0]}\n${out}`);
+            }
+            else {
+                resolve(out || '(пустой вывод)');
+            }
+        });
+    });
+    if (!requiresApproval(ctx, 'bash', command))
+        return run();
+    if (!process.stdin.isTTY)
+        return Promise.resolve('отклонено: неинтерактивный режим без --yes');
+    return (async () => {
+        const decision = await askApproval(`Выполнить важное действие: ${command}`, ctx);
+        if (decision === 'no')
+            return 'отклонено пользователем';
+        const spinner = paint('…выполняю', 'gray');
+        process.stderr.write(`${spinner}\r`);
+        const result = await run();
+        process.stderr.write('\r\x1b[K');
+        return result;
+    })();
+}
+/** Выполнить вызов инструмента модели, вернуть текст результата. */
+export async function executeAgentTool(ctx, call) {
+    let args;
+    try {
+        const parsed = JSON.parse(call.argsJson || '{}');
+        args = parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return 'ошибка: arguments не JSON';
+    }
+    try {
+        switch (call.name) {
+            case 'read': return truncateResult(toolRead(ctx, args));
+            case 'glob': return truncateResult(toolGlob(ctx, args));
+            case 'grep': return truncateResult(toolGrep(ctx, args));
+            case 'edit': return truncateResult(await toolEdit(ctx, args));
+            case 'write': return truncateResult(await toolWrite(ctx, args));
+            case 'bash': return truncateResult(await toolBash(ctx, args));
+            case 'skill': return truncateResult(toolSkill(ctx, args));
+            default: return `ошибка: неизвестный инструмент ${call.name}`;
+        }
+    }
+    catch (err) {
+        return `ошибка: ${err.message}`;
+    }
+}
+//# sourceMappingURL=cliTools.js.map