openbot 0.2.3 → 0.2.6

package/dist/registry/plugin-loader.js

@@ -2,13 +2,49 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
 import { execSync } from "node:child_process";
-/**
- * Get metadata (name, description, version) from a plugin directory.
- */
+import matter from "gray-matter";
+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 fs.access(pkgPath).then(() => true).catch(() => false);
-    let name = path.basename(pluginDir);
+    const hasPackageJson = await fileExists(pkgPath);
+    let name = "Unnamed Plugin";
     let description = "No description";
     let version = "0.0.0";
     if (hasPackageJson) {
@@ -18,33 +54,23 @@ export async function getPluginMetadata(pluginDir) {
             description = pkg.description || description;
             version = pkg.version || version;
         }
-        catch {
-            // Fallback to defaults
-        }
+        catch { /* fallback to defaults */ }
     }
     return { name, description, version };
 }
-/**
- * Ensure a plugin is ready to run by installing dependencies and building if necessary.
- */
 export async function ensurePluginReady(pluginDir) {
     try {
         const pkgPath = path.join(pluginDir, "package.json");
-        const hasPackageJson = await fs.access(pkgPath).then(() => true).catch(() => false);
-        if (!hasPackageJson)
+        if (!(await fileExists(pkgPath)))
             return;
         const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
         const nodeModulesPath = path.join(pluginDir, "node_modules");
-        const hasNodeModules = await fs.access(nodeModulesPath).then(() => true).catch(() => false);
-        // 1. Install dependencies if node_modules is missing
-        if (!hasNodeModules) {
+        if (!(await fileExists(nodeModulesPath))) {
             console.log(`[plugins] Installing dependencies for ${path.basename(pluginDir)}...`);
             execSync("npm install", { cwd: pluginDir, stdio: "inherit" });
         }
-        // 2. Run build if dist is missing but build script exists
         const distPath = path.join(pluginDir, "dist");
-        const hasDist = await fs.access(distPath).then(() => true).catch(() => false);
-        if (!hasDist && pkg.scripts?.build) {
+        if (!(await fileExists(distPath)) && pkg.scripts?.build) {
             console.log(`[plugins] Building ${path.basename(pluginDir)}...`);
             execSync("npm run build", { cwd: pluginDir, stdio: "inherit" });
         }
@@ -53,57 +79,81 @@ export async function ensurePluginReady(pluginDir) {
         console.error(`[plugins] Failed to prepare plugin in ${pluginDir}:`, err);
     }
 }
-/**
- * Dynamically load plugins from a directory.
- * Scans each subdirectory for an index.js (or index.ts if running via tsx).
- */
-export async function loadPluginsFromDir(dir) {
-    const plugins = [];
+export async function readAgentConfig(agentDir) {
+    const mdPath = path.join(agentDir, "AGENT.md");
+    let mdContent = "";
     try {
-        await fs.access(dir);
+        mdContent = await fs.readFile(mdPath, "utf-8");
     }
     catch {
-        // Directory doesn't exist
-        return plugins;
+        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,
+        plugins: config.plugins || [],
+        instructions: parsed.content.trim() || "",
+        subscribe: config.subscribe,
+    };
+}
+// ── 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) => {
+        for (const { plugin: toolPlugin, config: resolvedConfig } of pluginFactories) {
+            builder.use(toolPlugin({ ...resolvedConfig, model }));
+        }
+        builder.use(llmPlugin({
+            model,
+            system: config.instructions,
+            toolDefinitions: allToolDefinitions,
+        }));
+    };
+    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())
-                continue;
-            if (entry.name.startsWith(".") || entry.name.startsWith("_"))
+            if (!entry.isDirectory() || entry.name.startsWith(".") || entry.name.startsWith("_"))
                 continue;
             const pluginDir = path.join(dir, entry.name);
-            // Ensure plugin is ready (dependencies, build)
             await ensurePluginReady(pluginDir);
-            // Try to find index.js or index.ts, prioritizing dist/index.js for pre-built bundles
-            let indexPath;
-            const possibleIndices = ["dist/index.js", "index.js", "index.ts"];
-            for (const file of possibleIndices) {
-                try {
-                    const fullPath = path.join(pluginDir, file);
-                    await fs.access(fullPath);
-                    indexPath = fullPath;
-                    break;
-                }
-                catch {
-                    continue;
-                }
-            }
-            if (!indexPath) {
-                console.warn(`[plugins] No index.js or index.ts found in ${pluginDir}`);
+            const indexPath = await findIndexFile(pluginDir);
+            if (!indexPath)
                 continue;
-            }
             try {
-                // Use pathToFileURL for compatibility with import() on all OSs
-                const moduleUrl = pathToFileURL(indexPath).href;
-                const module = await import(moduleUrl);
-                // The plugin can be exported as 'plugin', 'default', or 'entry'
+                const module = await import(pathToFileURL(indexPath).href);
                 const entryData = module.plugin || module.default || module.entry;
                 if (entryData && typeof entryData.factory === "function") {
                     plugins.push({
-                        ...entryData,
-                        name: entryData.name || entry.name, // Fallback to folder name
+                        name: entryData.name || entry.name,
+                        description: entryData.description || `Tool plugin ${entry.name}`,
+                        type: "tool",
+                        plugin: entryData.factory,
+                        toolDefinitions: entryData.toolDefinitions || {},
                     });
                 }
                 else {
@@ -111,7 +161,7 @@ export async function loadPluginsFromDir(dir) {
                 }
             }
             catch (err) {
-                console.error(`[plugins] Failed to load plugin "${entry.name}":`, err);
+                console.error(`[plugins] Failed to load tool plugin "${entry.name}":`, err);
             }
         }
     }
@@ -120,3 +170,258 @@ export async function loadPluginsFromDir(dir) {
     }
     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);
+            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);
+                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({
+                    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: ${name} — ${description}`);
+            }
+            else if (entryData && typeof entryData.factory === "function") {
+                const meta = await getPluginMetadata(pluginDir);
+                const folderName = path.basename(pluginDir);
+                let name = entryData.name || meta.name;
+                if (!name || /^Unnamed\s+(Plugin|Tool|Agent)$/i.test(name)) {
+                    name = toTitleCaseFromSlug(folderName);
+                }
+                const pluginEntry = {
+                    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: ${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);
+                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);
+                    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({
+                        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: ${name} — ${description}`);
+                }
+            }
+            else {
+                // Declarative Agent — AGENT.md only, auto-wrapped with llmPlugin.
+                const config = await readAgentConfig(agentDir);
+                const meta = await getPluginMetadata(agentDir);
+                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({
+                    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: ${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);
+                    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,15 +1,18 @@
 /**
- * Plugin Registry
+ * Unified Plugin Registry
  *
- * Maps plugin names to their factories and tool definitions.
- * Built-in plugins are registered at startup; community plugins
- * can be added via npm packages or local directories (future).
+ * 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) {
@@ -24,4 +27,18 @@ export class PluginRegistry {
     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 names as a tuple suitable for z.enum(). */
+    getAgentNames() {
+        const names = this.getAgents().map(a => a.name);
+        if (names.length === 0) {
+            throw new Error("No agents registered — at least one agent is required");
+        }
+        return names;
+    }
 }

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

@@ -22,11 +22,11 @@ export async function discoverTsAgents(agentsDir, defaultModel, options) {
             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.yaml
+            // 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 yamlPath = path.join(agentDir, "agent.yaml");
-            const hasYaml = await fs.access(yamlPath).then(() => true).catch(() => false);
-            if (hasYaml)
+            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");