freddie 0.0.41

package/src/index.js

@@ -0,0 +1,47 @@
+export * from './home.js'
+export * from './config.js'
+export * from './sessions.js'
+export * from './toolsets.js'
+export { registry, discoverBuiltinTools } from './tools/registry.js'
+export { runTurn, createAgentMachine } from './agent/machine.js'
+export { Gateway, bootMdHook } from './gateway/run.js'
+export { AcpServer } from './acp/server.js'
+export { COMMAND_REGISTRY, resolveCommand, gatewayHelpLines, telegramBotCommands, slackSubcommandMap, GATEWAY_KNOWN_COMMANDS, COMMANDS_BY_CATEGORY } from './commands/registry.js'
+export { getActiveSkin, setActiveSkin, listBuiltinSkins, loadSkin } from './skin/engine.js'
+export { pluginManager, PluginManager } from './plugins/manager.js'
+export { listSkills, findSkill, skillAsUserMessage } from './skills/index.js'
+export { log, logger } from './observability/log.js'
+export { registerDebug, snapshot, snapshotAll, listDebug, attachDebugRoutes } from './observability/debug.js'
+export { createJob, listJobs, cancelJob, deleteJob, tick as cronTick, startScheduler, stopScheduler } from './cron/scheduler.js'
+export { parseCron, matches as cronMatches } from './cron/cron-parse.js'
+export { runBatch } from './batch.js'
+export { createDashboard } from './web/server.js'
+export { createEnvironment, defaultEnvironment, LocalEnvironment, DockerEnvironment, SshEnvironment } from './tools/environments/index.js'
+export { getAuthStore } from './auth.js'
+export { buildContext, blocksToSystemMessage, ContextPlugins } from './context/engine.js'
+export { callLLM as piCallLLM } from './agent/pi-bridge.js'
+export { interactive } from './cli/interactive.js'
+export { listMemoryProviders, createMemoryProvider, registerMemoryProvider } from './plugins/memory/provider.js'
+export { compress, shouldCompress, computeCompressionPlan, SUMMARY_PREFIX, estimateMessagesTokens, pruneOldToolResults, markFailure as compressMarkFailure, shouldRetry as compressShouldRetry, clearFailure as compressClearFailure } from './agent/compress/index.js'
+export * as time from './time.js'
+export * as utils from './utils.js'
+export * as accountUsage from './agent/account_usage.js'
+export * as credentialPool from './agent/credential_pool.js'
+export * as displayAgent from './agent/display.js'
+export * as redact from './agent/redact.js'
+export * as modelMetadata from './agent/model_metadata.js'
+export * as imageRouting from './agent/image_routing.js'
+export * as skillCommands from './agent/skill_commands.js'
+export * as contextRefs from './agent/context_references.js'
+export * as trajectory from './agent/trajectory.js'
+export * as toolsetDistributions from './toolset_distributions.js'
+export { McpServer } from './mcp/server.js'
+export { runMiniSwe, loadTask as loadSweTask } from './swe/runner.js'
+export { rlSubcommand } from './rl/cli.js'
+export { AtroposClient } from './rl/atropos.js'
+export { setupWizard } from './cli/setup.js'
+export { launchCurses } from './cli/curses.js'
+export { loadToolsConfig, saveToolsConfig, setToolOverride } from './cli/tools_config.js'
+export * as cliWebServer from './cli/web_server.js'
+export { launchTui } from './tui/index.js'
+export { registerBuiltinHooks } from './gateway/builtin_hooks/index.js'

package/src/mcp/server.js

@@ -0,0 +1,49 @@
+import readline from 'node:readline'
+import { registry, discoverBuiltinTools } from '../tools/registry.js'
+import { listSkills } from '../skills/index.js'
+import { logger } from '../observability/log.js'
+
+const log = logger('mcp')
+
+const PROTOCOL_VERSION = '2024-11-05'
+
+export class McpServer {
+    constructor({ stdin = process.stdin, stdout = process.stdout } = {}) { this.in = stdin; this.out = stdout }
+    start() {
+        const rl = readline.createInterface({ input: this.in, crlfDelay: Infinity })
+        rl.on('line', (l) => this.handle(l).catch(e => this._err(null, String(e))))
+        this.rl = rl
+    }
+    stop() { this.rl?.close() }
+    _send(o) { this.out.write(JSON.stringify(o) + '\n') }
+    _ok(id, result) { this._send({ jsonrpc: '2.0', id, result }) }
+    _err(id, message) { this._send({ jsonrpc: '2.0', id, error: { code: -32603, message } }) }
+    async handle(line) {
+        if (!line.trim()) return
+        let req; try { req = JSON.parse(line) } catch { return this._err(null, 'invalid json') }
+        log.info('rpc', { method: req.method, id: req.id })
+        const fn = METHODS[req.method]
+        if (!fn) return this._err(req.id, 'unknown method: ' + req.method)
+        try { this._ok(req.id, await fn(req.params || {})) } catch (e) { this._err(req.id, String(e?.message || e)) }
+    }
+}
+const METHODS = {
+    initialize: () => ({
+        protocolVersion: PROTOCOL_VERSION,
+        capabilities: { tools: { listChanged: false }, prompts: { listChanged: false }, resources: { listChanged: false } },
+        serverInfo: { name: 'freddie-mcp', version: '0.4.0' },
+    }),
+    'tools/list': async () => {
+        await discoverBuiltinTools()
+        return { tools: registry.list().map(t => ({ name: t.name, description: t.schema.description, inputSchema: t.schema.parameters || {} })) }
+    },
+    'tools/call': async ({ name, arguments: args = {} }) => {
+        const out = await registry.dispatch(name, args)
+        return { content: [{ type: 'text', text: typeof out === 'string' ? out : JSON.stringify(out) }] }
+    },
+    'prompts/list': async () => {
+        const skills = listSkills()
+        return { prompts: skills.map(s => ({ name: s.name, description: s.description })) }
+    },
+    'resources/list': async () => ({ resources: [] }),
+}

package/src/observability/debug.js

@@ -0,0 +1,31 @@
+const _registry = new Map()
+
+export function registerDebug(name, fn) {
+    _registry.set(name, fn)
+}
+
+export function listDebug() {
+    return [...registry().keys()]
+}
+
+export function snapshot(name) {
+    const fn = _registry.get(name)
+    if (!fn) return { error: `unknown subsystem: ${name}` }
+    try { return fn() } catch (e) { return { error: String(e) } }
+}
+
+export function snapshotAll() {
+    const out = {}
+    for (const [k, fn] of _registry.entries()) {
+        try { out[k] = fn() } catch (e) { out[k] = { error: String(e) } }
+    }
+    return out
+}
+
+export function attachDebugRoutes(app) {
+    app.get('/debug', (_, res) => res.json([..._registry.keys()]))
+    app.get('/debug/:name', (req, res) => res.json(snapshot(req.params.name)))
+    app.get('/debug-all', (_, res) => res.json(snapshotAll()))
+}
+
+function registry() { return _registry }

package/src/observability/log.js

@@ -0,0 +1,38 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFophHome } from '../home.js'
+
+const SEVERITIES = { debug: 10, info: 20, warning: 30, error: 40 }
+
+let _streams = new Map()
+
+function streamFor(name) {
+    if (_streams.has(name)) return _streams.get(name)
+    const dir = path.join(getFophHome(), 'logs')
+    fs.mkdirSync(dir, { recursive: true })
+    const s = fs.createWriteStream(path.join(dir, `${name}.log`), { flags: 'a' })
+    _streams.set(name, s)
+    return s
+}
+
+export function log({ subsystem = 'app', severity = 'info', msg = '', ...rest }) {
+    const ts = new Date().toISOString()
+    const rec = { ts, subsystem, severity, msg, ...rest }
+    const line = JSON.stringify(rec) + '\n'
+    streamFor(subsystem).write(line)
+    if (SEVERITIES[severity] >= 30) streamFor('errors').write(line)
+}
+
+export function logger(subsystem) {
+    return {
+        debug: (msg, e = {}) => log({ subsystem, severity: 'debug', msg, ...e }),
+        info: (msg, e = {}) => log({ subsystem, severity: 'info', msg, ...e }),
+        warn: (msg, e = {}) => log({ subsystem, severity: 'warning', msg, ...e }),
+        error: (msg, e = {}) => log({ subsystem, severity: 'error', msg, ...e }),
+    }
+}
+
+export function closeAll() {
+    for (const s of _streams.values()) s.end()
+    _streams.clear()
+}

package/src/plugins/achievements/index.js

@@ -0,0 +1,9 @@
+import { db } from '../../db.js'
+
+async function init() { const d = await db(); await d.exec(`CREATE TABLE IF NOT EXISTS achievements (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, ts INTEGER NOT NULL, payload TEXT)`); return d }
+export async function award(name, payload = null) { await (await init()).prepare('INSERT INTO achievements (name, ts, payload) VALUES (?, ?, ?)').run(name, Date.now(), payload ? JSON.stringify(payload) : null) }
+export async function listAchievements() { return await (await init()).prepare('SELECT * FROM achievements ORDER BY id DESC LIMIT 100').all() }
+export const plugin = {
+    name: 'achievements',
+    register: (ctx) => { ctx.registerHook('onSessionStart', async (p) => { await award('session-start', { id: p.session?.id }); return p }) },
+}

package/src/plugins/cockpit/index.js

@@ -0,0 +1,8 @@
+export const plugin = {
+    name: 'cockpit',
+    register: (ctx) => {
+        if (typeof ctx.attachRoute !== 'function') return
+        ctx.attachRoute('/api/cockpit/widgets', (_, res) => res.json([{ id: 'sessions', title: 'Sessions', kind: 'list' }, { id: 'tools', title: 'Tools', kind: 'count' }, { id: 'errors', title: 'Recent errors', kind: 'log' }]))
+        ctx.attachRoute('/api/cockpit/health', (_, res) => res.json({ ok: true, ts: Date.now() }))
+    },
+}

package/src/plugins/context_engine/index.js

@@ -0,0 +1,13 @@
+import { ContextPlugins, buildContext, blocksToSystemMessage } from '../../context/engine.js'
+export const plugin = {
+    name: 'context-engine',
+    register: (ctx) => {
+        ctx.registerHook('preLlmCall', async (p) => {
+            if (!p?.message) return p
+            const blocks = await buildContext({ message: p.message, plugins: ['file', 'skills'] })
+            const sys = blocksToSystemMessage(blocks)
+            return sys ? { ...p, prepend: [sys, ...(p.prepend || [])] } : p
+        })
+    },
+}
+export { ContextPlugins, buildContext, blocksToSystemMessage }

package/src/plugins/disk_cleanup/index.js

@@ -0,0 +1,22 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFophHome } from '../../home.js'
+
+const MAX_AGE_DAYS = { logs: 30, batches: 14, 'tool-results': 7, checkpoints: 90 }
+export function cleanup({ now = Date.now() } = {}) {
+    const removed = []
+    for (const [sub, days] of Object.entries(MAX_AGE_DAYS)) {
+        const dir = path.join(getFophHome(), sub)
+        if (!fs.existsSync(dir)) continue
+        const cutoff = now - days * 86400_000
+        for (const f of fs.readdirSync(dir)) {
+            const p = path.join(dir, f)
+            try { if (fs.statSync(p).mtimeMs < cutoff) { fs.rmSync(p, { recursive: true, force: true }); removed.push(p) } } catch {}
+        }
+    }
+    return { removed: removed.length }
+}
+export const plugin = {
+    name: 'disk-cleanup',
+    register: (ctx) => { ctx.registerHook('onSessionEnd', async (p) => { cleanup(); return p }) },
+}

package/src/plugins/google_meet/index.js

@@ -0,0 +1,19 @@
+export const plugin = {
+    name: 'google-meet',
+    register: (ctx) => {
+        ctx.registerTool({
+            name: 'google_meet',
+            toolset: 'core',
+            schema: { name: 'google_meet', description: 'Schedule / list Google Meet calls.', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['list', 'schedule'] }, summary: { type: 'string' }, start: { type: 'string' }, end: { type: 'string' } }, required: ['action'] } },
+            requiresEnv: ['GOOGLE_OAUTH_TOKEN'],
+            checkFn: () => Boolean(process.env.GOOGLE_OAUTH_TOKEN),
+            handler: async ({ action, summary, start, end }) => {
+                if (!process.env.GOOGLE_OAUTH_TOKEN) return { error: 'GOOGLE_OAUTH_TOKEN required' }
+                const auth = { authorization: `Bearer ${process.env.GOOGLE_OAUTH_TOKEN}` }
+                if (action === 'list') return await (await fetch('https://www.googleapis.com/calendar/v3/calendars/primary/events?conferenceDataVersion=1', { headers: auth })).json()
+                if (action === 'schedule') return await (await fetch('https://www.googleapis.com/calendar/v3/calendars/primary/events?conferenceDataVersion=1', { method: 'POST', headers: { ...auth, 'content-type': 'application/json' }, body: JSON.stringify({ summary, start: { dateTime: start }, end: { dateTime: end }, conferenceData: { createRequest: { requestId: String(Date.now()) } } }) })).json()
+                return { error: 'unknown action' }
+            },
+        })
+    },
+}

package/src/plugins/image_gen/index.js

@@ -0,0 +1,5 @@
+import '../../tools/image_gen.js'
+export const plugin = {
+    name: 'image-gen',
+    register: () => {},
+}

package/src/plugins/manager.js

@@ -0,0 +1,66 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFophHome } from '../home.js'
+import { registry as toolRegistry } from '../tools/registry.js'
+import { logger } from '../observability/log.js'
+
+const log = logger('plugins')
+
+const HOOK_NAMES = ['preToolCall', 'postToolCall', 'preLlmCall', 'postLlmCall', 'onSessionStart', 'onSessionEnd']
+
+export class PluginManager {
+    constructor() {
+        this.plugins = []
+        this.hooks = Object.fromEntries(HOOK_NAMES.map(n => [n, []]))
+        this.cliCommands = []
+    }
+
+    async discoverPlugins(extraDirs = []) {
+        const dirs = [path.join(getFophHome(), 'plugins'), path.join(process.cwd(), '.freddie', 'plugins'), ...extraDirs]
+        for (const d of dirs) {
+            if (!fs.existsSync(d)) continue
+            for (const entry of fs.readdirSync(d, { withFileTypes: true })) {
+                if (!entry.isDirectory()) continue
+                const pkg = path.join(d, entry.name, 'package.json')
+                if (!fs.existsSync(pkg)) continue
+                try { await this._loadPlugin(path.join(d, entry.name)) } catch (e) { log.error('plugin load failed', { name: entry.name, err: String(e) }) }
+            }
+        }
+        return this.plugins.length
+    }
+
+    async _loadPlugin(dir) {
+        const pkg = JSON.parse(fs.readFileSync(path.join(dir, 'package.json'), 'utf8'))
+        const main = path.join(dir, pkg.main || 'index.js')
+        const mod = await import(`file://${main.replace(/\\/g, '/')}`)
+        const ctx = this._ctx()
+        if (typeof mod.register === 'function') await mod.register(ctx)
+        this.plugins.push({ name: pkg.name, dir, main })
+        log.info('plugin loaded', { name: pkg.name })
+    }
+
+    register(plugin) {
+        const ctx = this._ctx()
+        plugin.register?.(ctx)
+        this.plugins.push({ name: plugin.name || 'inline', ...plugin })
+    }
+
+    _ctx() {
+        const self = this
+        return {
+            registerHook: (name, fn) => { if (!HOOK_NAMES.includes(name)) throw new Error(`unknown hook: ${name}`); self.hooks[name].push(fn) },
+            registerTool: (spec) => toolRegistry.register(spec),
+            registerCliCommand: (def) => self.cliCommands.push(def),
+        }
+    }
+
+    async invoke(hook, payload) {
+        let cur = payload
+        for (const fn of this.hooks[hook] || []) {
+            try { cur = (await fn(cur)) || cur } catch (e) { log.error('hook failed', { hook, err: String(e) }) }
+        }
+        return cur
+    }
+}
+
+export const pluginManager = new PluginManager()

package/src/plugins/memory/_index.js

@@ -0,0 +1,8 @@
+export { HonchoMemory } from './honcho.js'
+export { Mem0Memory } from './mem0.js'
+export { SupermemoryMemory } from './supermemory.js'
+export { ByteroverMemory } from './byterover.js'
+export { HindsightMemory } from './hindsight.js'
+export { HolographicMemory } from './holographic.js'
+export { OpenvikingMemory } from './openviking.js'
+export { RetaindbMemory } from './retaindb.js'

package/src/plugins/memory/byterover.js

@@ -0,0 +1,25 @@
+export class ByteroverMemory {
+    constructor(opts = {}) {
+        this.name = 'byterover'
+        this.apiKey = opts.apiKey || process.env.BYTEROVER_API_KEY
+        this.base = opts.base || "https://api.byterover.com"
+        this.userId = opts.userId || 'default'
+    }
+    getRequiredEnv() { return ["BYTEROVER_API_KEY"] }
+    _headers() {
+        if (!this.apiKey) throw new Error('ByteroverMemory: BYTEROVER_API_KEY required')
+        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
+    }
+    async syncTurn(messages) {
+        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
+        return { status: res.status, ok: res.ok }
+    }
+    async prefetch(query) {
+        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
+        const res = await fetch(url, { headers: this._headers() })
+        if (!res.ok) return { items: [], status: res.status }
+        return { items: await res.json() }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/src/plugins/memory/hindsight.js

@@ -0,0 +1,25 @@
+export class HindsightMemory {
+    constructor(opts = {}) {
+        this.name = 'hindsight'
+        this.apiKey = opts.apiKey || process.env.HINDSIGHT_API_KEY
+        this.base = opts.base || "https://api.hindsightai.com"
+        this.userId = opts.userId || 'default'
+    }
+    getRequiredEnv() { return ["HINDSIGHT_API_KEY"] }
+    _headers() {
+        if (!this.apiKey) throw new Error('HindsightMemory: HINDSIGHT_API_KEY required')
+        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
+    }
+    async syncTurn(messages) {
+        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
+        return { status: res.status, ok: res.ok }
+    }
+    async prefetch(query) {
+        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
+        const res = await fetch(url, { headers: this._headers() })
+        if (!res.ok) return { items: [], status: res.status }
+        return { items: await res.json() }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/src/plugins/memory/holographic.js

@@ -0,0 +1,31 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { getFophHome } from '../../home.js'
+
+export class HolographicMemory {
+    constructor(opts = {}) {
+        this.name = 'holographic'
+        this.dir = opts.dir || path.join(getFophHome(), 'memory', 'holographic')
+        fs.mkdirSync(this.dir, { recursive: true })
+    }
+    getRequiredEnv() { return [] }
+    async syncTurn(messages) {
+        const file = path.join(this.dir, Date.now() + '.json')
+        fs.writeFileSync(file, JSON.stringify({ ts: Date.now(), messages }), 'utf8')
+        return { stored: file }
+    }
+    async prefetch(query) {
+        const files = fs.readdirSync(this.dir).filter(f => f.endsWith('.json')).sort().slice(-20)
+        const items = []
+        for (const f of files) {
+            try {
+                const data = JSON.parse(fs.readFileSync(path.join(this.dir, f), 'utf8'))
+                const last = data.messages?.slice(-2).map(m => m.content).join(' ') || ''
+                if (!query || last.toLowerCase().includes(String(query).toLowerCase())) items.push({ file: f, summary: last.slice(0, 200) })
+            } catch {}
+        }
+        return { items }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/src/plugins/memory/honcho.js

@@ -0,0 +1,25 @@
+export class HonchoMemory {
+    constructor(opts = {}) {
+        this.name = 'honcho'
+        this.apiKey = opts.apiKey || process.env.HONCHO_API_KEY
+        this.base = opts.base || "https://api.honcho.dev"
+        this.userId = opts.userId || 'default'
+    }
+    getRequiredEnv() { return ["HONCHO_API_KEY"] }
+    _headers() {
+        if (!this.apiKey) throw new Error('HonchoMemory: HONCHO_API_KEY required')
+        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
+    }
+    async syncTurn(messages) {
+        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
+        return { status: res.status, ok: res.ok }
+    }
+    async prefetch(query) {
+        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
+        const res = await fetch(url, { headers: this._headers() })
+        if (!res.ok) return { items: [], status: res.status }
+        return { items: await res.json() }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/src/plugins/memory/mem0.js

@@ -0,0 +1,25 @@
+export class Mem0Memory {
+    constructor(opts = {}) {
+        this.name = 'mem0'
+        this.apiKey = opts.apiKey || process.env.MEM0_API_KEY
+        this.base = opts.base || "https://api.mem0.ai/v1"
+        this.userId = opts.userId || 'default'
+    }
+    getRequiredEnv() { return ["MEM0_API_KEY"] }
+    _headers() {
+        if (!this.apiKey) throw new Error('Mem0Memory: MEM0_API_KEY required')
+        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
+    }
+    async syncTurn(messages) {
+        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
+        return { status: res.status, ok: res.ok }
+    }
+    async prefetch(query) {
+        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
+        const res = await fetch(url, { headers: this._headers() })
+        if (!res.ok) return { items: [], status: res.status }
+        return { items: await res.json() }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/src/plugins/memory/openviking.js

@@ -0,0 +1,25 @@
+export class OpenvikingMemory {
+    constructor(opts = {}) {
+        this.name = 'openviking'
+        this.apiKey = opts.apiKey || process.env.OPENVIKING_API_KEY
+        this.base = opts.base || "https://api.openviking.com"
+        this.userId = opts.userId || 'default'
+    }
+    getRequiredEnv() { return ["OPENVIKING_API_KEY"] }
+    _headers() {
+        if (!this.apiKey) throw new Error('OpenvikingMemory: OPENVIKING_API_KEY required')
+        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
+    }
+    async syncTurn(messages) {
+        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
+        return { status: res.status, ok: res.ok }
+    }
+    async prefetch(query) {
+        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
+        const res = await fetch(url, { headers: this._headers() })
+        if (!res.ok) return { items: [], status: res.status }
+        return { items: await res.json() }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/src/plugins/memory/provider.js

@@ -0,0 +1,35 @@
+import { HonchoMemory, Mem0Memory, SupermemoryMemory, ByteroverMemory, HindsightMemory, HolographicMemory, OpenvikingMemory, RetaindbMemory } from './_index.js'
+
+const _registered = new Map()
+
+export class MemoryProvider {
+    constructor(opts = {}) { this.opts = opts; this.name = 'base' }
+    async syncTurn(_messages) { throw new Error('syncTurn not implemented') }
+    async prefetch(_query) { throw new Error('prefetch not implemented') }
+    async shutdown() {}
+    async postSetup(_home, _config) {}
+    getRequiredEnv() { return [] }
+}
+
+export function registerMemoryProvider(name, factory) { _registered.set(name, factory) }
+export function listMemoryProviders() { return [..._registered.keys()] }
+export function createMemoryProvider(name, opts) {
+    const factory = _registered.get(name)
+    if (!factory) throw new Error(`unknown memory provider: ${name}. Available: ${[..._registered.keys()].join(',') || 'none'}`)
+    return factory(opts)
+}
+
+const PROVIDERS = {
+    honcho: HonchoMemory,
+    mem0: Mem0Memory,
+    supermemory: SupermemoryMemory,
+    byterover: ByteroverMemory,
+    hindsight: HindsightMemory,
+    holographic: HolographicMemory,
+    openviking: OpenvikingMemory,
+    retaindb: RetaindbMemory,
+}
+
+for (const [name, Cls] of Object.entries(PROVIDERS)) {
+    registerMemoryProvider(name, (opts) => new Cls(opts))
+}

package/src/plugins/memory/retaindb.js

@@ -0,0 +1,25 @@
+export class RetaindbMemory {
+    constructor(opts = {}) {
+        this.name = 'retaindb'
+        this.apiKey = opts.apiKey || process.env.RETAINDB_API_KEY
+        this.base = opts.base || "https://api.retaindb.com"
+        this.userId = opts.userId || 'default'
+    }
+    getRequiredEnv() { return ["RETAINDB_API_KEY"] }
+    _headers() {
+        if (!this.apiKey) throw new Error('RetaindbMemory: RETAINDB_API_KEY required')
+        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
+    }
+    async syncTurn(messages) {
+        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
+        return { status: res.status, ok: res.ok }
+    }
+    async prefetch(query) {
+        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
+        const res = await fetch(url, { headers: this._headers() })
+        if (!res.ok) return { items: [], status: res.status }
+        return { items: await res.json() }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/src/plugins/memory/supermemory.js

@@ -0,0 +1,25 @@
+export class SupermemoryMemory {
+    constructor(opts = {}) {
+        this.name = 'supermemory'
+        this.apiKey = opts.apiKey || process.env.SUPERMEMORY_API_KEY
+        this.base = opts.base || "https://api.supermemory.ai/v3"
+        this.userId = opts.userId || 'default'
+    }
+    getRequiredEnv() { return ["SUPERMEMORY_API_KEY"] }
+    _headers() {
+        if (!this.apiKey) throw new Error('SupermemoryMemory: SUPERMEMORY_API_KEY required')
+        return { authorization: `Bearer ${this.apiKey}`, 'content-type': 'application/json' }
+    }
+    async syncTurn(messages) {
+        const res = await fetch(`${this.base}/memories`, { method: 'POST', headers: this._headers(), body: JSON.stringify({ user_id: this.userId, messages }) })
+        return { status: res.status, ok: res.ok }
+    }
+    async prefetch(query) {
+        const url = `${this.base}/memories/search?query=${encodeURIComponent(query || '')}&user_id=${encodeURIComponent(this.userId)}`
+        const res = await fetch(url, { headers: this._headers() })
+        if (!res.ok) return { items: [], status: res.status }
+        return { items: await res.json() }
+    }
+    async shutdown() {}
+    async postSetup() {}
+}

package/src/plugins/observability/index.js

@@ -0,0 +1,18 @@
+import { listDebug, snapshotAll } from '../../observability/debug.js'
+
+const _counters = new Map()
+export function inc(name, delta = 1) { _counters.set(name, (_counters.get(name) || 0) + delta) }
+export function counters() { return Object.fromEntries(_counters) }
+export function metricsText() {
+    const lines = ['# HELP foph_counter generic counter', '# TYPE foph_counter counter']
+    for (const [name, value] of _counters) lines.push(`foph_counter{name="${name}"} ${value}`)
+    for (const sub of listDebug()) lines.push(`foph_subsystem{name="${sub}"} 1`)
+    return lines.join('\n') + '\n'
+}
+export const plugin = {
+    name: 'observability',
+    register: (ctx) => {
+        ctx.registerHook('preToolCall', async (p) => { inc('tool_calls_total'); inc(`tool_call:${p?.name || 'unknown'}`); return p })
+        if (typeof ctx.attachRoute === 'function') ctx.attachRoute('/metrics', (_, res) => { res.set('content-type', 'text/plain'); res.send(metricsText()) })
+    },
+}

package/src/plugins/platforms/index.js

@@ -0,0 +1,20 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+export async function loadAllGatewayPlatforms() {
+    const dir = path.resolve(__dirname, '../../gateway/platforms')
+    const out = []
+    for (const f of fs.readdirSync(dir).filter(f => f.endsWith('.js'))) {
+        const mod = await import('file://' + path.join(dir, f).replace(/\\/g, '/'))
+        const cls = Object.values(mod).find(v => typeof v === 'function' && /Adapter$/.test(v.name))
+        if (cls) out.push({ name: f.replace(/\.js$/, ''), cls })
+    }
+    return out
+}
+export const plugin = {
+    name: 'platforms',
+    register: () => {},
+}

package/src/plugins/spotify/index.js

@@ -0,0 +1,22 @@
+export const plugin = {
+    name: 'spotify',
+    register: (ctx) => {
+        ctx.registerTool({
+            name: 'spotify',
+            toolset: 'core',
+            schema: { name: 'spotify', description: 'Spotify playback control (Web API).', parameters: { type: 'object', properties: { action: { type: 'string', enum: ['play', 'pause', 'next', 'previous', 'search', 'queue'] }, query: { type: 'string' }, uri: { type: 'string' } }, required: ['action'] } },
+            requiresEnv: ['SPOTIFY_ACCESS_TOKEN'],
+            checkFn: () => Boolean(process.env.SPOTIFY_ACCESS_TOKEN),
+            handler: async ({ action, query, uri }) => {
+                if (!process.env.SPOTIFY_ACCESS_TOKEN) return { error: 'SPOTIFY_ACCESS_TOKEN required' }
+                const auth = { authorization: `Bearer ${process.env.SPOTIFY_ACCESS_TOKEN}` }
+                const base = 'https://api.spotify.com/v1'
+                const map = { play: ['PUT', '/me/player/play'], pause: ['PUT', '/me/player/pause'], next: ['POST', '/me/player/next'], previous: ['POST', '/me/player/previous'] }
+                if (map[action]) { const r = await fetch(base + map[action][1], { method: map[action][0], headers: auth, body: uri ? JSON.stringify({ uris: [uri] }) : null }); return { status: r.status } }
+                if (action === 'search') return await (await fetch(`${base}/search?q=${encodeURIComponent(query)}&type=track&limit=10`, { headers: auth })).json()
+                if (action === 'queue') return await (await fetch(`${base}/me/player/queue?uri=${encodeURIComponent(uri)}`, { method: 'POST', headers: auth })).json()
+                return { error: 'unknown action' }
+            },
+        })
+    },
+}