freddie 0.0.41 → 0.0.42

package/src/tools/approval.js

@@ -1,15 +0,0 @@
-import { registry } from './registry.js'
-
-registry.register({
-    name: 'approval',
-    toolset: 'core',
-    schema: {
-        name: 'approval',
-        description: 'Request approval for a destructive action. Returns the user decision (allow|deny). In non-interactive contexts, defaults to deny unless config.acp.always_allow includes this action.',
-        parameters: { type: 'object', properties: { action: { type: 'string' }, reason: { type: 'string' } }, required: ['action'] },
-    },
-    handler: async ({ action, reason = '' }, ctx = {}) => {
-        if (typeof ctx.askApproval === 'function') return await ctx.askApproval({ action, reason })
-        return { decision: 'deny', reason: 'no interactive approval channel; supply ctx.askApproval' }
-    },
-})

package/src/tools/bash.js

@@ -1,35 +0,0 @@
-import { spawn } from 'node:child_process'
-import { registry } from './registry.js'
-
-registry.register({
-    name: 'bash',
-    toolset: 'core',
-    schema: {
-        name: 'bash',
-        description: 'Run a shell command. Returns stdout/stderr/exitCode.',
-        parameters: {
-            type: 'object',
-            properties: {
-                command: { type: 'string', description: 'Shell command to execute' },
-                cwd: { type: 'string', description: 'Working directory' },
-                timeout_ms: { type: 'number', description: 'Hard timeout in ms', default: 60000 },
-                background: { type: 'boolean', default: false },
-            },
-            required: ['command'],
-        },
-    },
-    handler: async (args) => {
-        const { command, cwd = process.cwd(), timeout_ms = 60000 } = args
-        return await new Promise((resolve) => {
-            const sh = process.platform === 'win32' ? 'cmd' : 'sh'
-            const flag = process.platform === 'win32' ? '/c' : '-c'
-            const child = spawn(sh, [flag, command], { cwd, env: process.env })
-            let stdout = '', stderr = ''
-            const t = setTimeout(() => { try { child.kill('SIGKILL') } catch {} resolve({ exitCode: -1, stdout, stderr: stderr + '\n[timeout]', timedOut: true }) }, timeout_ms)
-            child.stdout?.on('data', d => stdout += d.toString())
-            child.stderr?.on('data', d => stderr += d.toString())
-            child.on('close', code => { clearTimeout(t); resolve({ exitCode: code, stdout, stderr }) })
-            child.on('error', e => { clearTimeout(t); resolve({ exitCode: -1, stdout, stderr: stderr + '\n' + e.message }) })
-        })
-    },
-})

package/src/tools/binary_extensions.js

@@ -1,22 +0,0 @@
-import { registry } from './registry.js'
-
-export const BINARY_EXTENSIONS = new Set([
-    '.png', '.jpg', '.jpeg', '.gif', '.webp', '.bmp', '.ico', '.tiff',
-    '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx',
-    '.zip', '.tar', '.gz', '.bz2', '.xz', '.7z', '.rar',
-    '.exe', '.dll', '.so', '.dylib', '.bin',
-    '.mp3', '.mp4', '.mov', '.avi', '.flac', '.ogg',
-    '.ttf', '.otf', '.woff', '.woff2',
-    '.wasm', '.class', '.jar',
-])
-export function isBinary(filename) {
-    const lower = String(filename).toLowerCase()
-    for (const ext of BINARY_EXTENSIONS) if (lower.endsWith(ext)) return true
-    return false
-}
-registry.register({
-    name: 'binary_extensions',
-    toolset: 'core',
-    schema: { name: 'binary_extensions', description: 'Check whether a filename has a known binary extension.', parameters: { type: 'object', properties: { filename: { type: 'string' } }, required: ['filename'] } },
-    handler: async ({ filename }) => ({ binary: isBinary(filename), known: BINARY_EXTENSIONS.size }),
-})

package/src/tools/browser.js

@@ -1,48 +0,0 @@
-import { registry } from './registry.js'
-
-let _puppeteerAvail = null
-async function probe() {
-    if (_puppeteerAvail !== null) return _puppeteerAvail
-    try { await import('puppeteer-core'); _puppeteerAvail = true } catch { _puppeteerAvail = false }
-    return _puppeteerAvail
-}
-
-registry.register({
-    name: 'browser',
-    toolset: 'browse',
-    schema: {
-        name: 'browser',
-        description: 'Browser automation: navigate, click, type, evaluate, screenshot. Requires puppeteer-core.',
-        parameters: {
-            type: 'object',
-            properties: {
-                action: { type: 'string', enum: ['navigate', 'click', 'type', 'evaluate', 'screenshot', 'text'] },
-                url: { type: 'string' },
-                selector: { type: 'string' },
-                text: { type: 'string' },
-                script: { type: 'string' },
-                path: { type: 'string' },
-            },
-            required: ['action'],
-        },
-    },
-    checkFn: () => true,
-    requiresEnv: ['puppeteer-core'],
-    handler: async (args) => {
-        const ok = await probe()
-        if (!ok) return { error: 'puppeteer-core not installed. Run: npm install puppeteer-core' }
-        const puppeteer = (await import('puppeteer-core')).default
-        const browser = await puppeteer.launch({ headless: 'new' })
-        try {
-            const page = await browser.newPage()
-            const a = args.action
-            if (a === 'navigate') { await page.goto(args.url, { waitUntil: 'domcontentloaded' }); return { url: page.url(), title: await page.title() } }
-            if (a === 'click') { await page.goto(args.url, { waitUntil: 'domcontentloaded' }); await page.click(args.selector); return { ok: true } }
-            if (a === 'type') { await page.goto(args.url, { waitUntil: 'domcontentloaded' }); await page.type(args.selector, args.text); return { ok: true } }
-            if (a === 'evaluate') { await page.goto(args.url, { waitUntil: 'domcontentloaded' }); return { result: await page.evaluate(args.script) } }
-            if (a === 'text') { await page.goto(args.url, { waitUntil: 'domcontentloaded' }); return { text: await page.evaluate(() => document.body.innerText) } }
-            if (a === 'screenshot') { await page.goto(args.url, { waitUntil: 'domcontentloaded' }); await page.screenshot({ path: args.path }); return { saved: args.path } }
-            return { error: 'unknown action: ' + a }
-        } finally { await browser.close() }
-    },
-})

package/src/tools/budget_config.js

@@ -1,13 +0,0 @@
-import { registry } from './registry.js'
-import { getConfigValue, saveConfigValue } from '../config.js'
-
-registry.register({
-    name: 'budget_config',
-    toolset: 'core',
-    schema: { name: 'budget_config', description: 'Read/write per-session token budget limits.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['get', 'set'] }, max_tokens: { type: 'number' }, max_cost_usd: { type: 'number' } }, required: ['action'] } },
-    handler: async ({ action, max_tokens, max_cost_usd }) => {
-        if (action === 'get') return { max_tokens: getConfigValue('budget.max_tokens'), max_cost_usd: getConfigValue('budget.max_cost_usd') }
-        if (action === 'set') { if (typeof max_tokens === 'number') saveConfigValue('budget.max_tokens', max_tokens); if (typeof max_cost_usd === 'number') saveConfigValue('budget.max_cost_usd', max_cost_usd); return { saved: true } }
-        return { error: 'unknown action' }
-    },
-})

package/src/tools/checkpoint.js

@@ -1,29 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { getFophHome } from '../home.js'
-import { registry } from './registry.js'
-
-function dir() { const d = path.join(getFophHome(), 'checkpoints'); fs.mkdirSync(d, { recursive: true }); return d }
-
-const ACTIONS = {
-    save: ({ name, data }) => {
-        if (!name) return { error: 'name required' }
-        const p = path.join(dir(), name + '.json')
-        fs.writeFileSync(p, JSON.stringify(data || {}, null, 2), 'utf8')
-        return { saved: p }
-    },
-    load: ({ name }) => {
-        const p = path.join(dir(), name + '.json')
-        if (!fs.existsSync(p)) return { error: 'not found' }
-        return { data: JSON.parse(fs.readFileSync(p, 'utf8')) }
-    },
-    list: () => ({ items: fs.readdirSync(dir()).filter(f => f.endsWith('.json')).map(f => f.replace(/\.json$/, '')) }),
-    delete: ({ name }) => { const p = path.join(dir(), name + '.json'); if (fs.existsSync(p)) fs.unlinkSync(p); return { deleted: name } },
-}
-
-registry.register({
-    name: 'checkpoint',
-    toolset: 'core',
-    schema: { name: 'checkpoint', description: 'Save/load/list/delete named JSON checkpoints under ~/.freddie/checkpoints.', parameters: { type: 'object', properties: { action: { type: 'string', enum: Object.keys(ACTIONS) }, name: { type: 'string' }, data: {} }, required: ['action'] } },
-    handler: async (args) => { const fn = ACTIONS[args.action]; return fn ? fn(args) : { error: 'unknown action' } },
-})

package/src/tools/clarify.js

@@ -1,15 +0,0 @@
-import { registry } from './registry.js'
-
-registry.register({
-    name: 'clarify',
-    toolset: 'core',
-    schema: {
-        name: 'clarify',
-        description: 'Pose a clarifying question to the user before proceeding. Returns the user response. In non-interactive contexts, returns { error } so the agent must proceed with stated assumption.',
-        parameters: { type: 'object', properties: { question: { type: 'string' }, options: { type: 'array', items: { type: 'string' } } }, required: ['question'] },
-    },
-    handler: async ({ question, options = [] }, ctx = {}) => {
-        if (typeof ctx.askUser === 'function') return await ctx.askUser({ question, options })
-        return { error: 'no interactive channel; assume defaults', question, options }
-    },
-})

package/src/tools/code_execution.js

@@ -1,27 +0,0 @@
-import { spawn } from 'node:child_process'
-import { registry } from './registry.js'
-
-const RUNNERS = {
-    python: ['python', '-c'], python3: ['python3', '-c'],
-    node: ['node', '-e'], deno: ['deno', 'eval'],
-    ruby: ['ruby', '-e'], bash: ['bash', '-c'],
-}
-
-registry.register({
-    name: 'code_execution',
-    toolset: 'core',
-    schema: { name: 'code_execution', description: 'Execute a code snippet in a chosen runner (python, node, deno, ruby, bash). Returns stdout/stderr/exitCode.', parameters: { type: 'object', properties: { code: { type: 'string' }, runner: { type: 'string', enum: Object.keys(RUNNERS), default: 'python' }, timeout_ms: { type: 'number', default: 30000 } }, required: ['code'] } },
-    handler: async ({ code, runner = 'python', timeout_ms = 30000 }) => {
-        const cmd = RUNNERS[runner]
-        if (!cmd) return { error: 'unknown runner: ' + runner }
-        return await new Promise(resolve => {
-            const child = spawn(cmd[0], [cmd[1], code], { env: process.env })
-            let stdout = '', stderr = ''
-            const t = setTimeout(() => { try { child.kill('SIGKILL') } catch {} resolve({ exitCode: -1, stdout, stderr: stderr + '\n[timeout]' }) }, timeout_ms)
-            child.stdout?.on('data', d => stdout += d.toString())
-            child.stderr?.on('data', d => stderr += d.toString())
-            child.on('close', code => { clearTimeout(t); resolve({ exitCode: code, stdout, stderr }) })
-            child.on('error', e => { clearTimeout(t); resolve({ exitCode: -1, stdout, stderr: stderr + '\n' + e.message }) })
-        })
-    },
-})

package/src/tools/credential_files.js

@@ -1,16 +0,0 @@
-import { getAuthStore } from '../auth.js'
-import { registry } from './registry.js'
-
-registry.register({
-    name: 'credential_files',
-    toolset: 'core',
-    schema: { name: 'credential_files', description: 'Get/set credentials in ~/.freddie/auth/.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['get', 'set', 'list', 'delete'] }, name: { type: 'string' }, value: {} }, required: ['action'] } },
-    handler: async ({ action, name, value }) => {
-        const s = getAuthStore()
-        if (action === 'get') return { credential: await s.getCredential(name) }
-        if (action === 'set') return await s.setCredential(name, value)
-        if (action === 'list') return { credentials: await s.listCredentials() }
-        if (action === 'delete') return await s.deleteCredential(name)
-        return { error: 'unknown action' }
-    },
-})

package/src/tools/cronjob.js

@@ -1,16 +0,0 @@
-import { createJob, listJobs, cancelJob, deleteJob } from '../cron/scheduler.js'
-import { registry } from './registry.js'
-
-const ACTIONS = {
-    add: ({ cron, prompt, model = null }) => ({ id: createJob({ cron, prompt, model }) }),
-    list: () => ({ jobs: listJobs() }),
-    cancel: ({ id }) => { cancelJob(id); return { id, cancelled: true } },
-    delete: ({ id }) => { deleteJob(id); return { id, deleted: true } },
-}
-
-registry.register({
-    name: 'cronjob',
-    toolset: 'core',
-    schema: { name: 'cronjob', description: 'Manage agent cron jobs (add, list, cancel, delete).', parameters: { type: 'object', properties: { action: { type: 'string', enum: Object.keys(ACTIONS) }, cron: { type: 'string' }, prompt: { type: 'string' }, model: { type: 'string' }, id: { type: 'number' } }, required: ['action'] } },
-    handler: async (args) => { const fn = ACTIONS[args.action]; if (!fn) return { error: 'unknown action' }; try { return fn(args) } catch (e) { return { error: String(e.message || e) } } },
-})

package/src/tools/debug_helpers.js

@@ -1,9 +0,0 @@
-import { registry } from './registry.js'
-import { snapshotAll, listDebug } from '../observability/debug.js'
-
-registry.register({
-    name: 'debug_helpers',
-    toolset: 'core',
-    schema: { name: 'debug_helpers', description: 'Inspect any registered /debug subsystem.', parameters: { type: 'object', properties: { name: { type: 'string' } } } },
-    handler: async ({ name }) => name ? snapshotAll()[name] || { error: 'unknown subsystem: ' + name } : { subsystems: listDebug() },
-})

package/src/tools/delegate.js

@@ -1,28 +0,0 @@
-import { registry } from './registry.js'
-import { runTurn } from '../agent/machine.js'
-
-const MAX_DEPTH = 3
-
-registry.register({
-    name: 'delegate',
-    toolset: 'core',
-    schema: {
-        name: 'delegate',
-        description: 'Spawn a sub-agent to handle a focused task. Returns the sub-agent final result.',
-        parameters: {
-            type: 'object',
-            properties: {
-                task: { type: 'string' },
-                model: { type: 'string' },
-                max_iterations: { type: 'number', default: 30 },
-            },
-            required: ['task'],
-        },
-    },
-    handler: async ({ task, model, max_iterations = 30 }, ctx = {}) => {
-        const depth = (ctx.depth || 0) + 1
-        if (depth > MAX_DEPTH) return { error: `delegate recursion depth exceeded (${MAX_DEPTH})` }
-        const out = await runTurn({ prompt: task, model, callLLM: ctx.callLLM, maxIterations: max_iterations, timeoutMs: 60000 })
-        return { result: out.result, error: out.error, iterations: out.iterations, depth }
-    },
-})

package/src/tools/discord_tool.js

@@ -1,13 +0,0 @@
-import { registry } from './registry.js'
-registry.register({
-    name: 'discord_tool',
-    toolset: 'core',
-    schema: { name: 'discord_tool', description: 'Send a message to a Discord channel via REST.', parameters: { type: 'object', properties: { channel_id: { type: 'string' }, content: { type: 'string' } }, required: ['channel_id', 'content'] } },
-    requiresEnv: ['DISCORD_BOT_TOKEN'],
-    checkFn: () => Boolean(process.env.DISCORD_BOT_TOKEN),
-    handler: async ({ channel_id, content }) => {
-        if (!process.env.DISCORD_BOT_TOKEN) return { error: 'DISCORD_BOT_TOKEN required' }
-        const r = await fetch(`https://discord.com/api/v10/channels/${channel_id}/messages`, { method: 'POST', headers: { authorization: `Bot ${process.env.DISCORD_BOT_TOKEN}`, 'content-type': 'application/json' }, body: JSON.stringify({ content }) })
-        return await r.json()
-    },
-})

package/src/tools/edit.js

@@ -1,31 +0,0 @@
-import fs from 'node:fs'
-import { registry } from './registry.js'
-
-registry.register({
-    name: 'edit',
-    toolset: 'core',
-    schema: {
-        name: 'edit',
-        description: 'Replace exact string in file. Fails if old_string occurs zero or multiple times unless replace_all.',
-        parameters: {
-            type: 'object',
-            properties: {
-                path: { type: 'string' },
-                old_string: { type: 'string' },
-                new_string: { type: 'string' },
-                replace_all: { type: 'boolean', default: false },
-            },
-            required: ['path', 'old_string', 'new_string'],
-        },
-    },
-    handler: async ({ path: p, old_string, new_string, replace_all = false }) => {
-        if (!fs.existsSync(p)) return { error: `not found: ${p}` }
-        const src = fs.readFileSync(p, 'utf8')
-        const occurrences = src.split(old_string).length - 1
-        if (occurrences === 0) return { error: 'old_string not found' }
-        if (occurrences > 1 && !replace_all) return { error: `old_string matches ${occurrences} times; pass replace_all=true` }
-        const out = replace_all ? src.split(old_string).join(new_string) : src.replace(old_string, new_string)
-        fs.writeFileSync(p, out, 'utf8')
-        return { path: p, replacements: replace_all ? occurrences : 1 }
-    },
-})

package/src/tools/env_passthrough.js

@@ -1,15 +0,0 @@
-import { registry } from './registry.js'
-import { getConfigValue } from '../config.js'
-
-export function buildBashEnv() {
-    const allow = getConfigValue('terminal.env_passthrough', ['HOME', 'USER', 'LANG', 'PATH', 'SHELL']) || []
-    const out = {}
-    for (const k of allow) if (process.env[k]) out[k] = process.env[k]
-    return out
-}
-registry.register({
-    name: 'env_passthrough',
-    toolset: 'core',
-    schema: { name: 'env_passthrough', description: 'Compute the env-var subset that should be passed through to spawned shells.', parameters: { type: 'object', properties: {} } },
-    handler: async () => ({ env: buildBashEnv() }),
-})

package/src/tools/feishu_doc.js

@@ -1,15 +0,0 @@
-import { registry } from './registry.js'
-registry.register({
-    name: 'feishu_doc',
-    toolset: 'core',
-    schema: { name: 'feishu_doc', description: 'Read or update a Feishu doc by token.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['get', 'patch'] }, doc_token: { type: 'string' }, content: {} }, required: ['action', 'doc_token'] } },
-    requiresEnv: ['FEISHU_APP_TOKEN'],
-    checkFn: () => Boolean(process.env.FEISHU_APP_TOKEN),
-    handler: async ({ action, doc_token, content }) => {
-        const auth = { authorization: `Bearer ${process.env.FEISHU_APP_TOKEN}` }
-        const base = 'https://open.feishu.cn/open-apis/docx/v1/documents/' + doc_token
-        if (action === 'get') return await (await fetch(base, { headers: auth })).json()
-        if (action === 'patch') return await (await fetch(base + '/blocks', { method: 'PATCH', headers: { ...auth, 'content-type': 'application/json' }, body: JSON.stringify(content) })).json()
-        return { error: 'unknown action' }
-    },
-})

package/src/tools/feishu_drive.js

@@ -1,14 +0,0 @@
-import { registry } from './registry.js'
-registry.register({
-    name: 'feishu_drive',
-    toolset: 'core',
-    schema: { name: 'feishu_drive', description: 'List or download Feishu Drive files.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['list', 'download'] }, folder_token: { type: 'string' }, file_token: { type: 'string' } }, required: ['action'] } },
-    requiresEnv: ['FEISHU_APP_TOKEN'],
-    checkFn: () => Boolean(process.env.FEISHU_APP_TOKEN),
-    handler: async ({ action, folder_token, file_token }) => {
-        const auth = { authorization: `Bearer ${process.env.FEISHU_APP_TOKEN}` }
-        if (action === 'list') return await (await fetch('https://open.feishu.cn/open-apis/drive/v1/files?folder_token=' + (folder_token || ''), { headers: auth })).json()
-        if (action === 'download') return await (await fetch(`https://open.feishu.cn/open-apis/drive/v1/files/${file_token}/download`, { headers: auth })).json()
-        return { error: 'unknown action' }
-    },
-})

package/src/tools/file_operations.js

@@ -1,17 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { registry } from './registry.js'
-
-const ACTIONS = {
-    move: ({ src, dest }) => { fs.mkdirSync(path.dirname(dest), { recursive: true }); fs.renameSync(src, dest); return { moved: dest } },
-    copy: ({ src, dest }) => { fs.mkdirSync(path.dirname(dest), { recursive: true }); fs.copyFileSync(src, dest); return { copied: dest } },
-    delete: ({ path: p }) => { if (fs.existsSync(p)) fs.rmSync(p, { recursive: true, force: true }); return { deleted: p } },
-    mkdir: ({ path: p }) => { fs.mkdirSync(p, { recursive: true }); return { created: p } },
-    stat: ({ path: p }) => { const s = fs.statSync(p); return { size: s.size, mtime: s.mtimeMs, isDir: s.isDirectory() } },
-}
-registry.register({
-    name: 'file_operations',
-    toolset: 'core',
-    schema: { name: 'file_operations', description: 'move/copy/delete/mkdir/stat — atomic file ops.', parameters: { type: 'object', properties: { action: { type: 'string', enum: Object.keys(ACTIONS) }, src: { type: 'string' }, dest: { type: 'string' }, path: { type: 'string' } }, required: ['action'] } },
-    handler: async (a) => { const fn = ACTIONS[a.action]; try { return fn ? fn(a) : { error: 'unknown action' } } catch (e) { return { error: String(e.message || e) } } },
-})

package/src/tools/file_state.js

@@ -1,16 +0,0 @@
-import { db } from '../db.js'
-import { registry } from './registry.js'
-
-async function init() { const d = await db(); d.exec(`CREATE TABLE IF NOT EXISTS file_state (id INTEGER PRIMARY KEY AUTOINCREMENT, session_id TEXT, file_path TEXT NOT NULL, action TEXT NOT NULL, ts INTEGER NOT NULL)`); return d }
-registry.register({
-    name: 'file_state',
-    toolset: 'core',
-    schema: { name: 'file_state', description: 'Track files modified in this session (read|write|edit|delete) for diff-summary purposes.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['record', 'list', 'changed_in_session'] }, session_id: { type: 'string' }, file_path: { type: 'string' }, op: { type: 'string' } }, required: ['action'] } },
-    handler: async ({ action, session_id, file_path, op }) => {
-        const d = await init()
-        if (action === 'record') { d.prepare('INSERT INTO file_state (session_id, file_path, action, ts) VALUES (?, ?, ?, ?)').run(session_id, file_path, op, Date.now()); return { recorded: true } }
-        if (action === 'list') return { items: d.prepare('SELECT * FROM file_state WHERE session_id = ? ORDER BY id DESC').all(session_id) }
-        if (action === 'changed_in_session') return { files: [...new Set(d.prepare('SELECT file_path FROM file_state WHERE session_id = ?').all(session_id).map(r => r.file_path))] }
-        return { error: 'unknown action' }
-    },
-})

package/src/tools/file_tools.js

@@ -1,23 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { registry } from './registry.js'
-
-function walk(dir, out, skip) {
-    let entries; try { entries = fs.readdirSync(dir, { withFileTypes: true }) } catch { return }
-    for (const e of entries) {
-        if (skip.has(e.name)) continue
-        const full = path.join(dir, e.name)
-        if (e.isDirectory()) walk(full, out, skip)
-        else out.push(full)
-    }
-}
-registry.register({
-    name: 'file_tools',
-    toolset: 'core',
-    schema: { name: 'file_tools', description: 'list/glob files (recursive walk skipping node_modules, .git, dist).', parameters: { type: 'object', properties: { dir: { type: 'string', default: '.' }, ext: { type: 'string' }, limit: { type: 'number', default: 1000 } } } },
-    handler: async ({ dir = '.', ext, limit = 1000 }) => {
-        const out = []; walk(dir, out, new Set(['node_modules', '.git', 'dist', '.cache', 'build']))
-        const filtered = ext ? out.filter(f => f.endsWith(ext)) : out
-        return { files: filtered.slice(0, limit), total: filtered.length, truncated: filtered.length > limit }
-    },
-})

package/src/tools/fuzzy_match.js

@@ -1,8 +0,0 @@
-import { fuzzyMatch as helper } from '../utils.js'
-import { registry } from './registry.js'
-registry.register({
-    name: 'fuzzy_match',
-    toolset: 'core',
-    schema: { name: 'fuzzy_match', description: 'Score a candidate string against a needle. Returns 0 for no match, higher for better match.', parameters: { type: 'object', properties: { needle: { type: 'string' }, haystack: { type: 'string' } }, required: ['needle', 'haystack'] } },
-    handler: async ({ needle, haystack }) => ({ score: helper(needle, haystack) }),
-})

package/src/tools/grep.js

@@ -1,51 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { registry } from './registry.js'
-
-registry.register({
-    name: 'grep',
-    toolset: 'core',
-    schema: {
-        name: 'grep',
-        description: 'Recursive regex search across files. Returns file:line:content matches.',
-        parameters: {
-            type: 'object',
-            properties: {
-                pattern: { type: 'string' },
-                path: { type: 'string', default: '.' },
-                glob: { type: 'string' },
-                head_limit: { type: 'number', default: 200 },
-                ignore_case: { type: 'boolean', default: false },
-            },
-            required: ['pattern'],
-        },
-    },
-    handler: async ({ pattern, path: root = '.', head_limit = 200, ignore_case = false, glob }) => {
-        const re = new RegExp(pattern, ignore_case ? 'i' : '')
-        const out = []
-        const skipDirs = new Set(['node_modules', '.git', 'dist', 'build', '.cache'])
-        const walk = (d) => {
-            if (out.length >= head_limit) return
-            let entries
-            try { entries = fs.readdirSync(d, { withFileTypes: true }) } catch { return }
-            for (const e of entries) {
-                if (out.length >= head_limit) return
-                const full = path.join(d, e.name)
-                if (e.isDirectory()) { if (!skipDirs.has(e.name)) walk(full); continue }
-                if (glob && !matchGlob(e.name, glob)) continue
-                let content
-                try { content = fs.readFileSync(full, 'utf8') } catch { continue }
-                content.split('\n').forEach((line, i) => {
-                    if (out.length < head_limit && re.test(line)) out.push(`${full}:${i + 1}:${line.slice(0, 200)}`)
-                })
-            }
-        }
-        walk(root)
-        return { matches: out, total: out.length, truncated: out.length >= head_limit }
-    },
-})
-
-function matchGlob(name, glob) {
-    const re = new RegExp('^' + glob.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.') + '$', 'i')
-    return re.test(name)
-}

package/src/tools/homeassistant_tool.js

@@ -1,15 +0,0 @@
-import { registry } from './registry.js'
-registry.register({
-    name: 'homeassistant_tool',
-    toolset: 'core',
-    schema: { name: 'homeassistant_tool', description: 'Read state or call a service on Home Assistant.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['state', 'service'] }, entity_id: { type: 'string' }, domain: { type: 'string' }, service: { type: 'string' }, data: {} }, required: ['action'] } },
-    requiresEnv: ['HASS_TOKEN', 'HASS_URL'],
-    checkFn: () => Boolean(process.env.HASS_TOKEN),
-    handler: async ({ action, entity_id, domain, service, data = {} }) => {
-        const url = process.env.HASS_URL || 'http://homeassistant.local:8123'
-        const auth = { authorization: `Bearer ${process.env.HASS_TOKEN}` }
-        if (action === 'state') return await (await fetch(`${url}/api/states/${entity_id}`, { headers: auth })).json()
-        if (action === 'service') return await (await fetch(`${url}/api/services/${domain}/${service}`, { method: 'POST', headers: { ...auth, 'content-type': 'application/json' }, body: JSON.stringify({ entity_id, ...data }) })).json()
-        return { error: 'unknown action' }
-    },
-})

package/src/tools/image_gen.js

@@ -1,33 +0,0 @@
-import { registry } from './registry.js'
-
-registry.register({
-    name: 'image_gen',
-    toolset: 'creative',
-    schema: {
-        name: 'image_gen',
-        description: 'Generate an image from a prompt. Provider via config.image_gen.provider (openai|replicate).',
-        parameters: {
-            type: 'object',
-            properties: {
-                prompt: { type: 'string' },
-                provider: { type: 'string', enum: ['openai', 'replicate'] },
-                size: { type: 'string', default: '1024x1024' },
-                model: { type: 'string' },
-            },
-            required: ['prompt'],
-        },
-    },
-    checkFn: () => Boolean(process.env.OPENAI_API_KEY || process.env.REPLICATE_API_TOKEN),
-    requiresEnv: ['OPENAI_API_KEY or REPLICATE_API_TOKEN'],
-    handler: async ({ prompt, provider, size = '1024x1024', model }) => {
-        const which = provider || (process.env.OPENAI_API_KEY ? 'openai' : 'replicate')
-        if (which === 'openai') {
-            if (!process.env.OPENAI_API_KEY) return { error: 'OPENAI_API_KEY required' }
-            const res = await fetch('https://api.openai.com/v1/images/generations', { method: 'POST', headers: { authorization: `Bearer ${process.env.OPENAI_API_KEY}`, 'content-type': 'application/json' }, body: JSON.stringify({ model: model || 'gpt-image-1', prompt, size }) })
-            return await res.json()
-        }
-        if (!process.env.REPLICATE_API_TOKEN) return { error: 'REPLICATE_API_TOKEN required' }
-        const res = await fetch('https://api.replicate.com/v1/predictions', { method: 'POST', headers: { authorization: `Token ${process.env.REPLICATE_API_TOKEN}`, 'content-type': 'application/json' }, body: JSON.stringify({ version: model || 'black-forest-labs/flux-schnell', input: { prompt } }) })
-        return await res.json()
-    },
-})

package/src/tools/interrupt.js

@@ -1,18 +0,0 @@
-import { registry } from './registry.js'
-
-const _flags = new Map()
-export function setInterrupt(sessionId) { _flags.set(sessionId, true) }
-export function isInterrupted(sessionId) { return _flags.get(sessionId) === true }
-export function clearInterrupt(sessionId) { _flags.delete(sessionId) }
-
-registry.register({
-    name: 'interrupt',
-    toolset: 'core',
-    schema: { name: 'interrupt', description: 'Set/clear/check interrupt flag for a session — agent loop polls and exits early.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['set', 'clear', 'check'] }, session_id: { type: 'string' } }, required: ['action', 'session_id'] } },
-    handler: async ({ action, session_id }) => {
-        if (action === 'set') { setInterrupt(session_id); return { interrupted: true } }
-        if (action === 'clear') { clearInterrupt(session_id); return { cleared: true } }
-        if (action === 'check') return { interrupted: isInterrupted(session_id) }
-        return { error: 'unknown action' }
-    },
-})

package/src/tools/managed_tool_gateway.js

@@ -1,11 +0,0 @@
-import { registry } from './registry.js'
-
-registry.register({
-    name: 'managed_tool_gateway',
-    toolset: 'core',
-    schema: { name: 'managed_tool_gateway', description: 'Proxy: dispatch any registered tool by name with arguments. Used for tool-level audit and policy interception.', parameters: { type: 'object', properties: { name: { type: 'string' }, arguments: {} }, required: ['name'] } },
-    handler: async ({ name, arguments: args = {} }, ctx = {}) => {
-        if (typeof ctx.audit === 'function') ctx.audit({ name, args })
-        return { result: await registry.dispatch(name, args, ctx) }
-    },
-})

package/src/tools/mcp_oauth.js

@@ -1,21 +0,0 @@
-import { registry } from './registry.js'
-registry.register({
-    name: 'mcp_oauth',
-    toolset: 'core',
-    schema: { name: 'mcp_oauth', description: 'OAuth flow for an MCP server: build authorize URL, exchange code for token.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['authorize_url', 'exchange'] }, server_url: { type: 'string' }, client_id: { type: 'string' }, redirect_uri: { type: 'string' }, code: { type: 'string' }, code_verifier: { type: 'string' } }, required: ['action', 'server_url'] } },
-    handler: async ({ action, server_url, client_id, redirect_uri, code, code_verifier }) => {
-        if (action === 'authorize_url') {
-            const u = new URL(server_url + '/authorize')
-            if (client_id) u.searchParams.set('client_id', client_id)
-            if (redirect_uri) u.searchParams.set('redirect_uri', redirect_uri)
-            u.searchParams.set('response_type', 'code')
-            u.searchParams.set('code_challenge_method', 'S256')
-            return { url: u.toString() }
-        }
-        if (action === 'exchange') {
-            const r = await fetch(server_url + '/token', { method: 'POST', headers: { 'content-type': 'application/x-www-form-urlencoded' }, body: new URLSearchParams({ grant_type: 'authorization_code', code, redirect_uri, code_verifier, client_id }).toString() })
-            return await r.json()
-        }
-        return { error: 'unknown action' }
-    },
-})