openbot 0.1.20 → 0.1.23

package/dist/plugins/file-system/index.js

@@ -0,0 +1,166 @@
+import { z } from "zod";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+export const fileSystemToolDefinitions = {
+    readFile: {
+        description: "Read the contents of a file. Path can be absolute or relative to the current working directory.",
+        inputSchema: z.object({
+            path: z.string().describe("The path to the file (e.g., 'src/main.ts' or '/etc/hosts')"),
+        }),
+    },
+    writeFile: {
+        description: "Write content to a file. Path can be absolute or relative to the current working directory.",
+        inputSchema: z.object({
+            path: z.string().describe("The path to the file (e.g., 'new-file.ts')"),
+            content: z.string().describe("The content to write to the file"),
+        }),
+    },
+    listFiles: {
+        description: "List files in a directory. Path can be absolute or relative to the current working directory.",
+        inputSchema: z.object({
+            path: z.string().describe("The path to the directory (use '.' for current directory)"),
+        }),
+    },
+    deleteFile: {
+        description: "Delete a file. Path can be absolute or relative to the current working directory.",
+        inputSchema: z.object({
+            path: z.string().describe("The path to the file"),
+        }),
+    },
+};
+/**
+ * Truncates a string by keeping the first and last N characters.
+ */
+function truncate(str, maxChars) {
+    if (!str || str.length <= maxChars)
+        return str;
+    const half = Math.floor(maxChars / 2);
+    const truncatedCount = str.length - maxChars;
+    return `${str.slice(0, half)}\n\n[... ${truncatedCount} characters truncated ...]\n\n${str.slice(-half)}`;
+}
+export const fileSystemPlugin = (options = {}) => (builder) => {
+    const { baseDir = "/", maxFileReadLength = 10000 } = options;
+    const resolvePath = (p, stateCwd) => {
+        // If p is absolute, resolve from root. If relative, resolve from stateCwd or baseDir.
+        const resolved = path.isAbsolute(p) ? p : path.resolve(stateCwd || baseDir, p);
+        return resolved;
+    };
+    builder.on("action:readFile", async function* (event, { state }) {
+        const { path: filePath, toolCallId } = event.data;
+        yield {
+            type: "file-system:status",
+            data: { message: `Reading file: ${filePath} (relative to ${state.cwd || baseDir})` }
+        };
+        try {
+            const content = await fs.readFile(resolvePath(filePath, state.cwd), "utf-8");
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "readFile",
+                    result: { content: truncate(content, maxFileReadLength) },
+                    toolCallId
+                },
+            };
+            yield {
+                type: "file-system:status",
+                data: { message: `File read successfully`, severity: "success" }
+            };
+        }
+        catch (error) {
+            yield {
+                type: "action:taskResult",
+                data: { action: "readFile", result: { error: error.message }, toolCallId },
+            };
+            yield {
+                type: "file-system:status",
+                data: { message: `File read failed: ${error.message}`, severity: "error" }
+            };
+        }
+    });
+    builder.on("action:writeFile", async function* (event, { state }) {
+        const { path: filePath, content, toolCallId } = event.data;
+        yield {
+            type: "file-system:status",
+            data: { message: `Writing file: ${filePath}` }
+        };
+        try {
+            const fullPath = resolvePath(filePath, state.cwd);
+            await fs.mkdir(path.dirname(fullPath), { recursive: true });
+            await fs.writeFile(fullPath, content, "utf-8");
+            yield {
+                type: "action:taskResult",
+                data: { action: "writeFile", result: { success: true }, toolCallId },
+            };
+            yield {
+                type: "file-system:status",
+                data: { message: `File written successfully`, severity: "success" }
+            };
+        }
+        catch (error) {
+            yield {
+                type: "action:taskResult",
+                data: { action: "writeFile", result: { error: error.message }, toolCallId },
+            };
+            yield {
+                type: "file-system:status",
+                data: { message: `File write failed: ${error.message}`, severity: "error" }
+            };
+        }
+    });
+    builder.on("action:listFiles", async function* (event, { state }) {
+        const { path: dirPath, toolCallId } = event.data;
+        yield {
+            type: "file-system:status",
+            data: { message: `Listing files in: ${dirPath}` }
+        };
+        try {
+            const files = await fs.readdir(resolvePath(dirPath, state.cwd));
+            yield {
+                type: "file-system:status",
+                data: { message: `Files listed successfully`, severity: "success" }
+            };
+            yield {
+                type: "action:taskResult",
+                data: { action: "listFiles", result: { files }, toolCallId },
+            };
+        }
+        catch (error) {
+            yield {
+                type: "file-system:status",
+                data: { message: `Files listing failed: ${error.message}`, severity: "error" }
+            };
+            yield {
+                type: "action:taskResult",
+                data: { action: "listFiles", result: { error: error.message }, toolCallId },
+            };
+        }
+    });
+    builder.on("action:deleteFile", async function* (event, { state }) {
+        const { path: filePath, toolCallId } = event.data;
+        yield {
+            type: "file-system:status",
+            data: { message: `Deleting file: ${filePath}` }
+        };
+        try {
+            await fs.unlink(resolvePath(filePath, state.cwd));
+            yield {
+                type: "action:taskResult",
+                data: { action: "deleteFile", result: { success: true }, toolCallId },
+            };
+            yield {
+                type: "file-system:status",
+                data: { message: `File deleted successfully`, severity: "success" }
+            };
+        }
+        catch (error) {
+            yield {
+                type: "action:taskResult",
+                data: { action: "deleteFile", result: { error: error.message }, toolCallId },
+            };
+            yield {
+                type: "file-system:status",
+                data: { message: `File deletion failed: ${error.message}`, severity: "error" }
+            };
+        }
+    });
+};

package/dist/plugins/file-system/ui.js

@@ -0,0 +1,6 @@
+import { ui } from "@melony/ui-kit/server";
+export const fileSystemUIPlugin = () => (builder) => {
+    builder.on("file-system:status", async function* (event) {
+        yield ui.event(ui.status(event.data.message, event.data.severity));
+    });
+};

package/dist/plugins/llm/index.js

@@ -0,0 +1,81 @@
+import { streamText } from "ai";
+import { ui } from "@melony/ui-kit";
+/**
+ * Builds a simple history summary from recent messages.
+ * Keeps the last N messages as simple role/content pairs.
+ */
+function getRecentHistory(messages, maxMessages) {
+    return messages.slice(-maxMessages);
+}
+/**
+ * LLM Plugin for Melony.
+ * Automatically handles text events and routes them through an LLM using Vercel AI SDK.
+ * It can also automatically trigger events based on tool calls.
+ */
+export const llmPlugin = (options) => (builder) => {
+    const { model, system, toolDefinitions = {}, actionEventPrefix = "action:", promptInputType = "user:text", actionResultInputType = "action:taskResult", completionEventType } = options;
+    async function* routeToLLM(newMessage, context) {
+        const state = context.state;
+        if (!state.messages) {
+            state.messages = [];
+        }
+        // Add new message to history
+        state.messages.push(newMessage);
+        // Evaluate dynamic system prompt if it's a function
+        const systemPrompt = typeof system === "function" ? await system(context) : system;
+        const result = streamText({
+            model,
+            system: systemPrompt,
+            messages: getRecentHistory(state.messages, 20).map(m => m.role === "system" ? { role: "user", content: `System: ${m.content}` } : m),
+            tools: toolDefinitions,
+        });
+        let assistantText = "";
+        for await (const delta of result.textStream) {
+            assistantText += delta;
+            yield {
+                type: "assistant:text-delta",
+                data: { delta },
+            };
+        }
+        // Wait for tool calls to complete
+        const toolCalls = await result.toolCalls;
+        // Store assistant response as simple text
+        if (assistantText) {
+            state.messages.push({
+                role: "assistant",
+                content: assistantText,
+            });
+            if (completionEventType) {
+                yield {
+                    type: completionEventType,
+                    data: { content: assistantText },
+                };
+            }
+        }
+        const usage = await result.usage;
+        yield ui.event(ui.status(`Usage: ${usage.totalTokens} tokens`, "info"));
+        // Emit tool call events
+        for (const call of toolCalls) {
+            yield {
+                type: `${actionEventPrefix}${call.toolName}`,
+                data: {
+                    ...call.input,
+                    toolCallId: call.toolCallId,
+                },
+            };
+        }
+    }
+    // Handle user text input
+    builder.on(promptInputType, async function* (event, context) {
+        const content = event.data.content;
+        yield* routeToLLM({ role: "user", content }, context);
+    });
+    // Feed action results back to the LLM as user messages (with a System prefix)
+    // We use "user" role instead of "system" to avoid errors with providers like Anthropic
+    // that don't support multiple system messages or system messages after the first turn.
+    builder.on(actionResultInputType, async function* (event, context) {
+        const { action, result } = event.data;
+        const summary = typeof result === "string" ? result : JSON.stringify(result);
+        yield* routeToLLM({ role: "user", content: `System: Action "${action}" completed: ${summary}` }, context);
+    });
+};