freddie 0.0.41 → 0.0.42

package/src/tools/mcp_oauth_manager.js

@@ -1,20 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { getFophHome } from '../home.js'
-import { registry } from './registry.js'
-
-function tokFile(server) { return path.join(getFophHome(), 'mcp-tokens', encodeURIComponent(server) + '.json') }
-
-registry.register({
-    name: 'mcp_oauth_manager',
-    toolset: 'core',
-    schema: { name: 'mcp_oauth_manager', description: 'Persist & retrieve MCP OAuth tokens. Actions: store, get, list, delete, refresh.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['store', 'get', 'list', 'delete'] }, server: { type: 'string' }, token: {} }, required: ['action'] } },
-    handler: async ({ action, server, token }) => {
-        const dir = path.join(getFophHome(), 'mcp-tokens'); fs.mkdirSync(dir, { recursive: true })
-        if (action === 'store') { fs.writeFileSync(tokFile(server), JSON.stringify({ server, token, ts: Date.now() }), { mode: 0o600 }); return { stored: server } }
-        if (action === 'get') { const f = tokFile(server); return fs.existsSync(f) ? JSON.parse(fs.readFileSync(f, 'utf8')) : { error: 'not found' } }
-        if (action === 'list') return { servers: fs.readdirSync(dir).filter(f => f.endsWith('.json')).map(f => decodeURIComponent(f.replace(/\.json$/, ''))) }
-        if (action === 'delete') { const f = tokFile(server); if (fs.existsSync(f)) fs.unlinkSync(f); return { deleted: server } }
-        return { error: 'unknown action' }
-    },
-})

package/src/tools/mcp_tool.js

@@ -1,36 +0,0 @@
-import { spawn } from 'node:child_process'
-import { registry } from './registry.js'
-
-const _clients = new Map()
-
-registry.register({
-    name: 'mcp_tool',
-    toolset: 'core',
-    schema: { name: 'mcp_tool', description: 'Connect to an external MCP server (stdio) and call its tools.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['connect', 'list', 'call', 'disconnect'] }, id: { type: 'string' }, command: { type: 'string' }, args: { type: 'array' }, name: { type: 'string' }, arguments: {} }, required: ['action'] } },
-    handler: async ({ action, id, command, args = [], name, arguments: callArgs = {} }) => {
-        if (action === 'connect') {
-            const cid = id || 'mcp-' + Date.now()
-            const child = spawn(command, args, { stdio: ['pipe', 'pipe', 'pipe'] })
-            _clients.set(cid, { child, nextId: 1, pending: new Map(), buf: '' })
-            const c = _clients.get(cid)
-            child.stdout.on('data', d => {
-                c.buf += d.toString()
-                const lines = c.buf.split('\n'); c.buf = lines.pop()
-                for (const l of lines) { try { const m = JSON.parse(l); const p = c.pending.get(m.id); if (p) { c.pending.delete(m.id); p.resolve(m) } } catch {} }
-            })
-            return { id: cid, connected: true }
-        }
-        const c = _clients.get(id)
-        if (!c) return { error: 'unknown id' }
-        const rpc = (method, params) => new Promise((resolve, reject) => {
-            const rid = c.nextId++
-            c.pending.set(rid, { resolve, reject })
-            c.child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: rid, method, params }) + '\n')
-            setTimeout(() => { if (c.pending.has(rid)) { c.pending.delete(rid); reject(new Error('mcp timeout')) } }, 30000)
-        })
-        if (action === 'list') return await rpc('tools/list', {})
-        if (action === 'call') return await rpc('tools/call', { name, arguments: callArgs })
-        if (action === 'disconnect') { try { c.child.kill('SIGTERM') } catch {} _clients.delete(id); return { disconnected: id } }
-        return { error: 'unknown action' }
-    },
-})

package/src/tools/memory.js

@@ -1,66 +0,0 @@
-import { db } from '../db.js'
-import { registry } from './registry.js'
-import { getConfigValue } from '../config.js'
-import { createMemoryProvider } from '../plugins/memory/provider.js'
-
-async function init() {
-    const d = await db()
-    d.exec(`CREATE TABLE IF NOT EXISTS memory_local (id INTEGER PRIMARY KEY AUTOINCREMENT, content TEXT NOT NULL, ts INTEGER NOT NULL)`)
-    if (!d._fts5_unavailable) {
-        try { d.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS memory_local_fts USING fts5(content, content='memory_local', content_rowid='id')`) } catch (e) { d._fts5_unavailable = true }
-        try { d.exec(`CREATE TRIGGER IF NOT EXISTS memory_local_ai AFTER INSERT ON memory_local BEGIN INSERT INTO memory_local_fts(rowid, content) VALUES (new.id, new.content); END`) } catch (e) { d._fts5_unavailable = true }
-    }
-    return d
-}
-
-function provider() {
-    const name = getConfigValue('memory.provider')
-    if (!name) return null
-    try { return createMemoryProvider(name, {}) } catch { return null }
-}
-
-const ACTIONS = {
-    add: async ({ content }) => {
-        if (!content) return { error: 'content required' }
-        const p = provider()
-        if (p) { await p.syncTurn([{ role: 'note', content }]); return { stored: 'remote' } }
-        const d = await init()
-        const info = d.prepare(`INSERT INTO memory_local (content, ts) VALUES (?, ?)`).run(content, Date.now())
-        return { id: info.lastInsertRowid, stored: 'local' }
-    },
-    search: async ({ query, limit = 10 }) => {
-        const p = provider()
-        if (p) return await p.prefetch(query)
-        const d = await init()
-        if (d._fts5_unavailable) {
-            const rows = d.prepare(`SELECT id, content, ts FROM memory_local WHERE content LIKE ? ORDER BY ts DESC LIMIT ?`).all('%' + query + '%', limit)
-            return { items: rows }
-        }
-        try {
-            const rows = d.prepare(`SELECT m.id, m.content, m.ts FROM memory_local_fts f JOIN memory_local m ON m.id = f.rowid WHERE memory_local_fts MATCH ? ORDER BY rank LIMIT ?`).all(query, limit)
-            return { items: rows }
-        } catch {
-            const rows = d.prepare(`SELECT id, content, ts FROM memory_local WHERE content LIKE ? ORDER BY ts DESC LIMIT ?`).all('%' + query + '%', limit)
-            return { items: rows }
-        }
-    },
-    list: async () => {
-        const d = await init()
-        return { items: d.prepare(`SELECT id, content, ts FROM memory_local ORDER BY id DESC LIMIT 50`).all() }
-    },
-}
-
-registry.register({
-    name: 'memory',
-    toolset: 'core',
-    schema: {
-        name: 'memory',
-        description: 'Add/search/list memory. Routes to configured provider or local SQLite fallback.',
-        parameters: { type: 'object', properties: { action: { type: 'string', enum: Object.keys(ACTIONS) }, content: { type: 'string' }, query: { type: 'string' }, limit: { type: 'number' } }, required: ['action'] },
-    },
-    handler: async (args) => {
-        const fn = ACTIONS[args.action]
-        if (!fn) return { error: 'unknown action: ' + args.action }
-        return await fn(args)
-    },
-})

package/src/tools/mixture_of_agents.js

@@ -1,14 +0,0 @@
-import { registry } from './registry.js'
-import { runTurn } from '../agent/machine.js'
-
-registry.register({
-    name: 'mixture_of_agents',
-    toolset: 'core',
-    schema: { name: 'mixture_of_agents', description: 'Run the same prompt through N sub-agents (different models or seeds), then synthesize the results. Reduces variance.', parameters: { type: 'object', properties: { prompt: { type: 'string' }, models: { type: 'array', items: { type: 'string' } }, callLLM: {} }, required: ['prompt'] } },
-    handler: async ({ prompt, models = ['default'] }, ctx = {}) => {
-        const llm = ctx.callLLM || null
-        const runs = await Promise.all(models.map(m => runTurn({ prompt, model: m, callLLM: llm, timeoutMs: 30000 }).catch(e => ({ error: String(e.message || e) }))))
-        const synthesized = runs.map(r => r.result || r.error || '').join('\n---\n')
-        return { runs: runs.length, synthesized }
-    },
-})

package/src/tools/neutts_synth.js

@@ -1,13 +0,0 @@
-import { registry } from './registry.js'
-registry.register({
-    name: 'neutts_synth',
-    toolset: 'creative',
-    schema: { name: 'neutts_synth', description: 'Local NeuTTS synth (alternate TTS backend).', parameters: { type: 'object', properties: { text: { type: 'string' }, voice: { type: 'string', default: 'default' } }, required: ['text'] } },
-    requiresEnv: ['NEUTTS_URL'],
-    checkFn: () => Boolean(process.env.NEUTTS_URL),
-    handler: async ({ text, voice = 'default' }) => {
-        if (!process.env.NEUTTS_URL) return { error: 'NEUTTS_URL required' }
-        const r = await fetch(process.env.NEUTTS_URL + '/synthesize', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ text, voice }) })
-        return { status: r.status, bytes: (await r.arrayBuffer()).byteLength }
-    },
-})

package/src/tools/openrouter_client.js

@@ -1,13 +0,0 @@
-import { registry } from './registry.js'
-registry.register({
-    name: 'openrouter',
-    toolset: 'core',
-    schema: { name: 'openrouter', description: 'Chat completion via OpenRouter (any model).', parameters: { type: 'object', properties: { prompt: { type: 'string' }, model: { type: 'string', default: 'anthropic/claude-sonnet-4' } }, required: ['prompt'] } },
-    requiresEnv: ['OPENROUTER_API_KEY'],
-    checkFn: () => Boolean(process.env.OPENROUTER_API_KEY),
-    handler: async ({ prompt, model = 'anthropic/claude-sonnet-4' }) => {
-        if (!process.env.OPENROUTER_API_KEY) return { error: 'OPENROUTER_API_KEY required' }
-        const r = await fetch('https://openrouter.ai/api/v1/chat/completions', { method: 'POST', headers: { authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`, 'content-type': 'application/json' }, body: JSON.stringify({ model, messages: [{ role: 'user', content: prompt }] }) })
-        return await r.json()
-    },
-})

package/src/tools/osv_check.js

@@ -1,11 +0,0 @@
-import { registry } from './registry.js'
-registry.register({
-    name: 'osv_check',
-    toolset: 'core',
-    schema: { name: 'osv_check', description: 'Query osv.dev for known vulnerabilities. Pass either {package, version, ecosystem} or {commit_sha, repo}.', parameters: { type: 'object', properties: { package: { type: 'string' }, version: { type: 'string' }, ecosystem: { type: 'string' }, commit_sha: { type: 'string' } } } },
-    handler: async (args) => {
-        const body = args.commit_sha ? { commit: args.commit_sha } : { package: { name: args.package, ecosystem: args.ecosystem || 'npm' }, version: args.version }
-        const r = await fetch('https://api.osv.dev/v1/query', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) })
-        return await r.json()
-    },
-})

package/src/tools/patch_parser.js

@@ -1,42 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { registry } from './registry.js'
-
-export function applyUnifiedDiff(diff, { cwd = process.cwd() } = {}) {
-    const lines = diff.split('\n')
-    const results = []
-    let curFile = null, curHunks = [], curHunk = null
-    const flush = () => {
-        if (!curFile) return
-        const file = path.join(cwd, curFile)
-        if (!fs.existsSync(file)) { results.push({ file: curFile, error: 'not found' }); curFile = null; curHunks = []; return }
-        let src = fs.readFileSync(file, 'utf8').split('\n')
-        for (const h of curHunks) {
-            const before = src.slice(0, h.start)
-            const after = src.slice(h.start + h.removed)
-            src = [...before, ...h.added, ...after]
-        }
-        fs.writeFileSync(file, src.join('\n'), 'utf8')
-        results.push({ file: curFile, applied: curHunks.length })
-        curFile = null; curHunks = []
-    }
-    for (const l of lines) {
-        if (l.startsWith('--- ')) { flush(); curFile = l.slice(6).trim() }
-        else if (l.startsWith('+++ ')) {}
-        else if (l.startsWith('@@ ')) {
-            const m = l.match(/@@ -(\d+),(\d+) \+(\d+),(\d+) @@/)
-            if (m) { curHunk = { start: Number(m[1]) - 1, removed: Number(m[2]), added: [] }; curHunks.push(curHunk) }
-        } else if (curHunk) {
-            if (l.startsWith('+')) curHunk.added.push(l.slice(1))
-            else if (l.startsWith(' ')) curHunk.added.push(l.slice(1))
-        }
-    }
-    flush()
-    return results
-}
-registry.register({
-    name: 'patch_parser',
-    toolset: 'core',
-    schema: { name: 'patch_parser', description: 'Apply a unified diff to files in cwd. Returns per-file results.', parameters: { type: 'object', properties: { diff: { type: 'string' }, cwd: { type: 'string' } }, required: ['diff'] } },
-    handler: async ({ diff, cwd }) => ({ results: applyUnifiedDiff(diff, { cwd }) }),
-})

package/src/tools/path_security.js

@@ -1,16 +0,0 @@
-import path from 'node:path'
-import { registry } from './registry.js'
-
-const FORBIDDEN = ['/etc/passwd', '/etc/shadow', '/.ssh/', '/.aws/', 'C:\\Windows\\System32']
-export function isPathSafe(p, { cwd = process.cwd() } = {}) {
-    const abs = path.resolve(cwd, p)
-    for (const bad of FORBIDDEN) if (abs.includes(bad)) return { safe: false, reason: 'forbidden: ' + bad }
-    if (abs.includes('..')) return { safe: false, reason: 'parent reference in resolved path' }
-    return { safe: true, abs }
-}
-registry.register({
-    name: 'path_security',
-    toolset: 'core',
-    schema: { name: 'path_security', description: 'Check whether a path is allowed (no /etc/passwd, no .ssh/, etc).', parameters: { type: 'object', properties: { path: { type: 'string' }, cwd: { type: 'string' } }, required: ['path'] } },
-    handler: async ({ path: p, cwd }) => isPathSafe(p, { cwd }),
-})

package/src/tools/process_registry.js

@@ -1,17 +0,0 @@
-import { registry } from './registry.js'
-
-const _processes = new Map()
-export function registerProcess(id, child, meta = {}) { _processes.set(id, { id, pid: child.pid, started: Date.now(), ...meta }); child.on?.('exit', () => _processes.delete(id)) }
-export function listProcesses() { return [..._processes.values()] }
-export function killProcess(id) { const p = _processes.get(id); if (p) try { process.kill(p.pid, 'SIGTERM') } catch {} return p ? { killed: id } : { error: 'unknown id' } }
-
-registry.register({
-    name: 'process_registry',
-    toolset: 'core',
-    schema: { name: 'process_registry', description: 'List/kill spawned background processes tracked by freddie.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['list', 'kill'] }, id: { type: 'string' } }, required: ['action'] } },
-    handler: async ({ action, id }) => {
-        if (action === 'list') return { processes: listProcesses() }
-        if (action === 'kill') return killProcess(id)
-        return { error: 'unknown action' }
-    },
-})

package/src/tools/read.js

@@ -1,26 +0,0 @@
-import fs from 'node:fs'
-import { registry } from './registry.js'
-
-registry.register({
-    name: 'read',
-    toolset: 'core',
-    schema: {
-        name: 'read',
-        description: 'Read a file from disk. Returns lines with line numbers.',
-        parameters: {
-            type: 'object',
-            properties: {
-                path: { type: 'string' },
-                offset: { type: 'number', default: 0 },
-                limit: { type: 'number', default: 2000 },
-            },
-            required: ['path'],
-        },
-    },
-    handler: async ({ path: p, offset = 0, limit = 2000 }) => {
-        if (!fs.existsSync(p)) return { error: `not found: ${p}` }
-        const lines = fs.readFileSync(p, 'utf8').split('\n')
-        const slice = lines.slice(offset, offset + limit)
-        return { path: p, total: lines.length, content: slice.map((l, i) => `${(offset + i + 1).toString().padStart(6)}\t${l}`).join('\n') }
-    },
-})

package/src/tools/registry.js

@@ -1,54 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { fileURLToPath } from 'node:url'
-
-const _tools = new Map()
-let _discovered = false
-
-export const registry = {
-    register(spec) {
-        if (!spec?.name) throw new Error('tool name required')
-        _tools.set(spec.name, {
-            name: spec.name,
-            toolset: spec.toolset || 'core',
-            schema: spec.schema || { name: spec.name, description: '', parameters: { type: 'object', properties: {} } },
-            handler: spec.handler,
-            checkFn: spec.checkFn || (() => true),
-            requiresEnv: spec.requiresEnv || [],
-        })
-    },
-    list() { return [..._tools.values()] },
-    get(name) { return _tools.get(name) },
-    available() { return [..._tools.values()].filter(t => safeCheck(t)) },
-    schemas(tools) {
-        const src = tools || this.available()
-        return src.map(t => t.schema)
-    },
-    async dispatch(name, args = {}, ctx = {}) {
-        const t = _tools.get(name)
-        if (!t) return JSON.stringify({ error: `unknown tool: ${name}` })
-        if (!safeCheck(t)) return JSON.stringify({ error: `tool unavailable: ${name}`, requires: t.requiresEnv })
-        try {
-            const result = await t.handler(args, ctx)
-            return typeof result === 'string' ? result : JSON.stringify(result)
-        } catch (e) {
-            return JSON.stringify({ error: String(e?.message || e), tool: name })
-        }
-    },
-    clearForTests() { _tools.clear(); _discovered = false },
-}
-
-function safeCheck(t) {
-    try { return t.checkFn(t) !== false } catch { return false }
-}
-
-export async function discoverBuiltinTools() {
-    if (_discovered) return
-    _discovered = true
-    const here = path.dirname(fileURLToPath(import.meta.url))
-    const entries = fs.readdirSync(here).filter(f => f.endsWith('.js') && f !== 'registry.js' && f !== 'index.js')
-    for (const f of entries) {
-        const url = new URL(`./${f}`, import.meta.url).href
-        try { await import(url) } catch (e) { console.error(`tool load failed ${f}: ${e.message}`) }
-    }
-}

package/src/tools/rl_training.js

@@ -1,13 +0,0 @@
-import { registry } from './registry.js'
-registry.register({
-    name: 'rl_training',
-    toolset: 'core',
-    schema: { name: 'rl_training', description: 'Kick off an RL rollout (Atropos integration).', parameters: { type: 'object', properties: { task: { type: 'string' }, model: { type: 'string' } }, required: ['task'] } },
-    requiresEnv: ['ATROPOS_URL'],
-    checkFn: () => Boolean(process.env.ATROPOS_URL),
-    handler: async ({ task, model }) => {
-        if (!process.env.ATROPOS_URL) return { error: 'ATROPOS_URL required' }
-        const r = await fetch(process.env.ATROPOS_URL + '/rollouts', { method: 'POST', headers: { 'content-type': 'application/json', authorization: `Bearer ${process.env.ATROPOS_TOKEN || ''}` }, body: JSON.stringify({ task, model }) })
-        return await r.json()
-    },
-})

package/src/tools/schema_sanitizer.js

@@ -1,18 +0,0 @@
-import { registry } from './registry.js'
-const DANGEROUS_PARAM_NAMES = new Set(['eval', 'exec', '__proto__', 'constructor'])
-export function sanitizeSchema(schema) {
-    if (!schema || typeof schema !== 'object') return schema
-    const out = JSON.parse(JSON.stringify(schema))
-    if (out.parameters?.properties) {
-        for (const k of Object.keys(out.parameters.properties)) {
-            if (DANGEROUS_PARAM_NAMES.has(k)) delete out.parameters.properties[k]
-        }
-    }
-    return out
-}
-registry.register({
-    name: 'schema_sanitizer',
-    toolset: 'core',
-    schema: { name: 'schema_sanitizer', description: 'Strip dangerous fields (eval, exec, __proto__) from a tool schema.', parameters: { type: 'object', properties: { schema: {} }, required: ['schema'] } },
-    handler: async ({ schema }) => ({ sanitized: sanitizeSchema(schema) }),
-})

package/src/tools/send_message.js

@@ -1,32 +0,0 @@
-import { registry } from './registry.js'
-
-const PLATFORM_MODULES = {
-    telegram: '../gateway/platforms/telegram.js',
-    discord: '../gateway/platforms/discord.js',
-    slack: '../gateway/platforms/slack.js',
-    whatsapp: '../gateway/platforms/whatsapp.js',
-    email: '../gateway/platforms/email.js',
-    sms: '../gateway/platforms/sms.js',
-    matrix: '../gateway/platforms/matrix.js',
-    signal: '../gateway/platforms/signal.js',
-    mattermost: '../gateway/platforms/mattermost.js',
-}
-
-registry.register({
-    name: 'send_message',
-    toolset: 'core',
-    schema: { name: 'send_message', description: 'Send a message to a recipient on the named platform. Uses the gateway adapter; requires the platform credentials.', parameters: { type: 'object', properties: { platform: { type: 'string', enum: Object.keys(PLATFORM_MODULES) }, to: { type: 'string' }, text: { type: 'string' } }, required: ['platform', 'to', 'text'] } },
-    handler: async ({ platform, to, text }) => {
-        const mod = PLATFORM_MODULES[platform]
-        if (!mod) return { error: 'unknown platform: ' + platform }
-        const m = await import(mod)
-        const cls = Object.values(m)[0]
-        const inst = new cls({})
-        try { await inst.start() } catch (e) { return { error: String(e.message || e) } }
-        try {
-            const out = await inst.send({ to, text })
-            await inst.stop?.()
-            return { ok: true, response: out }
-        } catch (e) { await inst.stop?.(); return { error: String(e.message || e) } }
-    },
-})

package/src/tools/session_search.js

@@ -1,23 +0,0 @@
-import { search, listSessions, getMessages } from '../sessions.js'
-import { registry } from './registry.js'
-
-registry.register({
-    name: 'session_search',
-    toolset: 'core',
-    schema: { name: 'session_search', description: 'Full-text search across past session messages. Returns hits with session_id and content snippet.', parameters: { type: 'object', properties: { query: { type: 'string' }, limit: { type: 'number', default: 20 }, session_id: { type: 'string' } }, required: ['query'] } },
-    handler: async ({ query, limit = 20, session_id = null }) => {
-        if (session_id) {
-            const msgs = getMessages(session_id)
-            const q = String(query).toLowerCase()
-            return { items: msgs.filter(m => String(m.content || '').toLowerCase().includes(q)).slice(0, limit) }
-        }
-        return { items: search(query, limit) }
-    },
-})
-
-registry.register({
-    name: 'session_list',
-    toolset: 'core',
-    schema: { name: 'session_list', description: 'List recent sessions.', parameters: { type: 'object', properties: { limit: { type: 'number', default: 20 } } } },
-    handler: async ({ limit = 20 }) => ({ sessions: listSessions(limit) }),
-})

package/src/tools/skill_manager.js

@@ -1,17 +0,0 @@
-import { registry } from './registry.js'
-import { listSkills, findSkill, skillAsUserMessage } from '../skills/index.js'
-
-const ACTIONS = {
-    list: () => ({ skills: listSkills().map(s => ({ name: s.name, description: s.description, file: s.file })) }),
-    get: ({ name }) => { const s = findSkill(name); return s ? { skill: s } : { error: 'not found: ' + name } },
-    invoke: ({ name, args = '' }) => {
-        const m = skillAsUserMessage(name, args)
-        return m ? { message: m } : { error: 'not found: ' + name }
-    },
-}
-registry.register({
-    name: 'skill_manager',
-    toolset: 'core',
-    schema: { name: 'skill_manager', description: 'List, fetch, or invoke a skill from ~/.freddie/skills/ or bundled skills/.', parameters: { type: 'object', properties: { action: { type: 'string', enum: Object.keys(ACTIONS) }, name: { type: 'string' }, args: { type: 'string' } }, required: ['action'] } },
-    handler: async (a) => { const fn = ACTIONS[a.action]; return fn ? fn(a) : { error: 'unknown action' } },
-})

package/src/tools/skill_usage.js

@@ -1,20 +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 skill_usage (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, ts INTEGER NOT NULL, session_id TEXT)`)
-    return d
-}
-registry.register({
-    name: 'skill_usage',
-    toolset: 'core',
-    schema: { name: 'skill_usage', description: 'Track / query skill invocation stats.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['record', 'top', 'recent'] }, name: { type: 'string' }, session_id: { type: 'string' }, limit: { type: 'number', default: 20 } }, required: ['action'] } },
-    handler: async ({ action, name, session_id = null, limit = 20 }) => {
-        const d = await init()
-        if (action === 'record') { d.prepare(`INSERT INTO skill_usage (name, ts, session_id) VALUES (?, ?, ?)`).run(name, Date.now(), session_id); return { recorded: true } }
-        if (action === 'top') return { top: d.prepare(`SELECT name, COUNT(*) AS uses FROM skill_usage GROUP BY name ORDER BY uses DESC LIMIT ?`).all(limit) }
-        if (action === 'recent') return { recent: d.prepare(`SELECT name, ts, session_id FROM skill_usage ORDER BY id DESC LIMIT ?`).all(limit) }
-        return { error: 'unknown action' }
-    },
-})

package/src/tools/skills_guard.js

@@ -1,17 +0,0 @@
-import { registry } from './registry.js'
-import { detectSecrets } from '../agent/redact.js'
-
-const DANGEROUS = [/rm\s+-rf\s+\//, /:\(\)\s*\{\s*:\|:&\s*\};:/, /chmod\s+-R\s+777/]
-
-registry.register({
-    name: 'skills_guard',
-    toolset: 'core',
-    schema: { name: 'skills_guard', description: 'Inspect skill body for dangerous patterns (rm -rf /, fork bombs, secrets) before injection.', parameters: { type: 'object', properties: { body: { type: 'string' } }, required: ['body'] } },
-    handler: async ({ body }) => {
-        const issues = []
-        for (const re of DANGEROUS) if (re.test(body)) issues.push({ kind: 'dangerous-cmd', pattern: re.source })
-        const secrets = detectSecrets(body)
-        if (secrets.length) issues.push({ kind: 'secret', count: secrets.length })
-        return { safe: issues.length === 0, issues }
-    },
-})

package/src/tools/skills_hub.js

@@ -1,31 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { getFophHome } from '../home.js'
-import { registry } from './registry.js'
-
-const HUB_INDEX_URL = 'https://raw.githubusercontent.com/AnEntrypoint/freddie-skills/main/index.json'
-
-const ACTIONS = {
-    catalog: async () => {
-        try { const r = await fetch(HUB_INDEX_URL); if (!r.ok) return { items: [], error: 'fetch ' + r.status }; return { items: await r.json() } }
-        catch (e) { return { items: [], error: String(e.message || e) } }
-    },
-    install: async ({ name, body }) => {
-        if (!name || !body) return { error: 'name + body required' }
-        const dir = path.join(getFophHome(), 'skills', name)
-        fs.mkdirSync(dir, { recursive: true })
-        fs.writeFileSync(path.join(dir, 'SKILL.md'), body, 'utf8')
-        return { installed: dir }
-    },
-    uninstall: async ({ name }) => {
-        const dir = path.join(getFophHome(), 'skills', name)
-        if (fs.existsSync(dir)) { fs.rmSync(dir, { recursive: true, force: true }); return { uninstalled: name } }
-        return { error: 'not found' }
-    },
-}
-registry.register({
-    name: 'skills_hub',
-    toolset: 'core',
-    schema: { name: 'skills_hub', description: 'Browse and install community skills.', parameters: { type: 'object', properties: { action: { type: 'string', enum: Object.keys(ACTIONS) }, name: { type: 'string' }, body: { type: 'string' } }, required: ['action'] } },
-    handler: async (a) => { const fn = ACTIONS[a.action]; return fn ? await fn(a) : { error: 'unknown action' } },
-})

package/src/tools/skills_index.js

@@ -1,14 +0,0 @@
-import { listSkills } from '../skills/index.js'
-import { registry } from './registry.js'
-
-registry.register({
-    name: 'skills_index',
-    toolset: 'core',
-    schema: { name: 'skills_index', description: 'Build a search index of available skills (name + description + first-line of body) for the agent to query.', parameters: { type: 'object', properties: { query: { type: 'string' } } } },
-    handler: async ({ query }) => {
-        const all = listSkills().map(s => ({ name: s.name, description: s.description, hint: (s.body || '').split('\n').find(l => l.trim()) || '' }))
-        if (!query) return { items: all }
-        const q = String(query).toLowerCase()
-        return { items: all.filter(s => (s.name + ' ' + s.description + ' ' + s.hint).toLowerCase().includes(q)) }
-    },
-})

package/src/tools/skills_sync.js

@@ -1,19 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-import { getFophHome } from '../home.js'
-import { registry } from './registry.js'
-
-registry.register({
-    name: 'skills_sync',
-    toolset: 'core',
-    schema: { name: 'skills_sync', description: 'Sync ~/.freddie/skills/ with a remote git repo (clone or pull).', parameters: { type: 'object', properties: { repo: { type: 'string' } }, required: ['repo'] } },
-    handler: async ({ repo }) => {
-        const dir = path.join(getFophHome(), 'skills')
-        fs.mkdirSync(dir, { recursive: true })
-        const { spawnSync } = await import('node:child_process')
-        const exists = fs.existsSync(path.join(dir, '.git'))
-        const cmd = exists ? ['git', '-C', dir, 'pull'] : ['git', 'clone', repo, dir]
-        const r = spawnSync(cmd[0], cmd.slice(1), { encoding: 'utf8' })
-        return { exitCode: r.status, stdout: r.stdout, stderr: r.stderr }
-    },
-})

package/src/tools/skills_tool.js

@@ -1,11 +0,0 @@
-import { listSkills, findSkill, skillAsUserMessage } from '../skills/index.js'
-import { registry } from './registry.js'
-
-registry.register({
-    name: 'skill',
-    toolset: 'core',
-    schema: { name: 'skill', description: 'Run a skill by name. Returns the user-message representation that should be added to the conversation.', parameters: { type: 'object', properties: { name: { type: 'string' }, args: { type: 'string' } }, required: ['name'] } },
-    handler: async ({ name, args = '' }) => {
-        const m = skillAsUserMessage(name, args); return m ? { message: m } : { error: 'skill not found: ' + name, available: listSkills().map(s => s.name) }
-    },
-})

package/src/tools/slash_confirm.js

@@ -1,16 +0,0 @@
-import { resolveCommand, getCommand } from '../commands/registry.js'
-import { registry } from './registry.js'
-
-const DESTRUCTIVE = new Set(['reset', 'clear', 'delete'])
-
-registry.register({
-    name: 'slash_confirm',
-    toolset: 'core',
-    schema: { name: 'slash_confirm', description: 'Resolve a slash command and indicate whether it requires confirmation before running.', parameters: { type: 'object', properties: { input: { type: 'string' } }, required: ['input'] } },
-    handler: async ({ input }) => {
-        const name = resolveCommand(input)
-        if (!name) return { recognised: false, input }
-        const def = getCommand(name)
-        return { recognised: true, name, requiresConfirm: DESTRUCTIVE.has(name), description: def?.description }
-    },
-})

package/src/tools/terminal.js

@@ -1,29 +0,0 @@
-import { spawn } from 'node:child_process'
-import { registry } from './registry.js'
-
-const _sessions = new Map()
-
-registry.register({
-    name: 'terminal',
-    toolset: 'core',
-    schema: { name: 'terminal', description: 'Open a long-lived shell session, send input lines, capture output. Actions: open, send, read, close.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['open', 'send', 'read', 'close', 'list'] }, id: { type: 'string' }, input: { type: 'string' }, cwd: { type: 'string' } }, required: ['action'] } },
-    handler: async ({ action, id, input, cwd }) => {
-        if (action === 'open') {
-            const sid = 'term-' + Date.now()
-            const sh = process.platform === 'win32' ? 'cmd' : 'sh'
-            const child = spawn(sh, [], { cwd: cwd || process.cwd(), env: process.env })
-            const buf = { stdout: '', stderr: '' }
-            child.stdout?.on('data', d => buf.stdout += d.toString())
-            child.stderr?.on('data', d => buf.stderr += d.toString())
-            _sessions.set(sid, { child, buf })
-            return { id: sid, opened: true }
-        }
-        const s = _sessions.get(id)
-        if (!s) return { error: 'unknown terminal id: ' + id }
-        if (action === 'send') { s.child.stdin?.write(input + '\n'); return { sent: true } }
-        if (action === 'read') { const out = { ...s.buf }; s.buf.stdout = ''; s.buf.stderr = ''; return out }
-        if (action === 'close') { try { s.child.kill('SIGTERM') } catch {} _sessions.delete(id); return { closed: id } }
-        if (action === 'list') return { sessions: [..._sessions.keys()] }
-        return { error: 'unknown action' }
-    },
-})