openbot 0.1.20 → 0.1.23

package/dist/plugins/skills/index.js

@@ -0,0 +1,275 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import matter from "gray-matter";
+// Re-exports
+export { skillsToolDefinitions } from "./types.js";
+// --- Helpers ---
+function expandPath(p) {
+    if (p.startsWith("~/")) {
+        return path.join(process.env.HOME || "", p.slice(2));
+    }
+    return p;
+}
+// --- Skills Module (internal) ---
+function createSkillsModule(skillsDir) {
+    async function list() {
+        const skills = [];
+        try {
+            const folders = await fs.readdir(skillsDir);
+            for (const folder of folders) {
+                if (folder.startsWith("_") || folder.startsWith("."))
+                    continue;
+                const skillPath = path.join(skillsDir, folder, "SKILL.md");
+                try {
+                    const content = await fs.readFile(skillPath, "utf-8");
+                    const { data } = matter(content);
+                    skills.push({
+                        id: folder,
+                        title: data.title || folder,
+                        description: data.description || "No description",
+                        version: data.version,
+                        tools: data.tools,
+                        triggers: data.triggers,
+                    });
+                }
+                catch {
+                    // Invalid skill, skip
+                }
+            }
+        }
+        catch {
+            // Skills directory doesn't exist yet
+        }
+        return skills;
+    }
+    return {
+        async initialize() {
+            await fs.mkdir(skillsDir, { recursive: true });
+        },
+        list,
+        async load(skillId) {
+            const skillPath = path.join(skillsDir, skillId, "SKILL.md");
+            const content = await fs.readFile(skillPath, "utf-8");
+            const { data, content: body } = matter(content);
+            return { meta: data, instructions: body.trim() };
+        },
+        async create(id, title, description, content) {
+            if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(id)) {
+                throw new Error("Skill id must be kebab-case (e.g., 'my-skill')");
+            }
+            const skillDir = path.join(skillsDir, id);
+            await fs.mkdir(skillDir, { recursive: true });
+            const skillContent = `---
+title: ${title}
+description: ${description}
+version: 1.0.0
+createdAt: ${new Date().toISOString()}
+---
+
+${content}`;
+            await fs.writeFile(path.join(skillDir, "SKILL.md"), skillContent, "utf-8");
+            return `skills/${id}/SKILL.md`;
+        },
+        async update(id, content, title, description) {
+            const skillPath = path.join(skillsDir, id, "SKILL.md");
+            const existingContent = await fs.readFile(skillPath, "utf-8");
+            const { data: existingData } = matter(existingContent);
+            const newTitle = title || existingData.title || id;
+            const newDescription = description || existingData.description || "No description";
+            // Bump patch version
+            let version = existingData.version || "1.0.0";
+            const parts = version.split(".");
+            if (parts.length === 3) {
+                parts[2] = (parseInt(parts[2]) + 1).toString();
+                version = parts.join(".");
+            }
+            const skillContent = `---
+title: ${newTitle}
+description: ${newDescription}
+version: ${version}
+updatedAt: ${new Date().toISOString()}
+createdAt: ${existingData.createdAt || new Date().toISOString()}
+---
+
+${content}`;
+            await fs.writeFile(skillPath, skillContent, "utf-8");
+            return version;
+        },
+        async getIndex() {
+            const skills = await list();
+            if (skills.length > 0) {
+                return `## Available Skills
+
+You have the following skills available. Use \`loadSkill\` with the skill id to get full instructions before executing.
+
+${skills.map((s) => `- **${s.title}** (\`${s.id}\`): ${s.description}`).join("\n")}`;
+            }
+            return `## Skills
+
+You have no skills yet. When you learn reusable patterns, create skills using \`createSkill\` so you can use them again later.`;
+        },
+    };
+}
+// --- Prompt Builder ---
+/**
+ * Create a prompt builder that generates the skills section
+ * of the system prompt. Use alongside the brain prompt builder.
+ */
+export function createSkillsPromptBuilder(baseDir) {
+    const expandedBase = expandPath(baseDir);
+    const skills = createSkillsModule(path.join(expandedBase, "skills"));
+    return async () => skills.getIndex();
+}
+// --- Plugin ---
+/**
+ * Skills Plugin for Melony
+ *
+ * Manages reusable skill definitions: load, create, update, list.
+ * Fully independent from the brain plugin.
+ */
+export const skillsPlugin = (options) => (builder) => {
+    const expandedBase = expandPath(options.baseDir);
+    const skills = createSkillsModule(path.join(expandedBase, "skills"));
+    // ─── Initialization ───────────────────────────────────────────────
+    builder.on("init", async function* () {
+        await skills.initialize();
+        yield {
+            type: "skills:status",
+            data: { message: "Skills initialized", severity: "success" },
+        };
+    });
+    // ─── Load ─────────────────────────────────────────────────────────
+    builder.on("action:loadSkill", async function* (event) {
+        const { skillId, toolCallId } = event.data;
+        try {
+            const { meta, instructions } = await skills.load(skillId);
+            yield {
+                type: "skills:loaded",
+                data: {
+                    skillId,
+                    title: meta.title || skillId,
+                    instructions: meta.description || "No description",
+                },
+            };
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "loadSkill",
+                    toolCallId,
+                    result: { id: skillId, meta, instructions },
+                },
+            };
+        }
+        catch {
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "loadSkill",
+                    toolCallId,
+                    result: { error: `Skill "${skillId}" not found` },
+                },
+            };
+        }
+    });
+    // ─── List ─────────────────────────────────────────────────────────
+    builder.on("action:listSkills", async function* (event) {
+        const { toolCallId } = event.data;
+        const skillsList = await skills.list();
+        yield {
+            type: "action:taskResult",
+            data: {
+                action: "listSkills",
+                toolCallId,
+                result: { skills: skillsList },
+            },
+        };
+    });
+    // ─── Create ───────────────────────────────────────────────────────
+    builder.on("action:createSkill", async function* (event) {
+        const { id, title, description, content, toolCallId } = event.data;
+        try {
+            const skillPath = await skills.create(id, title, description, content);
+            yield {
+                type: "skills:status",
+                data: { message: `Skill "${title}" created`, severity: "success" },
+            };
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "createSkill",
+                    toolCallId,
+                    result: {
+                        success: true,
+                        path: skillPath,
+                        message: `Skill "${title}" created successfully`,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            yield {
+                type: "skills:status",
+                data: {
+                    message: `Failed to create skill: ${error.message}`,
+                    severity: "error",
+                },
+            };
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "createSkill",
+                    toolCallId,
+                    result: { error: error.message },
+                },
+            };
+        }
+    });
+    // ─── Update ───────────────────────────────────────────────────────
+    builder.on("action:updateSkill", async function* (event) {
+        const { id, title, description, content, toolCallId } = event.data;
+        try {
+            const version = await skills.update(id, content, title, description);
+            yield {
+                type: "skills:status",
+                data: {
+                    message: `Skill updated to v${version}`,
+                    severity: "success",
+                },
+            };
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "updateSkill",
+                    toolCallId,
+                    result: {
+                        success: true,
+                        path: `skills/${id}/SKILL.md`,
+                        version,
+                        message: `Skill updated to version ${version}`,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            const errorMsg = error.code === "ENOENT"
+                ? `Skill "${id}" does not exist`
+                : error.message;
+            yield {
+                type: "skills:status",
+                data: {
+                    message: `Failed to update skill: ${errorMsg}`,
+                    severity: "error",
+                },
+            };
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "updateSkill",
+                    toolCallId,
+                    result: { error: errorMsg },
+                },
+            };
+        }
+    });
+};
+export default skillsPlugin;

package/dist/plugins/skills/types.js

@@ -0,0 +1,50 @@
+import { z } from "zod";
+// --- Tool Definitions ---
+export const skillsToolDefinitions = {
+    loadSkill: {
+        description: "Load a skill's full instructions when you need to use it. Call this before executing a skill.",
+        inputSchema: z.object({
+            skillId: z
+                .string()
+                .describe("The skill folder name (e.g., 'code-review')"),
+        }),
+    },
+    createSkill: {
+        description: "Create a new skill from learned knowledge. Use when you discover a reusable pattern.",
+        inputSchema: z.object({
+            id: z
+                .string()
+                .describe("Skill folder name in kebab-case (e.g., 'web-search')"),
+            title: z.string().describe("Human-readable skill title"),
+            description: z
+                .string()
+                .describe("Brief description of what the skill does"),
+            content: z
+                .string()
+                .describe("Full skill instructions in markdown"),
+        }),
+    },
+    updateSkill: {
+        description: "Update an existing skill with new knowledge or improvements.",
+        inputSchema: z.object({
+            id: z
+                .string()
+                .describe("The skill folder name (e.g., 'code-review')"),
+            title: z
+                .string()
+                .optional()
+                .describe("New title for the skill"),
+            description: z
+                .string()
+                .optional()
+                .describe("New description for the skill"),
+            content: z
+                .string()
+                .describe("Updated full skill instructions in markdown"),
+        }),
+    },
+    listSkills: {
+        description: "List all available skills with their metadata.",
+        inputSchema: z.object({}),
+    },
+};

package/dist/plugins/skills/ui.js

@@ -0,0 +1,12 @@
+import { ui } from "@melony/ui-kit/server";
+// --- UI Plugin ---
+export const skillsUIPlugin = () => (builder) => {
+    builder.on("skills:status", async function* (event) {
+        yield ui.event(ui.status(event.data.message, event.data.severity));
+    });
+    builder.on("skills:loaded", async function* (event) {
+        yield ui.event(ui.resourceCard(event.data.title, "", [
+            ui.text(event.data.instructions),
+        ]));
+    });
+};

package/dist/registry/agent-registry.js

@@ -0,0 +1,35 @@
+/**
+ * Agent Registry
+ *
+ * Collects all available agents (built-in + discovered).
+ * Used by the manager to dynamically build the delegation tool schema
+ * and wire up generic bridge-back handlers.
+ */
+export class AgentRegistry {
+    constructor() {
+        this.agents = new Map();
+    }
+    register(entry) {
+        if (this.agents.has(entry.name)) {
+            console.warn(`Agent "${entry.name}" is already registered — overwriting`);
+        }
+        this.agents.set(entry.name, entry);
+    }
+    get(name) {
+        return this.agents.get(name);
+    }
+    has(name) {
+        return this.agents.has(name);
+    }
+    getAll() {
+        return Array.from(this.agents.values());
+    }
+    /** Returns agent names as a tuple suitable for z.enum() */
+    getNames() {
+        const names = Array.from(this.agents.keys());
+        if (names.length === 0) {
+            throw new Error("No agents registered — at least one agent is required");
+        }
+        return names;
+    }
+}

package/dist/registry/index.js

@@ -0,0 +1,3 @@
+export { PluginRegistry } from "./plugin-registry.js";
+export { AgentRegistry } from "./agent-registry.js";
+export { discoverYamlAgents } from "./yaml-agent-loader.js";

package/dist/registry/plugin-registry.js

@@ -0,0 +1,27 @@
+/**
+ * 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).
+ */
+export class PluginRegistry {
+    constructor() {
+        this.plugins = new Map();
+    }
+    register(entry) {
+        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());
+    }
+}

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

@@ -0,0 +1,100 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import yaml from "js-yaml";
+import { llmPlugin } from "../plugins/llm/index.js";
+import { createModel } from "../models.js";
+/**
+ * Discover and load YAML-defined agents from a directory.
+ *
+ * Scans `agentsDir` for subdirectories containing an `agent.yaml` file,
+ * parses each one, and composes a Melony plugin from the referenced plugins.
+ *
+ * @param agentsDir  Absolute path to the agents directory (e.g. ~/.openbot/agents)
+ * @param pluginRegistry  Registry of available plugins
+ * @param defaultModel  Language model to use for agent LLMs if not specified in YAML
+ * @param options  Optional API keys for creating specific models
+ * @returns Array of discovered agent entries ready for registration
+ */
+export async function discoverYamlAgents(agentsDir, pluginRegistry, defaultModel, options) {
+    const agents = [];
+    // Ensure the agents directory exists
+    try {
+        await fs.mkdir(agentsDir, { recursive: true });
+    }
+    catch {
+        // Best effort
+    }
+    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 yamlPath = path.join(agentsDir, entry.name, "agent.yaml");
+            try {
+                const content = await fs.readFile(yamlPath, "utf-8");
+                const config = yaml.load(content);
+                // Validate required fields
+                if (!config.name || !config.description || !config.plugins?.length || !config.systemPrompt) {
+                    console.warn(`[agents] "${entry.name}/agent.yaml": missing required fields (name, description, plugins, systemPrompt) — skipping`);
+                    continue;
+                }
+                // Use agent-specific model if defined, otherwise use default
+                const agentModel = config.model
+                    ? createModel({ ...options, model: config.model })
+                    : defaultModel;
+                const plugin = composeAgentFromYaml(config, pluginRegistry, agentModel);
+                agents.push({
+                    name: config.name,
+                    description: config.description,
+                    plugin,
+                });
+                console.log(`[agents] Loaded: ${config.name} — ${config.description}${config.model ? ` (model: ${config.model})` : ""}`);
+            }
+            catch (err) {
+                // Invalid or missing agent.yaml — silently skip
+                console.warn(`[agents] Error loading "${entry.name}/agent.yaml":`, err);
+            }
+        }
+    }
+    catch {
+        // Agents directory doesn't exist or can't be read — that's fine
+    }
+    return agents;
+}
+/**
+ * Compose a Melony plugin from a YAML agent configuration.
+ *
+ * Resolves each plugin name against the registry, collects their tool definitions,
+ * and wires them with an agent-scoped LLM plugin.
+ */
+function composeAgentFromYaml(config, pluginRegistry, model) {
+    return (builder) => {
+        const allToolDefinitions = {};
+        for (const pluginName of config.plugins) {
+            const entry = pluginRegistry.get(pluginName);
+            if (!entry) {
+                console.warn(`[agents] "${config.name}": plugin "${pluginName}" not found in registry — skipping`);
+                continue;
+            }
+            // Register the plugin's event handlers
+            builder.use(entry.factory());
+            // Register UI plugin if available
+            if (entry.uiFactory) {
+                builder.use(entry.uiFactory());
+            }
+            // Collect tool definitions for the LLM
+            Object.assign(allToolDefinitions, entry.toolDefinitions);
+        }
+        // Wire up the LLM with agent-scoped event channels
+        builder.use(llmPlugin({
+            model,
+            system: config.systemPrompt,
+            toolDefinitions: allToolDefinitions,
+            promptInputType: `agent:${config.name}:input`,
+            actionResultInputType: `agent:${config.name}:result`,
+            completionEventType: `agent:${config.name}:output`,
+        }));
+    };
+}

package/dist/server.js

@@ -1,25 +1,16 @@
-#!/usr/bin/env node
 import "dotenv/config";
 import express from "express";
 import cors from "cors";
-import { Command } from "commander";
 import { generateId } from "melony";
-import { createOpenBot } from "./agent.js";
+import { createOpenBot } from "./open-bot.js";
 import { loadConfig } from "./config.js";
 import { loadSession, saveSession, logEvent, loadEvents } from "./session.js";
-const program = new Command();
-program
-    .name("openbot-server")
-    .description("OpenBot server")
-    .option("-p, --port <number>", "Port to listen on")
-    .option("--openai-api-key <key>", "OpenAI API Key")
-    .option("--anthropic-api-key <key>", "Anthropic API Key")
-    .action(async (options) => {
+export async function startServer(options = {}) {
     const config = loadConfig();
     const PORT = Number(options.port ?? config.port ?? process.env.PORT ?? 4001);
     const app = express();
-    // Initialize the bot instance once at startup
-    const openBot = await createOpenBot({
+    // Initialize the agent instance once at startup
+    const openBotAgent = await createOpenBot({
         openaiApiKey: options.openaiApiKey,
         anthropicApiKey: options.anthropicApiKey,
     });
@@ -32,24 +23,32 @@ program
             stream: "Server-Sent Events (SSE)",
         });
     });
-    // Init endpoint
-    app.get("/api/init", async (req, res) => {
-        const platform = req.query.platform || "web";
-        const sessionId = req.query.sessionId || "default";
-        const tab = req.query.tab;
-        const state = await loadSession(sessionId) ?? {};
-        const response = await openBot.jsonResponse({
-            type: "init",
-            data: { platform, tab }
+    // View endpoint (GET version of chat, returns JSON instead of SSE)
+    app.get("/api/view", async (req, res) => {
+        const { type = "init", data: dataStr } = req.query;
+        // Parse the structured data
+        const eventData = dataStr ? JSON.parse(dataStr) : {};
+        const { sessionId = "default", history = false } = eventData;
+        const state = (await loadSession(sessionId)) ?? {};
+        state.sessionId = sessionId;
+        const response = await openBotAgent.jsonResponse({
+            type: type,
+            data: eventData,
         }, {
-            state: { ...state, sessionId },
-            runId: generateId()
+            state,
+            runId: generateId(),
         });
         const result = await response.json();
-        const initialEvents = await loadEvents(sessionId);
+        const uiEvents = result.events.filter((event) => event.type === "ui");
+        const layout = uiEvents.find((e) => e.meta?.type === "layout")?.data;
+        const sidebar = uiEvents.find((e) => e.meta?.type === "sidebar")?.data;
+        const content = uiEvents.find((e) => e.meta?.type === "content")?.data;
+        const initialEvents = history ? await loadEvents(sessionId) : undefined;
         res.json({
-            data: result.data,
-            initialEvents
+            ui: layout,
+            sidebar,
+            content,
+            initialEvents,
         });
     });
     // Chat endpoint
@@ -66,10 +65,11 @@ program
             Connection: "keep-alive",
         });
         res.flushHeaders?.();
-        const runtime = openBot.build();
+        const runtime = openBotAgent.build();
         const sessionId = body.sessionId ?? "default";
         const runId = body.runId ?? `run_${generateId()}`;
-        const state = await loadSession(sessionId) ?? {};
+        const state = (await loadSession(sessionId)) ?? {};
+        state.sessionId = sessionId;
         // Log the incoming event
         await logEvent(sessionId, runId, body.event);
         const iterator = runtime.run(body.event, {
@@ -116,5 +116,4 @@ program
         if (options.anthropicApiKey)
             console.log("  - Using Anthropic API Key from CLI");
     });
-});
-program.parse();
+}

package/dist/ui/header.js

@@ -6,15 +6,12 @@ export const headerUI = (tab) => ui.box({
 }, [
     ui.row({ justify: "between", align: "center", width: "full" }, [
         ui.row({ gap: "xs", align: "center" }, [
-            ui.button({
-                label: "OpenBot",
-                variant: "ghost",
-                size: "sm",
+            ui.listItem({
                 onClickAction: {
                     type: "client:navigate",
-                    data: { path: "/" },
-                },
-            }),
+                    data: { path: "/" }
+                }
+            }, [ui.text("OpenBot")]),
             ui.divider({ orientation: "vertical", margin: "xs" }),
             ui.button({
                 label: "Chat",

package/dist/ui/layout.js

@@ -9,13 +9,6 @@ const tabs = {
     settings: settingsUI,
     skills: skillsUI,
 };
-// export const layoutUI = (tab: string) =>
-//   ui.col({ height: "full", width: "full", gap: "none" }, [
-//     headerUI(tab),
-//     ui.box({ flex: 1, width: "full", overflow: "auto" }, [
-//       tabs[tab as keyof typeof tabs],
-//     ]),
-//   ]);
 export const layoutUI = async ({ tab, sessionId }) => {
     const sessions = await listSessions();
     return ui.row({ height: "full" }, [
@@ -23,3 +16,10 @@ export const layoutUI = async ({ tab, sessionId }) => {
         tabs[tab]
     ]);
 };
+export const sidebarOnlyUI = async ({ sessionId }) => {
+    const sessions = await listSessions();
+    return sidebarUI({ sessions, sessionId });
+};
+export const tabOnlyUI = async ({ tab }) => {
+    return tabs[tab];
+};

package/dist/ui/navigation.js

@@ -8,6 +8,8 @@ const listItemProps = (path) => ({
 export const navigationUI = ui.box({ width: "full" }, [ui.list({
         gap: "none",
     }, [
-        ui.listItem(listItemProps("/"), [ui.text("Chat", { size: "sm" })]),
-        ui.listItem(listItemProps("/?tab=skills"), [ui.text("Skills", { size: "sm" })]),
+        ui.listItem(listItemProps("/"), [
+            ui.icon("PlusIcon", { size: "sm" }),
+            ui.text("New chat", { size: "sm" })
+        ])
     ])]);