@vesk/agentic 0.2.11

package/dist/slash.js

@@ -0,0 +1,77 @@
+/**
+ * Slash command parser for devtool agentic tab.
+ * Pure string ops, no regex.
+ */
+export const SLASH_COMMANDS = [
+    { name: '/provider', description: 'switch provider', usage: '/provider <openai|anthropic|google|ollama>' },
+    { name: '/model', description: 'switch or list models', usage: '/model [name]  (no arg = list)' },
+    { name: '/models', description: 'list models for current provider', usage: '/models' },
+    { name: '/tools', description: 'list available tools', usage: '/tools' },
+    { name: '/tool', description: 'show tool details', usage: '/tool <name>' },
+    { name: '/commands', description: 'list slash commands', usage: '/commands' },
+    { name: '/mode', description: 'switch mode', usage: '/mode <explore|debug|agent>' },
+    { name: '/clear', description: 'clear chat', usage: '/clear' },
+    { name: '/help', description: 'show help', usage: '/help' },
+    { name: '/history', description: 'show checkpoints', usage: '/history' },
+    { name: '/rollback', description: 'rollback to checkpoint', usage: '/rollback <id>' },
+    { name: '/checkpoint', description: 'create checkpoint', usage: '/checkpoint [message]' },
+    { name: '/config', description: 'show agentic config', usage: '/config' },
+];
+export function parseSlash(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith('/'))
+        return null;
+    const spaceIdx = trimmed.indexOf(' ');
+    let cmdStr;
+    let rest;
+    if (spaceIdx === -1) {
+        cmdStr = trimmed.slice(1);
+        rest = '';
+    }
+    else {
+        cmdStr = trimmed.slice(1, spaceIdx);
+        rest = trimmed.slice(spaceIdx + 1).trim();
+    }
+    const cmd = cmdStr.toLowerCase();
+    const known = SLASH_COMMANDS.map(c => c.name.slice(1));
+    if (!known.includes(cmd))
+        return { cmd: cmd, args: [], raw: trimmed };
+    const args = [];
+    if (rest) {
+        let cur = '';
+        let inQuote = false;
+        let quoteChar = '';
+        for (let i = 0; i < rest.length; i++) {
+            const ch = rest[i];
+            if (!inQuote && (ch === '"' || ch === "'")) {
+                inQuote = true;
+                quoteChar = ch;
+                continue;
+            }
+            if (inQuote && ch === quoteChar) {
+                inQuote = false;
+                continue;
+            }
+            if (!inQuote && ch === ' ') {
+                if (cur) {
+                    args.push(cur);
+                    cur = '';
+                }
+                continue;
+            }
+            cur += ch;
+        }
+        if (cur)
+            args.push(cur);
+    }
+    return { cmd, args, raw: trimmed };
+}
+export function helpText() {
+    let out = 'Available slash commands:\n';
+    for (const c of SLASH_COMMANDS)
+        out += `${c.name.padEnd(14)} ${c.description}  (${c.usage})\n`;
+    return out;
+}
+export function isSlash(input) {
+    return input.trim().startsWith('/');
+}

package/dist/tools/browser.d.ts

@@ -0,0 +1,3 @@
+import type { Tool } from '../loop.js';
+export declare function createBrowserTools(projectDir?: string): Tool[];
+//# sourceMappingURL=browser.d.ts.map

package/dist/tools/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../src/tools/browser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAkDvC,wBAAgB,kBAAkB,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,IAAI,EAAE,CA2N9D"}

package/dist/tools/browser.js

@@ -0,0 +1,289 @@
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { spawn } from 'node:child_process';
+// Global bridge injected by dev server when available (set via globalThis.__vesk_browser_bridge)
+function getBridge() {
+    const g = globalThis;
+    return g.__vesk_browser_bridge || null;
+}
+async function ensurePuppeteerInstalled(projectDir) {
+    // Check if already installed
+    const puppeteerPath = resolve(projectDir, 'node_modules', 'puppeteer');
+    const corePath = resolve(projectDir, 'node_modules', 'puppeteer-core');
+    if (existsSync(puppeteerPath) || existsSync(corePath)) {
+        return { ok: true, message: 'puppeteer already installed' };
+    }
+    // Try to install puppeteer (includes chromium) as devDep
+    return new Promise((res) => {
+        const child = spawn('npm', ['install', '-D', 'puppeteer'], {
+            cwd: projectDir,
+            stdio: 'pipe',
+            shell: false,
+        });
+        let out = '';
+        let err = '';
+        child.stdout?.on('data', (d) => (out += String(d)));
+        child.stderr?.on('data', (d) => (err += String(d)));
+        const timer = setTimeout(() => {
+            try {
+                child.kill();
+            }
+            catch { }
+            res({ ok: false, message: 'install timed out after 120s' });
+        }, 120_000);
+        child.on('close', (code) => {
+            clearTimeout(timer);
+            if (code === 0)
+                res({ ok: true, message: 'puppeteer installed successfully\n' + out.slice(-500) });
+            else
+                res({ ok: false, message: `npm install failed code=${code}\n${err.slice(-1000)}` });
+        });
+        child.on('error', (e) => {
+            clearTimeout(timer);
+            res({ ok: false, message: `spawn failed: ${e.message}` });
+        });
+    });
+}
+export function createBrowserTools(projectDir) {
+    const dir = projectDir || process.cwd();
+    return [
+        {
+            name: 'browser.open',
+            description: 'Open a URL in the users browser first via devtools (if connected), otherwise via puppeteer (auto-installs if needed). Returns rendered text. The agent should prefer this for JS-heavy pages, inspection, and any browser task.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'URL to open (http/https)' },
+                    waitMs: { type: 'number', description: 'Wait after load (ms, default 1500)' },
+                },
+                required: ['url'],
+            },
+            async execute(args) {
+                const url = String(args.url || '').trim();
+                const waitMs = Math.min(15000, Math.max(0, Number(args.waitMs) || 1500));
+                if (!url)
+                    return JSON.stringify({ error: 'missing url' });
+                if (!url.startsWith('http://') && !url.startsWith('https://'))
+                    return JSON.stringify({ error: 'only http/https allowed' });
+                // 1) Try devtools bridge first (users browser)
+                const bridge = getBridge();
+                if (bridge && bridge.hasClients()) {
+                    try {
+                        const result = await bridge.request({ action: 'open', url, waitMs }, 15000);
+                        if (result && typeof result.text === 'string')
+                            return String(result.text).slice(0, 12000);
+                        if (result && typeof result.error === 'string') {
+                            // fall through to puppeteer
+                        }
+                        else if (result)
+                            return JSON.stringify(result).slice(0, 12000);
+                    }
+                    catch (e) {
+                        // bridge failed, fall through
+                    }
+                }
+                // 2) Try puppeteer-core / puppeteer if available
+                try {
+                    // @ts-ignore - optional dep, installed on demand
+                    // @ts-ignore
+                    const puppeteer = await import('puppeteer').catch(() => null);
+                    // @ts-ignore - optional dep
+                    const core = !puppeteer ? await import('puppeteer-core').catch(() => null) : null;
+                    const impl = puppeteer || core;
+                    if (impl && typeof impl.launch === 'function') {
+                        const executablePath = process.env.CHROMIUM_PATH || process.env.PUPPETEER_EXECUTABLE_PATH || undefined;
+                        const launchOpts = { headless: true, args: ['--no-sandbox', '--disable-setuid-sandbox'] };
+                        if (executablePath)
+                            launchOpts.executablePath = executablePath;
+                        const browser = await impl.launch(launchOpts);
+                        const page = await browser.newPage();
+                        await page.goto(url, { waitUntil: 'networkidle2', timeout: 20000 });
+                        if (waitMs)
+                            await new Promise(r => setTimeout(r, waitMs));
+                        const text = await page.evaluate(() => document.body.innerText.slice(0, 12000));
+                        await page.close();
+                        await browser.close();
+                        return text;
+                    }
+                }
+                catch (e) {
+                    // puppeteer launch failed, will try install
+                }
+                // 3) Auto-install puppeteer if not present and we have a projectDir
+                if (dir) {
+                    const install = await ensurePuppeteerInstalled(dir);
+                    if (install.ok) {
+                        try {
+                            // @ts-ignore
+                            const puppeteer = await import('puppeteer');
+                            const browser = await puppeteer.launch({ headless: true, args: ['--no-sandbox'] });
+                            const page = await browser.newPage();
+                            await page.goto(url, { waitUntil: 'networkidle2', timeout: 20000 });
+                            if (waitMs)
+                                await new Promise(r => setTimeout(r, waitMs));
+                            const text = await page.evaluate(() => document.body.innerText.slice(0, 12000));
+                            await page.close();
+                            await browser.close();
+                            return text + '\n\n[installed puppeteer automatically]';
+                        }
+                        catch (e2) {
+                            // fall through to fetch
+                        }
+                    }
+                    else {
+                        // install failed, fall through but include message
+                    }
+                }
+                // 4) Final fallback: fetch and strip html
+                try {
+                    const res = await fetch(url, { headers: { 'User-Agent': 'vesk-agentic/0.2.10' } });
+                    if (!res.ok)
+                        return JSON.stringify({ error: `fetch failed: ${res.status} ${res.statusText}`, hint: 'tried devtools bridge, puppeteer, and fetch — all failed' });
+                    const html = await res.text();
+                    const text = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '').replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '').replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 12000);
+                    return text + '\n\n[fallback: fetch strip — for full JS rendering install puppeteer or connect a browser devtools]';
+                }
+                catch (e) {
+                    return JSON.stringify({ error: e instanceof Error ? e.message : String(e), hint: 'no browser available and fetch failed' });
+                }
+            },
+        },
+        {
+            name: 'browser.inspect',
+            description: 'Inspect a page/element via users browser devtools first, then puppeteer. Can get outerHTML, styles, source, network, etc.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'URL to inspect (optional if already open)' },
+                    selector: { type: 'string', description: 'CSS selector to inspect (e.g. "#app", ".btn")' },
+                    what: { type: 'string', description: 'what to inspect: html, text, styles, attributes, source, network, js', enum: ['html', 'text', 'styles', 'attributes', 'source', 'network', 'js'] },
+                    js: { type: 'string', description: 'JS code to evaluate (when what=js)' },
+                },
+                required: [],
+            },
+            async execute(args) {
+                const url = args.url ? String(args.url) : undefined;
+                const selector = String(args.selector || 'body');
+                const what = String(args.what || 'html');
+                const js = args.js ? String(args.js) : undefined;
+                const bridge = getBridge();
+                if (bridge && bridge.hasClients()) {
+                    try {
+                        const res = await bridge.request({ action: 'inspect', url, selector, what, js }, 15000);
+                        if (res && typeof res.result === 'string')
+                            return String(res.result).slice(0, 15000);
+                        if (res)
+                            return JSON.stringify(res, null, 2).slice(0, 15000);
+                    }
+                    catch { }
+                }
+                // Fallback to fetch + basic inspection
+                if (what === 'js' && js) {
+                    return JSON.stringify({ error: 'js evaluation requires a browser — no devtools client connected and puppeteer not configured. The agent will install puppeteer.' });
+                }
+                if (url) {
+                    try {
+                        const res = await fetch(url, { headers: { 'User-Agent': 'vesk-agentic/0.2.10' } });
+                        const html = await res.text();
+                        if (what === 'source')
+                            return html.slice(0, 15000);
+                        if (what === 'html') {
+                            // naive selector: just return whole html if selector is body
+                            return html.slice(0, 15000);
+                        }
+                        const text = html.replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '').replace(/<[^>]*>/g, ' ').replace(/\s+/g, ' ').trim().slice(0, 12000);
+                        return text;
+                    }
+                    catch (e) {
+                        return JSON.stringify({ error: e instanceof Error ? e.message : String(e) });
+                    }
+                }
+                return JSON.stringify({ error: 'no url and no devtools browser connected — cannot inspect without a page' });
+            },
+        },
+        {
+            name: 'browser.eval',
+            description: 'Evaluate JavaScript in the users browser (via devtools) or puppeteer. Use for debugging, styles, networks.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    js: { type: 'string', description: 'JS code to evaluate (return value will be stringified)' },
+                    url: { type: 'string', description: 'URL to open first (optional)' },
+                },
+                required: ['js'],
+            },
+            async execute(args) {
+                const js = String(args.js || '');
+                const url = args.url ? String(args.url) : undefined;
+                if (!js)
+                    return JSON.stringify({ error: 'missing js' });
+                const bridge = getBridge();
+                if (bridge && bridge.hasClients()) {
+                    try {
+                        const res = await bridge.request({ action: 'eval', js, url }, 15000);
+                        if (res && typeof res.result !== 'undefined')
+                            return typeof res.result === 'string' ? res.result.slice(0, 15000) : JSON.stringify(res.result, null, 2).slice(0, 15000);
+                        if (res && typeof res.error === 'string')
+                            return JSON.stringify({ error: res.error });
+                    }
+                    catch { }
+                }
+                // Fallback: try puppeteer
+                try {
+                    // @ts-ignore
+                    const puppeteer = await import('puppeteer').catch(() => null);
+                    if (puppeteer) {
+                        // would need to launch, but for eval we need a page
+                        return JSON.stringify({ error: 'eval requires devtools browser — puppeteer fallback not yet wired for eval, will install and retry' });
+                    }
+                }
+                catch { }
+                return JSON.stringify({ error: 'no browser available for eval — connect a browser with devtools or ensure puppeteer is installed' });
+            },
+        },
+        {
+            name: 'browser.screenshot',
+            description: 'Take a screenshot via users browser devtools or puppeteer (auto-installs if needed). Returns base64 or note.',
+            parameters: {
+                type: 'object',
+                properties: { url: { type: 'string', description: 'URL to screenshot' } },
+                required: ['url'],
+            },
+            async execute(args) {
+                const url = String(args.url || '').trim();
+                if (!url)
+                    return JSON.stringify({ error: 'missing url' });
+                const bridge = getBridge();
+                if (bridge && bridge.hasClients()) {
+                    try {
+                        const res = await bridge.request({ action: 'screenshot', url }, 20000);
+                        if (res && typeof res.base64 === 'string')
+                            return JSON.stringify({ base64: res.base64.slice(0, 20000) + '...' });
+                    }
+                    catch { }
+                }
+                // Try puppeteer
+                try {
+                    // @ts-ignore
+                    const puppeteer = await import('puppeteer').catch(() => null);
+                    if (puppeteer && typeof puppeteer.launch === 'function') {
+                        const browser = await puppeteer.launch({ headless: true, args: ['--no-sandbox'] });
+                        const page = await browser.newPage();
+                        await page.goto(url, { waitUntil: 'networkidle2', timeout: 20000 });
+                        const buf = await page.screenshot({ encoding: 'base64' });
+                        await page.close();
+                        await browser.close();
+                        return JSON.stringify({ base64: String(buf).slice(0, 20000) });
+                    }
+                }
+                catch { }
+                if (dir) {
+                    const install = await ensurePuppeteerInstalled(dir);
+                    if (install.ok)
+                        return JSON.stringify({ note: 'puppeteer installed, retry screenshot', detail: install.message });
+                }
+                return JSON.stringify({ note: 'browser.screenshot requires a connected browser devtools or puppeteer — will auto-install on next call' });
+            },
+        },
+    ];
+}

package/dist/tools/command.d.ts

@@ -0,0 +1,14 @@
+/**
+ * @vesk/agentic — command tool
+ *
+ * Zero-deps. Single tool `command.execute` that is allowlist-checked before
+ * delegating to the injected `runCommand` runner. Every `execute` returns a
+ * JSON string and never throws.
+ */
+import type { Tool } from '../loop.js';
+export declare function createCommandTools(allowlist: RegExp[], runCommand: (argv: string[]) => Promise<{
+    stdout: string;
+    stderr: string;
+    code: number;
+}>): Tool[];
+//# sourceMappingURL=command.d.ts.map

package/dist/tools/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../src/tools/command.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,MAAM,EAAE,EACnB,UAAU,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,OAAO,CAAC;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GACxF,IAAI,EAAE,CAiDR"}

package/dist/tools/command.js

@@ -0,0 +1,55 @@
+/**
+ * @vesk/agentic — command tool
+ *
+ * Zero-deps. Single tool `command.execute` that is allowlist-checked before
+ * delegating to the injected `runCommand` runner. Every `execute` returns a
+ * JSON string and never throws.
+ */
+export function createCommandTools(allowlist, runCommand) {
+    const tool = {
+        name: 'command.execute',
+        description: 'Execute a shell command via the allowlisted runner. The command is checked against the allowlist before execution.',
+        parameters: {
+            type: 'object',
+            properties: {
+                argv: {
+                    type: 'array',
+                    description: 'Command and arguments as an array (e.g. ["npm","run","build"])',
+                    items: { type: 'string' },
+                },
+            },
+            required: ['argv'],
+            additionalProperties: false,
+        },
+        async execute(args) {
+            const raw = args.argv;
+            if (!Array.isArray(raw) || raw.length === 0) {
+                return JSON.stringify({ ok: false, error: 'missing required "argv" parameter (expected non-empty string[])' });
+            }
+            const argv = raw.filter((v) => typeof v === 'string');
+            if (argv.length !== raw.length) {
+                return JSON.stringify({ ok: false, error: '"argv" must be an array of strings' });
+            }
+            if (argv.length === 0) {
+                return JSON.stringify({ ok: false, error: 'missing required "argv" parameter (expected non-empty string[])' });
+            }
+            // Allowlist check — join with space to match the dev-api convention.
+            const joined = argv.join(' ');
+            const allowed = allowlist.some((re) => re.test(joined));
+            if (!allowed) {
+                return JSON.stringify({ ok: false, error: 'command not in allowlist', argv });
+            }
+            try {
+                const result = await runCommand(argv);
+                const stdout = typeof result.stdout === 'string' ? result.stdout : String(result.stdout ?? '');
+                const stderr = typeof result.stderr === 'string' ? result.stderr : String(result.stderr ?? '');
+                const code = typeof result.code === 'number' ? result.code : Number(result.code) || 0;
+                return JSON.stringify({ ok: true, argv, stdout, stderr, code });
+            }
+            catch (e) {
+                return JSON.stringify({ ok: false, error: e instanceof Error ? e.message : String(e), argv });
+            }
+        },
+    };
+    return [tool];
+}

package/dist/tools/fs.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @vesk/agentic — filesystem tools
+ *
+ * Zero-deps, node:fs only. Containment-checked via a local `resolveWithin`
+ * helper (no import from @vesk/adapter). Every `execute` returns a JSON
+ * string and never throws.
+ */
+import type { Tool } from '../loop.js';
+export declare function createFsTools(projectDir: string): Tool[];
+//# sourceMappingURL=fs.d.ts.map

package/dist/tools/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../src/tools/fs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAaH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AA+BvC,wBAAgB,aAAa,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,EAAE,CAoGxD"}

package/dist/tools/fs.js

@@ -0,0 +1,142 @@
+/**
+ * @vesk/agentic — filesystem tools
+ *
+ * Zero-deps, node:fs only. Containment-checked via a local `resolveWithin`
+ * helper (no import from @vesk/adapter). Every `execute` returns a JSON
+ * string and never throws.
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync, readdirSync, unlinkSync, rmSync, } from 'node:fs';
+import { resolve, dirname, sep } from 'node:path';
+// ──────────────────────────────────────────────────────────────────────────────
+// local containment helper — must stay in this file so the module is zero-deps
+// ──────────────────────────────────────────────────────────────────────────────
+/**
+ * Resolve `relPath` against `baseDir` and return the absolute path ONLY if
+ * it stays strictly inside `baseDir` (never the directory itself, never
+ * outside). Returns null otherwise.
+ */
+function resolveWithin(baseDir, relPath) {
+    const base = resolve(baseDir);
+    const target = resolve(baseDir, relPath);
+    const prefix = base + sep;
+    if (target === base || !target.startsWith(prefix))
+        return null;
+    return target;
+}
+function jsonOk(data) {
+    return JSON.stringify(data);
+}
+function jsonError(message, extra) {
+    return JSON.stringify({ ok: false, error: message, ...(extra || {}) });
+}
+// ──────────────────────────────────────────────────────────────────────────────
+// public API
+// ──────────────────────────────────────────────────────────────────────────────
+export function createFsTools(projectDir) {
+    const base = resolve(projectDir);
+    const readTool = {
+        name: 'filesystem.read',
+        description: 'Read a file or directory inside the project. Containment-checked; paths outside the project are rejected.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Project-relative path to read (e.g. "app/page.vsk" or "src/lib.ts")' },
+            },
+            required: ['path'],
+            additionalProperties: false,
+        },
+        async execute(args) {
+            const rel = String(args.path ?? '');
+            if (!rel)
+                return jsonError('missing required "path" parameter');
+            const resolved = resolveWithin(base, rel);
+            if (!resolved)
+                return jsonError('path escapes project root', { path: rel });
+            try {
+                if (!existsSync(resolved))
+                    return jsonError('not found', { path: rel });
+                const st = statSync(resolved);
+                if (st.isDirectory()) {
+                    const entries = readdirSync(resolved, { withFileTypes: true }).map((e) => e.isDirectory() ? e.name + '/' : e.name);
+                    return jsonOk({ ok: true, path: rel, directory: true, entries });
+                }
+                if (st.isFile()) {
+                    const content = readFileSync(resolved, 'utf-8');
+                    return jsonOk({ ok: true, path: rel, directory: false, content });
+                }
+                return jsonError('unsupported file type', { path: rel });
+            }
+            catch (e) {
+                return jsonError(e instanceof Error ? e.message : String(e), { path: rel });
+            }
+        },
+    };
+    const writeTool = {
+        name: 'filesystem.write',
+        description: 'Write (create or overwrite) a file inside the project. Containment-checked; paths outside the project are rejected. Creates parent directories as needed.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Project-relative path to write' },
+                content: { type: 'string', description: 'File content (utf-8)' },
+            },
+            required: ['path', 'content'],
+            additionalProperties: false,
+        },
+        async execute(args) {
+            const rel = String(args.path ?? '');
+            const content = String(args.content ?? '');
+            if (!rel)
+                return jsonError('missing required "path" parameter');
+            if (args.content === undefined)
+                return jsonError('missing required "content" parameter');
+            const resolved = resolveWithin(base, rel);
+            if (!resolved)
+                return jsonError('path escapes project root', { path: rel });
+            try {
+                mkdirSync(dirname(resolved), { recursive: true });
+                writeFileSync(resolved, content, 'utf-8');
+                return jsonOk({ ok: true, path: rel });
+            }
+            catch (e) {
+                return jsonError(e instanceof Error ? e.message : String(e), { path: rel });
+            }
+        },
+    };
+    const deleteTool = {
+        name: 'filesystem.delete',
+        description: 'Delete a file or directory inside the project. Containment-checked; paths outside the project are rejected.',
+        parameters: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Project-relative path to delete' },
+            },
+            required: ['path'],
+            additionalProperties: false,
+        },
+        async execute(args) {
+            const rel = String(args.path ?? '');
+            if (!rel)
+                return jsonError('missing required "path" parameter');
+            const resolved = resolveWithin(base, rel);
+            if (!resolved)
+                return jsonError('path escapes project root', { path: rel });
+            try {
+                if (!existsSync(resolved))
+                    return jsonError('not found', { path: rel });
+                const st = statSync(resolved);
+                if (st.isDirectory()) {
+                    rmSync(resolved, { recursive: true, force: true });
+                }
+                else {
+                    unlinkSync(resolved);
+                }
+                return jsonOk({ ok: true, path: rel });
+            }
+            catch (e) {
+                return jsonError(e instanceof Error ? e.message : String(e), { path: rel });
+            }
+        },
+    };
+    return [readTool, writeTool, deleteTool];
+}

package/dist/tools/vesk.d.ts

@@ -0,0 +1,22 @@
+/**
+ * @vesk/agentic — Vesk-native tools
+ *
+ * Zero-deps, node:fs-only tools routed through the Dev Server capability gate.
+ * All file access is containment-checked via a local `resolveWithin` helper.
+ * Every `execute` returns a JSON string (never throws).
+ *
+ * Export: `createVeskTools(deps)` -> Tool[] (14 tools, covering the
+ * `plans/devtools.md` Vesk-Native Agent Tools list).
+ */
+import type { Tool } from '../loop.js';
+export interface VeskToolsDeps {
+    projectDir: string;
+    appDir: string;
+    veskDir: string;
+    readConfig?: () => unknown | Promise<unknown>;
+    getDiagnostics?: () => unknown[] | Promise<unknown[]>;
+    runBuild?: () => Promise<unknown>;
+    runTests?: () => Promise<unknown>;
+}
+export declare function createVeskTools(deps: VeskToolsDeps): Tool[];
+//# sourceMappingURL=vesk.d.ts.map

package/dist/tools/vesk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vesk.d.ts","sourceRoot":"","sources":["../../src/tools/vesk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAIH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AA4LvC,MAAM,WAAW,aAAa;IAC5B,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,CAAC,EAAE,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC9C,cAAc,CAAC,EAAE,MAAM,OAAO,EAAE,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;IACtD,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAClC,QAAQ,CAAC,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;CACnC;AAUD,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,IAAI,EAAE,CAohB3D"}