freddie 0.0.41

package/src/cli/setup.js

@@ -0,0 +1,131 @@
+import readline from 'node:readline'
+import { saveConfigValue, getConfigValue } from '../config.js'
+import { getAuthStore } from '../auth.js'
+import { listBuiltinSkins, setActiveSkin } from '../skin/engine.js'
+import { listEnvironments } from '../tools/environments/index.js'
+
+const PROVIDERS = ['anthropic', 'openai', 'groq', 'openrouter', 'xai', 'gemini', 'bedrock']
+const ENV_BY_PROVIDER = { anthropic: 'ANTHROPIC_API_KEY', openai: 'OPENAI_API_KEY', groq: 'GROQ_API_KEY', openrouter: 'OPENROUTER_API_KEY', xai: 'XAI_API_KEY', gemini: 'GEMINI_API_KEY', bedrock: 'AWS_ACCESS_KEY_ID' }
+const TTS_PROVIDERS = ['none', 'elevenlabs', 'kittentts', 'neutts', 'espeak']
+const GATEWAY_PLATFORMS = ['telegram', 'discord', 'slack', 'whatsapp', 'matrix', 'mattermost', 'signal', 'email', 'sms', 'webhook', 'feishu', 'dingtalk', 'wecom', 'weixin', 'qqbot', 'bluebubbles', 'homeassistant']
+
+function makeAsker(input, output) {
+    const rl = readline.createInterface({ input, output })
+    const ask = (q) => new Promise(r => rl.question(q, a => r(a.trim())))
+    return { ask, close: () => rl.close() }
+}
+
+export async function setupModelProvider({ input = process.stdin, output = process.stdout } = {}) {
+    const { ask, close } = makeAsker(input, output)
+    output.write('providers: ' + PROVIDERS.join(', ') + '\n')
+    const provider = (await ask('provider [anthropic]: ')) || 'anthropic'
+    if (!PROVIDERS.includes(provider)) { close(); throw new Error('unknown provider: ' + provider) }
+    saveConfigValue('agent.provider', provider)
+    const key = await ask('api key (leave blank to skip): ')
+    if (key) await getAuthStore().setCredential(ENV_BY_PROVIDER[provider], key)
+    const model = await ask('default model [empty=provider default]: ')
+    if (model) saveConfigValue('agent.model', model)
+    close()
+    return { provider, model: model || null }
+}
+
+export async function setupTerminalBackend({ input = process.stdin, output = process.stdout } = {}) {
+    const { ask, close } = makeAsker(input, output)
+    const opts = listEnvironments()
+    output.write('terminal backends: ' + opts.join(', ') + '\n')
+    const choice = (await ask('backend [local]: ')) || 'local'
+    if (!opts.includes(choice)) { close(); throw new Error('unknown backend: ' + choice) }
+    saveConfigValue('terminal.environment', choice)
+    if (choice === 'docker') {
+        const img = (await ask('docker image [ubuntu:22.04]: ')) || 'ubuntu:22.04'
+        saveConfigValue('terminal.docker_image', img)
+    } else if (choice === 'ssh') {
+        const host = await ask('ssh host: ')
+        if (host) saveConfigValue('terminal.ssh_host', host)
+    } else if (choice === 'modal' || choice === 'managed_modal') {
+        const tok = await ask('MODAL_TOKEN_ID (blank to skip): ')
+        if (tok) await getAuthStore().setCredential('MODAL_TOKEN_ID', tok)
+    } else if (choice === 'daytona') {
+        const k = await ask('DAYTONA_API_KEY (blank to skip): ')
+        if (k) await getAuthStore().setCredential('DAYTONA_API_KEY', k)
+    } else if (choice === 'vercel_sandbox') {
+        const t = await ask('VERCEL_TOKEN (blank to skip): ')
+        if (t) await getAuthStore().setCredential('VERCEL_TOKEN', t)
+    }
+    close()
+    return { backend: choice }
+}
+
+export async function setupTts({ input = process.stdin, output = process.stdout } = {}) {
+    const { ask, close } = makeAsker(input, output)
+    output.write('tts providers: ' + TTS_PROVIDERS.join(', ') + '\n')
+    const choice = (await ask('tts [none]: ')) || 'none'
+    if (!TTS_PROVIDERS.includes(choice)) { close(); throw new Error('unknown tts: ' + choice) }
+    saveConfigValue('tts.provider', choice)
+    if (choice === 'elevenlabs') {
+        const k = await ask('ELEVENLABS_API_KEY (blank to skip): ')
+        if (k) await getAuthStore().setCredential('ELEVENLABS_API_KEY', k)
+    }
+    close()
+    return { tts: choice }
+}
+
+export async function setupGatewayPlatform(name, { input = process.stdin, output = process.stdout } = {}) {
+    if (!GATEWAY_PLATFORMS.includes(name)) throw new Error('unknown platform: ' + name)
+    const { ask, close } = makeAsker(input, output)
+    const result = { platform: name }
+    const tokenEnv = {
+        telegram: 'TELEGRAM_BOT_TOKEN', discord: 'DISCORD_BOT_TOKEN', slack: 'SLACK_BOT_TOKEN', signal: 'SIGNAL_API_TOKEN',
+        matrix: 'MATRIX_ACCESS_TOKEN', mattermost: 'MATTERMOST_TOKEN', feishu: 'FEISHU_APP_SECRET', dingtalk: 'DINGTALK_APP_SECRET',
+        wecom: 'WECOM_APP_SECRET', weixin: 'WEIXIN_APP_SECRET', qqbot: 'QQ_BOT_TOKEN', bluebubbles: 'BLUEBUBBLES_PASSWORD',
+        whatsapp: 'WHATSAPP_TOKEN', email: 'IMAP_PASSWORD', sms: 'TWILIO_AUTH_TOKEN', homeassistant: 'HASS_TOKEN',
+    }[name]
+    if (tokenEnv) {
+        const v = await ask(tokenEnv + ' (blank to skip): ')
+        if (v) { await getAuthStore().setCredential(tokenEnv, v); result.tokenSaved = true }
+    }
+    saveConfigValue('gateway.platforms.' + name + '.enabled', true)
+    close()
+    return result
+}
+
+export async function setupAgentSettings({ input = process.stdin, output = process.stdout } = {}) {
+    const { ask, close } = makeAsker(input, output)
+    const maxIter = parseInt((await ask('max iterations [90]: ')) || '90', 10)
+    saveConfigValue('agent.max_iterations', maxIter)
+    const compress = ((await ask('enable compression [y]: ')) || 'y').toLowerCase() === 'y'
+    saveConfigValue('agent.compression.enabled', compress)
+    close()
+    return { max_iterations: maxIter, compression: compress }
+}
+
+export async function setupSkin({ input = process.stdin, output = process.stdout } = {}) {
+    const { ask, close } = makeAsker(input, output)
+    output.write('skins: ' + listBuiltinSkins().join(', ') + '\n')
+    const skin = (await ask('skin [default]: ')) || 'default'
+    setActiveSkin(skin)
+    saveConfigValue('display.skin', skin)
+    close()
+    return { skin }
+}
+
+export async function setupWizard({ input = process.stdin, output = process.stdout } = {}) {
+    output.write('freddie setup wizard\n')
+    const provider = await setupModelProvider({ input, output })
+    const backend = await setupTerminalBackend({ input, output })
+    const tts = await setupTts({ input, output })
+    const agent = await setupAgentSettings({ input, output })
+    const skin = await setupSkin({ input, output })
+    return { ...provider, ...backend, ...tts, ...agent, ...skin }
+}
+
+export function getSetupStatus() {
+    return {
+        provider: getConfigValue('agent.provider'),
+        terminal: getConfigValue('terminal.environment', 'local'),
+        tts: getConfigValue('tts.provider', 'none'),
+        skin: getConfigValue('display.skin', 'default'),
+    }
+}
+
+export { PROVIDERS, TTS_PROVIDERS, GATEWAY_PLATFORMS }

package/src/cli/skills_config.js

@@ -0,0 +1,6 @@
+import { getConfigValue, saveConfigValue } from '../config.js'
+export function getSkillsConfig() { return getConfigValue('skills.config', {}) || {} }
+export function setSkillConfig(name, opts) { const cfg = getSkillsConfig(); cfg[name] = { ...(cfg[name] || {}), ...opts }; saveConfigValue('skills.config', cfg); return cfg[name] }
+export function disableSkill(name) { return setSkillConfig(name, { disabled: true }) }
+export function enableSkill(name) { const cfg = getSkillsConfig(); delete cfg[name]?.disabled; saveConfigValue('skills.config', cfg); return cfg[name] }
+export function isSkillEnabled(name) { return !getSkillsConfig()[name]?.disabled }

package/src/cli/skills_hub.js

@@ -0,0 +1,8 @@
+const HUB_INDEX = 'https://raw.githubusercontent.com/AnEntrypoint/freddie-skills/main/index.json'
+export async function fetchHub() { try { const r = await fetch(HUB_INDEX); return r.ok ? await r.json() : { items: [], error: 'fetch ' + r.status } } catch (e) { return { items: [], error: String(e.message || e) } } }
+export async function searchHub(query) {
+    const data = await fetchHub()
+    if (data.error) return data
+    const q = String(query || '').toLowerCase()
+    return { items: (data.items || data || []).filter(i => !q || (i.name + ' ' + (i.description || '')).toLowerCase().includes(q)) }
+}

package/src/cli/slack_cli.js

@@ -0,0 +1,17 @@
+import { listAll as listProfiles } from './profiles_cli.js'
+import { getConfigValue, saveConfigValue } from '../config.js'
+export const SLACK_SUBCOMMANDS = ['login', 'channels', 'send', 'config']
+export async function slackChannels() {
+    const token = process.env.SLACK_BOT_TOKEN
+    if (!token) return { error: 'SLACK_BOT_TOKEN required' }
+    const r = await fetch('https://slack.com/api/conversations.list', { headers: { authorization: 'Bearer ' + token } })
+    return await r.json()
+}
+export async function slackSend({ channel, text }) {
+    const token = process.env.SLACK_BOT_TOKEN
+    if (!token) return { error: 'SLACK_BOT_TOKEN required' }
+    const r = await fetch('https://slack.com/api/chat.postMessage', { method: 'POST', headers: { authorization: 'Bearer ' + token, 'content-type': 'application/json' }, body: JSON.stringify({ channel, text }) })
+    return await r.json()
+}
+export function slackConfig() { return { profile: listProfiles().active, gateway_enabled: getConfigValue('gateway.platforms.slack.enabled') } }
+export function setSlackEnabled(enabled) { saveConfigValue('gateway.platforms.slack.enabled', Boolean(enabled)); return { enabled: Boolean(enabled) } }

package/src/cli/status.js

@@ -0,0 +1,10 @@
+import { activeRuntime } from './runtime_provider.js'
+import { activeProfile, listAll as listProfiles } from './profiles_cli.js'
+import { getActiveSkin } from '../skin/engine.js'
+import { listSessions } from '../sessions.js'
+import { totalLifetime } from '../agent/account_usage.js'
+import { runDoctor } from './doctor.js'
+export async function systemStatus() {
+    const rt = await activeRuntime()
+    return { runtime: rt, profile: activeProfile(), skin: getActiveSkin().name, sessions: listSessions(5).length, lifetimeUsage: totalLifetime(), doctor: runDoctor().filter(c => !c.ok) }
+}

package/src/cli/timeouts.js

@@ -0,0 +1,5 @@
+import { getConfigValue, saveConfigValue } from '../config.js'
+export const DEFAULTS = { agent_turn_ms: 60_000, tool_call_ms: 30_000, llm_call_ms: 90_000, batch_item_ms: 60_000, gateway_inbound_ms: 5_000 }
+export function getTimeout(key) { return getConfigValue('timeouts.' + key, DEFAULTS[key] ?? 30_000) }
+export function setTimeout_(key, ms) { saveConfigValue('timeouts.' + key, Number(ms)); return { key, ms: Number(ms) } }
+export function listTimeouts() { return Object.fromEntries(Object.keys(DEFAULTS).map(k => [k, getTimeout(k)])) }

package/src/cli/tips.js

@@ -0,0 +1,14 @@
+export const TIPS = [
+    'Use /skill <name> to inject a skill body as a user message — preserves prompt cache.',
+    'Profiles isolate state: freddie profile create <name>; FREDDIE_PROFILE=<name> freddie ...',
+    'freddie doctor checks env, deps, config — run when something feels off.',
+    'freddie dump exports your config + sessions to JSON for backup.',
+    'Set FREDDIE_DEBUG=1 to see verbose logs.',
+    'freddie dashboard runs a webjsx UI on a local port.',
+    '/cron add "*/15 * * * *" "your prompt" schedules a recurring run.',
+    'freddie batch <file.txt> runs many prompts in parallel.',
+    'Skin not for you? freddie skin ares|mono|slate.',
+    'Memory provider: freddie memory-setup.',
+]
+export function randomTip() { return TIPS[Math.floor(Math.random() * TIPS.length)] }
+export function listTips() { return TIPS }

package/src/cli/tools_config.js

@@ -0,0 +1,15 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFophHome } from '../home.js'
+
+function file() { return path.join(getFophHome(), 'tools_config.json') }
+export function loadToolsConfig() { try { return JSON.parse(fs.readFileSync(file(), 'utf8')) } catch { return {} } }
+export function saveToolsConfig(cfg) { fs.writeFileSync(file(), JSON.stringify(cfg, null, 2), 'utf8') }
+export function setToolOverride(toolName, override) {
+    const cfg = loadToolsConfig()
+    cfg[toolName] = { ...(cfg[toolName] || {}), ...override }
+    saveToolsConfig(cfg)
+    return cfg[toolName]
+}
+export function getToolOverride(toolName) { return loadToolsConfig()[toolName] || null }
+export function clearToolOverride(toolName) { const cfg = loadToolsConfig(); delete cfg[toolName]; saveToolsConfig(cfg); return true }

package/src/cli/uninstall.js

@@ -0,0 +1,8 @@
+import fs from 'node:fs'
+import { getFophHome } from '../home.js'
+export function uninstall({ keepData = true } = {}) {
+    const home = getFophHome()
+    const removed = []
+    if (!keepData && fs.existsSync(home)) { fs.rmSync(home, { recursive: true, force: true }); removed.push(home) }
+    return { removed, keepData, hint: 'npm uninstall -g freddie (or remove your local checkout)' }
+}

package/src/cli/vercel_auth.js

@@ -0,0 +1,13 @@
+import { getAuthStore } from '../auth.js'
+const KEY = 'VERCEL_TOKEN'
+export async function getVercelToken() {
+    if (process.env.VERCEL_TOKEN) return { source: 'env', value: process.env.VERCEL_TOKEN }
+    const s = await getAuthStore().getCredential(KEY)
+    return s?.value ? { source: 'auth-store', value: s.value } : { source: 'none', value: null }
+}
+export async function setVercelToken(t) { return await getAuthStore().setCredential(KEY, t) }
+export async function listVercelProjects() {
+    const t = (await getVercelToken()).value
+    if (!t) return { error: 'VERCEL_TOKEN required' }
+    return await (await fetch('https://api.vercel.com/v9/projects', { headers: { authorization: 'Bearer ' + t } })).json()
+}

package/src/cli/voice.js

@@ -0,0 +1,6 @@
+import { getConfigValue, saveConfigValue } from '../config.js'
+export function voiceState() { return Boolean(getConfigValue('voice.enabled')) }
+export function enable() { saveConfigValue('voice.enabled', true); return { enabled: true } }
+export function disable() { saveConfigValue('voice.enabled', false); return { enabled: false } }
+export function setBackend(name) { saveConfigValue('voice.backend', name); return { backend: name } }
+export function getBackend() { return getConfigValue('voice.backend', 'openai') }

package/src/cli/web_server.js

@@ -0,0 +1,13 @@
+import { createDashboard } from '../web/server.js'
+import { getConfigValue } from '../config.js'
+
+let _dashboard = null
+
+export async function start({ port = null } = {}) {
+    if (_dashboard) return _dashboard
+    const p = port || getConfigValue('web.port', 0)
+    _dashboard = await createDashboard({ port: Number(p) })
+    return _dashboard
+}
+export async function stop() { if (_dashboard) { await _dashboard.stop(); _dashboard = null } }
+export function status() { return _dashboard ? { running: true, url: _dashboard.url, port: _dashboard.port } : { running: false } }

package/src/cli/webhook.js

@@ -0,0 +1,12 @@
+import express from 'express'
+let _server = null
+const _routes = new Map()
+export async function startWebhookListener({ port = 0, path = '/webhook' } = {}) {
+    if (_server) return _server
+    const app = express(); app.use(express.json())
+    app.post(path, (req, res) => { for (const fn of _routes.values()) try { fn(req.body) } catch {} res.json({ ok: true }) })
+    _server = await new Promise(r => { const s = app.listen(port, () => r(s)) })
+    return { port: _server.address().port, path }
+}
+export function onWebhook(name, fn) { _routes.set(name, fn); return () => _routes.delete(name) }
+export async function stopWebhookListener() { if (_server) await new Promise(r => _server.close(() => r())); _server = null; _routes.clear() }

package/src/commands/profile.js

@@ -0,0 +1,72 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getProfilesRoot, listProfiles, applyProfileOverride } from '../home.js'
+
+export function createProfile(name) {
+    if (!/^[a-zA-Z0-9_-]+$/.test(name)) throw new Error('profile name must match [a-zA-Z0-9_-]+')
+    const p = path.join(getProfilesRoot(), name)
+    if (fs.existsSync(p)) throw new Error(`profile exists: ${name}`)
+    fs.mkdirSync(p, { recursive: true })
+    return p
+}
+
+export function deleteProfile(name) {
+    const p = path.join(getProfilesRoot(), name)
+    if (!fs.existsSync(p)) throw new Error(`profile not found: ${name}`)
+    fs.rmSync(p, { recursive: true, force: true })
+    return name
+}
+
+export function switchProfile(name) {
+    if (name && name !== 'default') {
+        const p = path.join(getProfilesRoot(), name)
+        if (!fs.existsSync(p)) throw new Error(`profile not found: ${name}`)
+    }
+    applyProfileOverride(name)
+    return name || 'default'
+}
+
+export function listAllProfiles() { return ['default', ...listProfiles()] }
+
+export function renameProfile(from, to) {
+    if (!/^[a-zA-Z0-9_-]+$/.test(to)) throw new Error('profile name must match [a-zA-Z0-9_-]+')
+    const src = path.join(getProfilesRoot(), from)
+    const dst = path.join(getProfilesRoot(), to)
+    if (!fs.existsSync(src)) throw new Error('profile not found: ' + from)
+    if (fs.existsSync(dst)) throw new Error('profile exists: ' + to)
+    fs.renameSync(src, dst)
+    return to
+}
+
+const IGNORE = new Set(['logs', 'sessions.db', 'sessions.db-wal', 'sessions.db-shm', '.lock'])
+
+function copyFiltered(src, dst) {
+    fs.mkdirSync(dst, { recursive: true })
+    for (const ent of fs.readdirSync(src, { withFileTypes: true })) {
+        if (IGNORE.has(ent.name)) continue
+        const a = path.join(src, ent.name), b = path.join(dst, ent.name)
+        if (ent.isDirectory()) copyFiltered(a, b)
+        else if (ent.isFile()) fs.copyFileSync(a, b)
+    }
+}
+
+export function exportProfile(name, outDir) {
+    const src = path.join(getProfilesRoot(), name)
+    if (!fs.existsSync(src)) throw new Error('profile not found: ' + name)
+    const out = path.join(outDir, name + '-profile')
+    copyFiltered(src, out)
+    fs.writeFileSync(path.join(out, 'freddie-profile.json'), JSON.stringify({ name, exported: new Date().toISOString(), version: 1 }, null, 2))
+    return out
+}
+
+export function importProfile(srcDir, name) {
+    const meta = path.join(srcDir, 'freddie-profile.json')
+    if (!fs.existsSync(meta)) throw new Error('not a freddie profile export: missing freddie-profile.json')
+    const target = name || JSON.parse(fs.readFileSync(meta, 'utf8')).name
+    if (!/^[a-zA-Z0-9_-]+$/.test(target)) throw new Error('invalid profile name: ' + target)
+    const dst = path.join(getProfilesRoot(), target)
+    if (fs.existsSync(dst)) throw new Error('profile exists: ' + target)
+    copyFiltered(srcDir, dst)
+    fs.unlinkSync(path.join(dst, 'freddie-profile.json'))
+    return target
+}

package/src/commands/registry.js

@@ -0,0 +1,94 @@
+export const COMMAND_REGISTRY = [
+    cmd('help', 'Show available commands', 'Info', { aliases: ['h', '?'] }),
+    cmd('quit', 'Exit freddie', 'Exit', { aliases: ['exit', 'q'] }),
+    cmd('clear', 'Clear conversation history', 'Session', { aliases: ['cls'] }),
+    cmd('resume', 'Resume a previous session', 'Session', { args_hint: '[session-id]' }),
+    cmd('sessions', 'List recent sessions', 'Session'),
+    cmd('search', 'Search messages full-text', 'Session', { args_hint: '<query>' }),
+    cmd('background', 'Run command in background', 'Session', { aliases: ['bg'], args_hint: '<prompt>' }),
+    cmd('model', 'Set or show current model', 'Configuration', { args_hint: '[model]' }),
+    cmd('provider', 'Set or show current provider', 'Configuration', { args_hint: '[provider]' }),
+    cmd('toolsets', 'List or toggle toolsets', 'Tools & Skills'),
+    cmd('tools', 'List available tools', 'Tools & Skills'),
+    cmd('skills', 'Skills hub: install, list, run', 'Tools & Skills'),
+    cmd('skill', 'Run a skill by name', 'Tools & Skills', { args_hint: '<name>' }),
+    cmd('memory', 'Memory provider commands', 'Configuration'),
+    cmd('skin', 'Switch CLI skin', 'Configuration', { args_hint: '[name]' }),
+    cmd('profile', 'Manage profiles', 'Configuration', { args_hint: '<list|create|switch|delete>' }),
+    cmd('logs', 'Tail logs', 'Info'),
+    cmd('config', 'Show/set config values', 'Configuration', { args_hint: '[key] [value]' }),
+    cmd('status', 'Agent + gateway status', 'Info'),
+    cmd('copy', 'Copy last response', 'Session', { cli_only: true }),
+    cmd('paste', 'Paste from clipboard', 'Session', { cli_only: true }),
+    cmd('reset', 'Reset session state', 'Session'),
+]
+
+function cmd(name, description, category, opts = {}) {
+    return {
+        name, description, category,
+        aliases: opts.aliases || [],
+        args_hint: opts.args_hint || '',
+        cli_only: !!opts.cli_only,
+        gateway_only: !!opts.gateway_only,
+        gateway_config_gate: opts.gateway_config_gate || null,
+    }
+}
+
+const _alias = new Map()
+for (const c of COMMAND_REGISTRY) {
+    _alias.set(c.name, c.name)
+    for (const a of c.aliases) _alias.set(a, c.name)
+}
+
+export function resolveCommand(input) {
+    if (!input) return null
+    const stripped = input.replace(/^\//, '').split(/\s+/)[0]
+    return _alias.get(stripped) || null
+}
+
+export function getCommand(name) {
+    return COMMAND_REGISTRY.find(c => c.name === name) || null
+}
+
+export const GATEWAY_KNOWN_COMMANDS = new Set(
+    COMMAND_REGISTRY.filter(c => !c.cli_only || c.gateway_config_gate).map(c => c.name)
+)
+
+export function gatewayHelpLines() {
+    return COMMAND_REGISTRY.filter(c => !c.cli_only || c.gateway_config_gate)
+        .map(c => `/${c.name}${c.args_hint ? ' ' + c.args_hint : ''} — ${c.description}`)
+}
+
+export function telegramBotCommands() {
+    return COMMAND_REGISTRY.filter(c => !c.cli_only).map(c => ({ command: c.name, description: c.description }))
+}
+
+export function slackSubcommandMap() {
+    const out = {}
+    for (const c of COMMAND_REGISTRY) if (!c.cli_only) out[c.name] = c.description
+    return out
+}
+
+export function slackAppManifest({ appName = 'freddie', botUserName = 'freddie' } = {}) {
+    return {
+        display_information: { name: appName, description: 'Freddie agent', background_color: '#1a1a1a' },
+        features: {
+            bot_user: { display_name: botUserName, always_online: true },
+            slash_commands: [{ command: '/' + appName, description: 'Talk to ' + appName, usage_hint: '<message or /command>', should_escape: false }],
+        },
+        oauth_config: { scopes: { bot: ['app_mentions:read', 'chat:write', 'commands', 'im:history', 'im:read', 'im:write', 'users:read'] } },
+        settings: { event_subscriptions: { bot_events: ['app_mention', 'message.im'] }, interactivity: { is_enabled: true }, org_deploy_enabled: false, socket_mode_enabled: true },
+    }
+}
+
+export function discordSkillCommands() {
+    return COMMAND_REGISTRY.filter(c => !c.cli_only && c.category !== 'Exit').map(c => ({ name: c.name, description: c.description.slice(0, 100) || c.name }))
+}
+
+export const COMMANDS = Object.fromEntries(
+    COMMAND_REGISTRY.flatMap(c => [[c.name, c], ...c.aliases.map(a => [a, c])])
+)
+
+export const COMMANDS_BY_CATEGORY = COMMAND_REGISTRY.reduce((acc, c) => {
+    (acc[c.category] = acc[c.category] || []).push(c); return acc
+}, {})

package/src/config.js

@@ -0,0 +1,125 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import yaml from 'js-yaml'
+import { getFophHome } from './home.js'
+
+export const DEFAULT_CONFIG = {
+    _config_version: 1,
+    display: { skin: 'default', tool_progress_command: false, background_process_notifications: 'all' },
+    agent: { provider: 'anthropic', model: '', max_iterations: 90, fallback_model: null, save_trajectories: false },
+    memory: { provider: null },
+    skills: { config: {} },
+    terminal: { cwd: null },
+    gateway: { timeout: 60, platforms: {} },
+    plugins: { enabled: [] },
+    toolsets: { enabled: ['core'], disabled: [] },
+}
+
+const MIGRATIONS = {
+    1: cfg => cfg,
+}
+
+export function configPath() { return path.join(getFophHome(), 'config.yaml') }
+
+export function loadConfig() {
+    const p = configPath()
+    if (!fs.existsSync(p)) return clone(DEFAULT_CONFIG)
+    const raw = yaml.load(fs.readFileSync(p, 'utf8')) || {}
+    const merged = deepMerge(clone(DEFAULT_CONFIG), raw)
+    return migrate(merged)
+}
+
+export function saveConfig(cfg) {
+    fs.mkdirSync(path.dirname(configPath()), { recursive: true })
+    fs.writeFileSync(configPath(), yaml.dump(cfg, { lineWidth: 100 }), 'utf8')
+}
+
+export function saveConfigValue(dotpath, value) {
+    const cfg = loadConfig()
+    setDot(cfg, dotpath, value)
+    saveConfig(cfg)
+    return cfg
+}
+
+export function getConfigValue(dotpath, fallback = undefined) {
+    const cfg = loadConfig()
+    return getDot(cfg, dotpath, fallback)
+}
+
+function setDot(obj, dotpath, value) {
+    const keys = dotpath.split('.')
+    let cur = obj
+    for (let i = 0; i < keys.length - 1; i++) {
+        if (typeof cur[keys[i]] !== 'object' || cur[keys[i]] === null) cur[keys[i]] = {}
+        cur = cur[keys[i]]
+    }
+    cur[keys[keys.length - 1]] = value
+}
+
+function getDot(obj, dotpath, fallback) {
+    return dotpath.split('.').reduce((c, k) => (c && k in c) ? c[k] : undefined, obj) ?? fallback
+}
+
+function deepMerge(target, src) {
+    if (!src || typeof src !== 'object') return target
+    for (const k of Object.keys(src)) {
+        if (src[k] && typeof src[k] === 'object' && !Array.isArray(src[k]) && target[k] && typeof target[k] === 'object' && !Array.isArray(target[k])) {
+            deepMerge(target[k], src[k])
+        } else {
+            target[k] = src[k]
+        }
+    }
+    return target
+}
+
+function migrate(cfg) {
+    const cur = cfg._config_version || 0
+    const target = DEFAULT_CONFIG._config_version
+    let work = cfg
+    for (let v = cur + 1; v <= target; v++) if (MIGRATIONS[v]) work = MIGRATIONS[v](work)
+    work._config_version = target
+    return work
+}
+
+function clone(o) { return JSON.parse(JSON.stringify(o)) }
+
+export function validateConfigStructure(cfg) {
+    const issues = []
+    if (!cfg || typeof cfg !== 'object') return [{ path: '', message: 'config must be an object' }]
+    for (const [k, v] of Object.entries(DEFAULT_CONFIG)) {
+        if (!(k in cfg)) issues.push({ path: k, severity: 'info', message: 'missing key (will use default)' })
+        else if (typeof v === 'object' && !Array.isArray(v) && (typeof cfg[k] !== 'object' || Array.isArray(cfg[k]))) {
+            issues.push({ path: k, severity: 'warn', message: 'expected object, got ' + (Array.isArray(cfg[k]) ? 'array' : typeof cfg[k]) })
+        }
+    }
+    if (cfg.agent && typeof cfg.agent.max_iterations !== 'undefined' && (typeof cfg.agent.max_iterations !== 'number' || cfg.agent.max_iterations < 1)) {
+        issues.push({ path: 'agent.max_iterations', severity: 'error', message: 'must be a positive integer' })
+    }
+    if (cfg.toolsets && cfg.toolsets.enabled && !Array.isArray(cfg.toolsets.enabled)) {
+        issues.push({ path: 'toolsets.enabled', severity: 'error', message: 'must be an array' })
+    }
+    return issues
+}
+
+export function expandEnvVars(value) {
+    if (typeof value === 'string') return value.replace(/\$\{([A-Z_][A-Z0-9_]*)\}/g, (_, name) => process.env[name] || '')
+    if (Array.isArray(value)) return value.map(expandEnvVars)
+    if (value && typeof value === 'object') { const out = {}; for (const [k, v] of Object.entries(value)) out[k] = expandEnvVars(v); return out }
+    return value
+}
+
+export function readRawConfig() {
+    const p = configPath()
+    return fs.existsSync(p) ? (yaml.load(fs.readFileSync(p, 'utf8')) || {}) : {}
+}
+
+export function checkConfigVersion() {
+    const raw = readRawConfig()
+    return { current: raw._config_version || 0, target: DEFAULT_CONFIG._config_version, needsMigration: (raw._config_version || 0) < DEFAULT_CONFIG._config_version }
+}
+
+export function getMissingConfigFields(cfg = loadConfig()) {
+    const missing = []
+    if (!cfg.agent?.provider) missing.push('agent.provider')
+    return missing
+}

package/src/context/engine.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { listSkills } from '../skills/index.js'
+
+export const ContextPlugins = {
+    file: async ({ cwd = process.cwd() } = {}) => {
+        const candidates = ['.freddie-context', 'CLAUDE.md', 'AGENTS.md']
+        const blocks = []
+        for (const c of candidates) {
+            const p = path.join(cwd, c)
+            if (fs.existsSync(p)) blocks.push({ name: 'file:' + c, body: fs.readFileSync(p, 'utf8') })
+        }
+        return blocks
+    },
+    skills: async () => {
+        return listSkills().map(s => ({ name: 'skill:' + s.name, body: s.description }))
+    },
+    memory: async ({ provider } = {}) => {
+        if (!provider) return []
+        try {
+            const out = await provider.prefetch('')
+            return (out.items || []).slice(0, 5).map((it, i) => ({ name: 'memory:' + i, body: typeof it === 'string' ? it : JSON.stringify(it) }))
+        } catch { return [] }
+    },
+}
+
+export async function buildContext({ session = null, message = '', plugins = ['file'], options = {} } = {}) {
+    const blocks = []
+    for (const name of plugins) {
+        const p = ContextPlugins[name]
+        if (!p) continue
+        const got = await p({ session, message, ...options })
+        for (const b of got) blocks.push(b)
+    }
+    return blocks
+}
+
+export function blocksToSystemMessage(blocks) {
+    if (!blocks.length) return null
+    const body = blocks.map(b => `[${b.name}]\n${b.body}`).join('\n\n')
+    return { role: 'system', content: body }
+}

package/src/cron/cron-parse.js

@@ -0,0 +1,27 @@
+const RANGES = [[0, 59], [0, 23], [1, 31], [1, 12], [0, 6]]
+
+export function parseCron(expr) {
+    const parts = expr.trim().split(/\s+/)
+    if (parts.length !== 5) throw new Error(`cron must have 5 fields: ${expr}`)
+    return parts.map((p, i) => parseField(p, RANGES[i][0], RANGES[i][1]))
+}
+
+function parseField(p, lo, hi) {
+    const out = new Set()
+    for (const piece of p.split(',')) {
+        let step = 1, range = piece
+        if (piece.includes('/')) { const [r, s] = piece.split('/'); range = r; step = Number(s) }
+        let from = lo, to = hi
+        if (range !== '*') {
+            if (range.includes('-')) { const [a, b] = range.split('-'); from = Number(a); to = Number(b) }
+            else { from = to = Number(range) }
+        }
+        for (let v = from; v <= to; v += step) out.add(v)
+    }
+    return out
+}
+
+export function matches(parsed, date) {
+    const fields = [date.getMinutes(), date.getHours(), date.getDate(), date.getMonth() + 1, date.getDay()]
+    return parsed.every((set, i) => set.has(fields[i]))
+}