openbot 0.2.12 → 0.2.13

package/dist/registry/plugin-loader.js

@@ -1,499 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { pathToFileURL } from "node:url";
-import { execSync } from "node:child_process";
-import matter from "gray-matter";
-import { z } from "zod";
-import { PluginRegistry } from "./plugin-registry.js";
-import { llmPlugin } from "../plugins/llm/index.js";
-import { createModel } from "../models.js";
-import { resolvePath, DEFAULT_AGENT_MD } from "../config.js";
-// ── Helpers ──────────────────────────────────────────────────────────
-function toTitleCaseFromSlug(value) {
-    return value
-        .split(/[-_]+/)
-        .filter(Boolean)
-        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-        .join(" ") || "Agent";
-}
-async function fileExists(filePath) {
-    return fs.access(filePath).then(() => true).catch(() => false);
-}
-async function findIndexFile(dir) {
-    for (const file of ["dist/index.js", "index.js", "index.ts"]) {
-        if (await fileExists(path.join(dir, file))) {
-            return path.join(dir, file);
-        }
-    }
-    return undefined;
-}
-function resolveConfigPaths(config) {
-    if (typeof config === "string")
-        return resolvePath(config);
-    if (Array.isArray(config))
-        return config.map(resolveConfigPaths);
-    if (config !== null && typeof config === "object") {
-        const resolved = {};
-        for (const [key, value] of Object.entries(config)) {
-            resolved[key] = resolveConfigPaths(value);
-        }
-        return resolved;
-    }
-    return config;
-}
-// ── Metadata ─────────────────────────────────────────────────────────
-export async function getPluginMetadata(pluginDir) {
-    const pkgPath = path.join(pluginDir, "package.json");
-    const hasPackageJson = await fileExists(pkgPath);
-    let name = "Unnamed Plugin";
-    let description = "No description";
-    let version = "0.0.0";
-    if (hasPackageJson) {
-        try {
-            const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
-            name = (pkg.name?.split("/").pop()) || name;
-            description = pkg.description || description;
-            version = pkg.version || version;
-        }
-        catch { /* fallback to defaults */ }
-    }
-    return { name, description, version };
-}
-export async function ensurePluginReady(pluginDir) {
-    try {
-        const pkgPath = path.join(pluginDir, "package.json");
-        if (!(await fileExists(pkgPath)))
-            return;
-        const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
-        const nodeModulesPath = path.join(pluginDir, "node_modules");
-        if (!(await fileExists(nodeModulesPath))) {
-            console.log(`[plugins] Installing dependencies for ${path.basename(pluginDir)}...`);
-            execSync("npm install", { cwd: pluginDir, stdio: "inherit" });
-        }
-        const distPath = path.join(pluginDir, "dist");
-        if (!(await fileExists(distPath)) && pkg.scripts?.build) {
-            console.log(`[plugins] Building ${path.basename(pluginDir)}...`);
-            execSync("npm run build", { cwd: pluginDir, stdio: "inherit" });
-        }
-    }
-    catch (err) {
-        console.error(`[plugins] Failed to prepare plugin in ${pluginDir}:`, err);
-    }
-}
-// ── AGENT.md Config ──────────────────────────────────────────────────
-function jsonToZod(schema) {
-    if (typeof schema === "string") {
-        if (schema === "string")
-            return z.string();
-        if (schema === "number")
-            return z.number();
-        if (schema === "boolean")
-            return z.boolean();
-    }
-    if (Array.isArray(schema)) {
-        // If it's a simple array like ["string"], take the first item
-        if (schema.length === 1)
-            return z.array(jsonToZod(schema[0]));
-        // For anything else, treat as array of any (or you could improve this)
-        return z.array(z.any());
-    }
-    if (typeof schema === "object" && schema !== null) {
-        const shape = {};
-        for (const [key, value] of Object.entries(schema)) {
-            shape[key] = jsonToZod(value);
-        }
-        return z.object(shape);
-    }
-    return z.any();
-}
-export async function readAgentConfig(agentDir) {
-    const mdPath = path.join(agentDir, "AGENT.md");
-    let mdContent = "";
-    try {
-        mdContent = await fs.readFile(mdPath, "utf-8");
-    }
-    catch {
-        mdContent = DEFAULT_AGENT_MD;
-    }
-    const parsed = matter(mdContent);
-    const config = (parsed.data || {});
-    return {
-        name: typeof config.name === "string" ? config.name : "",
-        description: typeof config.description === "string" ? config.description : "",
-        model: config.model,
-        image: config.image,
-        base: config.base,
-        plugins: config.plugins || [],
-        instructions: parsed.content.trim() || "",
-        subscribe: config.subscribe,
-        outputSchema: config.outputSchema,
-    };
-}
-// ── Agent composition (declarative AGENT.md agents) ──────────────────
-function composeAgentFromConfig(config, toolRegistry, model) {
-    const allToolDefinitions = {};
-    const pluginFactories = [];
-    for (const pluginItem of config.plugins) {
-        const isString = typeof pluginItem === "string";
-        const pluginName = isString ? pluginItem : pluginItem.name;
-        const pluginConfig = isString ? {} : (pluginItem.config || {});
-        const resolvedConfig = resolveConfigPaths(pluginConfig);
-        const entry = toolRegistry.get(pluginName);
-        if (!entry || entry.type !== "tool") {
-            console.warn(`[plugins] "${config.name}": tool "${pluginName}" not found — skipping`);
-            continue;
-        }
-        pluginFactories.push({ plugin: entry.plugin, config: resolvedConfig });
-        Object.assign(allToolDefinitions, entry.toolDefinitions);
-    }
-    const plugin = (builder) => {
-        // 1. Initialize all regular tool plugins
-        for (const { plugin: toolPlugin, config: resolvedConfig } of pluginFactories) {
-            builder.use(toolPlugin({ ...resolvedConfig, model }));
-        }
-        // 2. Resolve the "Brain" (Base Plugin)
-        const baseInput = config.base || "llm";
-        const isBaseString = typeof baseInput === "string";
-        const baseName = isBaseString ? baseInput : baseInput.name;
-        const baseConfig = isBaseString ? {} : (baseInput.config || {});
-        const resolvedBaseConfig = resolveConfigPaths(baseConfig);
-        if (baseName === "llm") {
-            // Default built-in brain
-            builder.use(llmPlugin({
-                model,
-                system: config.instructions,
-                toolDefinitions: allToolDefinitions,
-                outputSchema: config.outputSchema ? jsonToZod(config.outputSchema) : undefined,
-            }));
-        }
-        else {
-            // Custom autonomous brain (e.g. codex)
-            const baseEntry = toolRegistry.get(baseName);
-            if (!baseEntry || baseEntry.type !== "tool") {
-                console.error(`[plugins] "${config.name}": base plugin "${baseName}" not found or invalid. Falling back to default LLM brain.`);
-                builder.use(llmPlugin({
-                    model,
-                    system: config.instructions,
-                    toolDefinitions: allToolDefinitions,
-                }));
-            }
-            else {
-                // Use the custom plugin as the autonomous engine.
-                // It must follow the Base Plugin contract (receive model, system, tools).
-                builder.use(baseEntry.plugin({
-                    ...resolvedBaseConfig,
-                    model,
-                    system: config.instructions,
-                    toolDefinitions: allToolDefinitions,
-                    outputSchema: config.outputSchema ? jsonToZod(config.outputSchema) : undefined,
-                }));
-            }
-        }
-    };
-    return { plugin, toolDefinitions: allToolDefinitions };
-}
-// ── Load tool plugins from a subdirectory (used for agent-local tools) ─
-async function loadToolPluginsFromDir(dir) {
-    const plugins = [];
-    if (!(await fileExists(dir)))
-        return plugins;
-    try {
-        const entries = await fs.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_"))
-                continue;
-            const pluginDir = path.join(dir, entry.name);
-            await ensurePluginReady(pluginDir);
-            const indexPath = await findIndexFile(pluginDir);
-            if (!indexPath)
-                continue;
-            try {
-                const module = await import(pathToFileURL(indexPath).href + `?update=${Date.now()}`);
-                const entryData = module.plugin || module.default || module.entry;
-                if (entryData && typeof entryData.factory === "function") {
-                    plugins.push({
-                        id: entry.name,
-                        name: entryData.name || entry.name,
-                        description: entryData.description || `Tool plugin ${entry.name}`,
-                        type: "tool",
-                        plugin: entryData.factory,
-                        toolDefinitions: entryData.toolDefinitions || {},
-                    });
-                }
-                else {
-                    console.warn(`[plugins] "${entry.name}" does not export a valid plugin entry (missing factory)`);
-                }
-            }
-            catch (err) {
-                console.error(`[plugins] Failed to load tool plugin "${entry.name}":`, err);
-            }
-        }
-    }
-    catch (err) {
-        console.warn(`[plugins] Error reading directory ${dir}:`, err);
-    }
-    return plugins;
-}
-// ── Main unified discovery ───────────────────────────────────────────
-/**
- * Discover all plugins (tools + agents) from a directory.
- *
- * Pass 1: Load code plugins in folders without AGENT.md.
- *   - module.agent export → code-only agent
- *   - plugin/default/entry export → tool plugin
- * Pass 2: Load agent-type plugins (folders WITH AGENT.md).
- *   - AGENT.md only → declarative agent (auto-wrapped with llmPlugin)
- *   - AGENT.md + index.ts → TS agent (user controls logic, AGENT.md for UI editing)
- *
- * Discovered entries are registered directly into the provided registry.
- */
-export async function discoverPlugins(dir, registry, defaultModel, options) {
-    try {
-        await fs.mkdir(dir, { recursive: true });
-    }
-    catch { /* best effort */ }
-    let entries;
-    try {
-        entries = await fs.readdir(dir, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
-    // Classify each subdirectory
-    const codeDirs = [];
-    const agentDirs = [];
-    for (const entry of entries) {
-        if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_"))
-            continue;
-        const pluginDir = path.join(dir, entry.name);
-        const hasAgentMd = await fileExists(path.join(pluginDir, "AGENT.md"));
-        const hasIndex = !!(await findIndexFile(pluginDir));
-        const hasPkg = await fileExists(path.join(pluginDir, "package.json"));
-        if (hasAgentMd) {
-            agentDirs.push({ dir: pluginDir, hasIndex: hasIndex || hasPkg });
-        }
-        else if (hasIndex || hasPkg) {
-            codeDirs.push(pluginDir);
-        }
-    }
-    // Pass 1: code-only agents and tool plugins
-    for (const pluginDir of codeDirs) {
-        await ensurePluginReady(pluginDir);
-        const indexPath = await findIndexFile(pluginDir);
-        if (!indexPath)
-            continue;
-        try {
-            const module = await import(pathToFileURL(indexPath).href + `?update=${Date.now()}`);
-            const codeAgentDef = module.agent;
-            const entryData = module.plugin || module.default || module.entry;
-            if (codeAgentDef && typeof codeAgentDef.factory === "function") {
-                const meta = await getPluginMetadata(pluginDir);
-                const folderName = path.basename(pluginDir);
-                const id = folderName; // Folder name as slug
-                let name = codeAgentDef.name || meta.name;
-                if (!name || /^Unnamed\s+(Plugin|Tool|Agent)$/i.test(name)) {
-                    name = toTitleCaseFromSlug(folderName);
-                }
-                const description = codeAgentDef.description || meta.description || "Code Agent";
-                registry.register({
-                    id,
-                    name,
-                    description,
-                    type: "agent",
-                    plugin: codeAgentDef.factory({ ...options, model: defaultModel }),
-                    capabilities: codeAgentDef.capabilities,
-                    subscribe: codeAgentDef.subscribe,
-                    folder: pluginDir,
-                });
-                console.log(`[plugins] Loaded code-only agent: ${id} (${name}) — ${description}`);
-            }
-            else if (entryData && typeof entryData.factory === "function") {
-                const meta = await getPluginMetadata(pluginDir);
-                const folderName = path.basename(pluginDir);
-                const id = folderName;
-                let name = entryData.name || meta.name;
-                if (!name || /^Unnamed\s+(Plugin|Tool|Agent)$/i.test(name)) {
-                    name = toTitleCaseFromSlug(folderName);
-                }
-                const pluginEntry = {
-                    id,
-                    name,
-                    description: entryData.description || meta.description || "Tool plugin",
-                    type: "tool",
-                    plugin: entryData.factory,
-                    toolDefinitions: entryData.toolDefinitions || {},
-                    folder: pluginDir,
-                };
-                registry.register(pluginEntry);
-                console.log(`[plugins] Loaded tool: ${id} (${pluginEntry.name})`);
-            }
-            else {
-                console.warn(`[plugins] "${path.basename(pluginDir)}" does not export a valid plugin (missing factory)`);
-            }
-        }
-        catch (err) {
-            console.error(`[plugins] Failed to load "${path.basename(pluginDir)}":`, err);
-        }
-    }
-    // Pass 2: agent plugins
-    for (const { dir: agentDir, hasIndex } of agentDirs) {
-        const folderName = path.basename(agentDir);
-        try {
-            if (hasIndex) {
-                // TS Agent — has AGENT.md + code. User controls logic; AGENT.md is for UI editing.
-                await ensurePluginReady(agentDir);
-                const indexPath = await findIndexFile(agentDir);
-                if (!indexPath)
-                    continue;
-                const module = await import(pathToFileURL(indexPath).href + `?update=${Date.now()}`);
-                const definition = module.agent || module.plugin || module.default || module.entry;
-                if (definition && typeof definition.factory === "function") {
-                    const config = await readAgentConfig(agentDir);
-                    const meta = await getPluginMetadata(agentDir);
-                    const id = folderName;
-                    let name = config.name || definition.name || meta.name;
-                    if (!name || /^Unnamed\s+(Plugin|Tool|Agent)$/i.test(name)) {
-                        name = toTitleCaseFromSlug(folderName);
-                    }
-                    const description = definition.description || config.description || "TS Agent";
-                    registry.register({
-                        id,
-                        name,
-                        description,
-                        type: "agent",
-                        plugin: definition.factory({ ...options, model: defaultModel }),
-                        capabilities: definition.capabilities,
-                        subscribe: definition.subscribe || config.subscribe,
-                        folder: agentDir,
-                    });
-                    console.log(`[plugins] Loaded TS agent: ${id} (${name}) — ${description}`);
-                }
-            }
-            else {
-                // Declarative Agent — AGENT.md only, auto-wrapped with llmPlugin.
-                const config = await readAgentConfig(agentDir);
-                const meta = await getPluginMetadata(agentDir);
-                const id = folderName;
-                let resolvedName = config.name || meta.name;
-                if (!resolvedName || /^Unnamed\s+(Plugin|Tool|Agent)$/i.test(resolvedName)) {
-                    resolvedName = toTitleCaseFromSlug(folderName);
-                }
-                const resolvedDescription = config.description || meta.description || "No description";
-                const agentModel = config.model
-                    ? createModel({ ...options, model: config.model })
-                    : defaultModel;
-                // Load agent-local tool plugins
-                const localPlugins = await loadToolPluginsFromDir(path.join(agentDir, "plugins"));
-                // Scoped registry: global tools + local tools
-                const scopedRegistry = new PluginRegistry();
-                for (const p of registry.getTools()) {
-                    scopedRegistry.register(p);
-                }
-                for (const p of localPlugins) {
-                    scopedRegistry.register(p);
-                }
-                // Initialize AGENT.md if missing
-                const agentMdPath = path.join(agentDir, "AGENT.md");
-                if (!(await fileExists(agentMdPath))) {
-                    const content = DEFAULT_AGENT_MD.replace("name: Agent", `name: ${resolvedName}`);
-                    await fs.writeFile(agentMdPath, content, "utf-8");
-                    console.log(`[plugins] Initialized ${resolvedName}/AGENT.md`);
-                }
-                const { plugin, toolDefinitions } = composeAgentFromConfig(config, scopedRegistry, agentModel);
-                registry.register({
-                    id,
-                    name: resolvedName,
-                    description: resolvedDescription,
-                    type: "agent",
-                    plugin,
-                    capabilities: Object.fromEntries(Object.entries(toolDefinitions).map(([name, def]) => [name, def.description])),
-                    subscribe: config.subscribe,
-                    folder: agentDir,
-                });
-                console.log(`[plugins] Loaded agent: ${id} (${resolvedName}) — ${resolvedDescription}${config.model ? ` (model: ${config.model})` : ""}`);
-            }
-        }
-        catch (err) {
-            if (err.code !== "ENOENT") {
-                console.warn(`[plugins] Error loading "${folderName}":`, err);
-            }
-        }
-    }
-}
-// ── Lightweight listing (for API) ────────────────────────────────────
-export async function listPlugins(dir) {
-    const plugins = [];
-    try {
-        const entries = await fs.readdir(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_"))
-                continue;
-            const pluginDir = path.join(dir, entry.name);
-            const hasAgentMd = await fileExists(path.join(pluginDir, "AGENT.md"));
-            const hasCode = await fileExists(path.join(pluginDir, "package.json"))
-                || !!(await findIndexFile(pluginDir));
-            if (hasAgentMd) {
-                const config = await readAgentConfig(pluginDir);
-                const { name: fallbackName, description: fallbackDescription } = await getPluginMetadata(pluginDir);
-                plugins.push({
-                    name: config.name || fallbackName || "Unnamed Agent",
-                    description: config.description || fallbackDescription || "No description",
-                    folder: pluginDir,
-                    type: "agent",
-                    hasAgentMd: true,
-                    image: config.image,
-                });
-            }
-            else if (hasCode) {
-                await ensurePluginReady(pluginDir);
-                const indexPath = await findIndexFile(pluginDir);
-                const { name: fallbackName, description: fallbackDescription } = await getPluginMetadata(pluginDir);
-                if (!indexPath) {
-                    plugins.push({
-                        name: fallbackName,
-                        description: fallbackDescription,
-                        folder: pluginDir,
-                        type: "tool",
-                        hasAgentMd: false,
-                    });
-                    continue;
-                }
-                try {
-                    const module = await import(pathToFileURL(indexPath).href + `?update=${Date.now()}`);
-                    const codeAgentDef = module.agent;
-                    const toolEntry = module.plugin || module.default || module.entry;
-                    if (codeAgentDef && typeof codeAgentDef.factory === "function") {
-                        plugins.push({
-                            name: codeAgentDef.name || fallbackName || "Unnamed Agent",
-                            description: codeAgentDef.description || fallbackDescription || "Code Agent",
-                            folder: pluginDir,
-                            type: "agent",
-                            hasAgentMd: false,
-                            image: codeAgentDef.image,
-                        });
-                    }
-                    else if (toolEntry && typeof toolEntry.factory === "function") {
-                        plugins.push({
-                            name: toolEntry.name || fallbackName,
-                            description: toolEntry.description || fallbackDescription,
-                            folder: pluginDir,
-                            type: "tool",
-                            hasAgentMd: false,
-                        });
-                    }
-                }
-                catch {
-                    plugins.push({
-                        name: fallbackName,
-                        description: fallbackDescription,
-                        folder: pluginDir,
-                        type: "tool",
-                        hasAgentMd: false,
-                    });
-                }
-            }
-        }
-    }
-    catch { /* directory doesn't exist */ }
-    return plugins;
-}

package/dist/registry/plugin-registry.js

@@ -1,44 +0,0 @@
-/**
- * Unified Plugin Registry
- *
- * Holds both tool plugins and agent plugins in a single registry.
- * Built-in entries are registered at startup; community plugins
- * are discovered from ~/.openbot/plugins/.
- */
-export class PluginRegistry {
-    constructor() {
-        this.plugins = new Map();
-    }
-    register(entry) {
-        if (this.plugins.has(entry.name)) {
-            console.warn(`Plugin "${entry.name}" is already registered — overwriting`);
-        }
-        this.plugins.set(entry.name, entry);
-    }
-    get(name) {
-        return this.plugins.get(name);
-    }
-    has(name) {
-        return this.plugins.has(name);
-    }
-    getAll() {
-        return Array.from(this.plugins.values());
-    }
-    getNames() {
-        return Array.from(this.plugins.keys());
-    }
-    getAgents() {
-        return this.getAll().filter(p => p.type === "agent");
-    }
-    getTools() {
-        return this.getAll().filter(p => p.type === "tool");
-    }
-    /** Returns agent IDs as a tuple suitable for z.enum(). */
-    getAgentIds() {
-        const ids = this.getAgents().map(a => a.id);
-        if (ids.length === 0) {
-            throw new Error("No agents registered — at least one agent is required");
-        }
-        return ids;
-    }
-}

package/dist/registry/ts-agent-loader.js

@@ -1,82 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { pathToFileURL } from "node:url";
-import { ensurePluginReady } from "./plugin-loader.js";
-/**
- * Discover and load TS-defined agents from a directory.
- *
- * Scans each subdirectory for a package.json and an index file.
- *
- * @param agentsDir Absolute path to the agents directory (e.g. ~/.openbot/agents)
- * @param defaultModel Language model to use for agent LLMs
- * @param options Optional API keys for creating specific models
- * @returns Array of discovered agent entries ready for registration
- */
-export async function discoverTsAgents(agentsDir, defaultModel, options) {
-    const agents = [];
-    try {
-        const entries = await fs.readdir(agentsDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (!entry.isDirectory())
-                continue;
-            if (entry.name.startsWith(".") || entry.name.startsWith("_"))
-                continue;
-            const agentDir = path.join(agentsDir, entry.name);
-            // We only consider it a TS agent if it doesn't have an AGENT.md
-            // (This avoids double-loading if someone has both for some reason)
-            const mdPath = path.join(agentDir, "AGENT.md");
-            const hasMd = await fs.access(mdPath).then(() => true).catch(() => false);
-            if (hasMd)
-                continue;
-            // Check for package.json to see if it's a package
-            const pkgPath = path.join(agentDir, "package.json");
-            const hasPackageJson = await fs.access(pkgPath).then(() => true).catch(() => false);
-            if (!hasPackageJson)
-                continue;
-            try {
-                // 1. Ensure dependencies and build are ready
-                await ensurePluginReady(agentDir);
-                // 2. Find index file
-                let indexPath;
-                const possibleIndices = ["dist/index.js", "index.js", "index.ts"];
-                for (const file of possibleIndices) {
-                    try {
-                        const fullPath = path.join(agentDir, file);
-                        await fs.access(fullPath);
-                        indexPath = fullPath;
-                        break;
-                    }
-                    catch {
-                        continue;
-                    }
-                }
-                if (!indexPath)
-                    continue;
-                // 3. Import and instantiate
-                const moduleUrl = pathToFileURL(indexPath).href;
-                const module = await import(moduleUrl);
-                // Support 'agent', 'plugin', 'default', or 'entry'
-                const definition = module.agent || module.plugin || module.default || module.entry;
-                if (definition && typeof definition.factory === "function") {
-                    const name = definition.name || entry.name;
-                    const description = definition.description || "TS Agent";
-                    agents.push({
-                        name,
-                        description,
-                        plugin: definition.factory({ ...options, model: defaultModel }),
-                        capabilities: definition.capabilities,
-                        subscribe: definition.subscribe,
-                    });
-                    console.log(`[agents] Loaded TS agent: ${name} — ${description}`);
-                }
-            }
-            catch (err) {
-                console.warn(`[agents] Failed to load TS agent package "${entry.name}":`, err);
-            }
-        }
-    }
-    catch {
-        // Agents directory doesn't exist
-    }
-    return agents;
-}