openbot 0.1.18 → 0.1.22

package/dist/plugins/brain/index.js

@@ -0,0 +1,269 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { createIdentityModule } from "./identity.js";
+import { createMemoryModule } from "./memory.js";
+import { buildBrainPrompt } from "./prompt.js";
+// Re-exports
+export { brainToolDefinitions } from "./types.js";
+export { buildBrainPrompt } from "./prompt.js";
+// --- Helpers ---
+function expandPath(p) {
+    if (p.startsWith("~/")) {
+        return path.join(process.env.HOME || "", p.slice(2));
+    }
+    return p;
+}
+/**
+ * Create a prompt-builder function bound to a baseDir.
+ * Returns the brain's portion of the system prompt (identity + memory).
+ */
+export function createBrainPromptBuilder(baseDir) {
+    const expandedBase = expandPath(baseDir);
+    const modules = {
+        identity: createIdentityModule(expandedBase),
+        memory: createMemoryModule(expandedBase),
+    };
+    return async (context) => buildBrainPrompt(expandedBase, modules, context);
+}
+// --- Plugin ---
+/**
+ * Brain Plugin for Melony
+ *
+ * Provides the bot's "brain": identity and long-term memory with recall.
+ * Skills are managed by the separate skills plugin.
+ *
+ * Architecture: thin facade that delegates to focused sub-modules
+ * (identity, memory) — each independently testable and replaceable.
+ */
+export const brainPlugin = (options) => (builder) => {
+    const { baseDir } = options;
+    const expandedBase = expandPath(baseDir);
+    // Create sub-modules
+    const identity = createIdentityModule(expandedBase);
+    const memory = createMemoryModule(expandedBase);
+    // ─── Initialization ───────────────────────────────────────────────
+    builder.on("init", async function* (_event, context) {
+        yield {
+            type: "brain:status",
+            data: { message: "Initializing brain..." },
+        };
+        await fs.mkdir(expandedBase, { recursive: true, mode: 0o700 });
+        await identity.initialize();
+        await memory.initialize();
+        yield {
+            type: "brain:status",
+            data: { message: "Brain initialized", severity: "success" },
+        };
+    });
+    // ─── Memory: Remember ─────────────────────────────────────────────
+    builder.on("action:remember", async function* (event) {
+        const { content, tags = [], toolCallId } = event.data;
+        try {
+            const entry = await memory.store(content, tags);
+            yield {
+                type: "brain:status",
+                data: { message: "Remembered", severity: "success" },
+            };
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "remember",
+                    toolCallId,
+                    result: {
+                        success: true,
+                        memoryId: entry.id,
+                        message: `Stored in memory with id ${entry.id}`,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            yield {
+                type: "brain:status",
+                data: {
+                    message: `Failed to remember: ${error.message}`,
+                    severity: "error",
+                },
+            };
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "remember",
+                    toolCallId,
+                    result: { error: error.message },
+                },
+            };
+        }
+    });
+    // ─── Memory: Recall ────────────────────────────────────────────────
+    builder.on("action:recall", async function* (event) {
+        const { query, tags, limit, toolCallId } = event.data;
+        try {
+            const results = await memory.recall(query, { tags, limit });
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "recall",
+                    toolCallId,
+                    result: {
+                        count: results.length,
+                        memories: results.map((e) => ({
+                            id: e.id,
+                            content: e.content,
+                            tags: e.tags,
+                            createdAt: e.createdAt,
+                        })),
+                    },
+                },
+            };
+        }
+        catch (error) {
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "recall",
+                    toolCallId,
+                    result: { error: error.message },
+                },
+            };
+        }
+    });
+    // ─── Memory: Forget ────────────────────────────────────────────────
+    builder.on("action:forget", async function* (event) {
+        const { memoryId, toolCallId } = event.data;
+        try {
+            const removed = await memory.forget(memoryId);
+            yield {
+                type: "brain:status",
+                data: {
+                    message: removed ? "Memory removed" : "Memory not found",
+                    severity: removed ? "success" : "error",
+                },
+            };
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "forget",
+                    toolCallId,
+                    result: {
+                        success: removed,
+                        message: removed
+                            ? "Memory removed"
+                            : `Memory "${memoryId}" not found`,
+                    },
+                },
+            };
+        }
+        catch (error) {
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "forget",
+                    toolCallId,
+                    result: { error: error.message },
+                },
+            };
+        }
+    });
+    // ─── Memory: Journal ───────────────────────────────────────────────
+    builder.on("action:journal", async function* (event) {
+        const { content, toolCallId } = event.data;
+        try {
+            await memory.addJournalEntry(content);
+            yield {
+                type: "brain:status",
+                data: { message: "Journal entry added", severity: "success" },
+            };
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "journal",
+                    toolCallId,
+                    result: { success: true, message: "Journal entry added" },
+                },
+            };
+        }
+        catch (error) {
+            yield {
+                type: "brain:status",
+                data: {
+                    message: `Failed to journal: ${error.message}`,
+                    severity: "error",
+                },
+            };
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "journal",
+                    toolCallId,
+                    result: { error: error.message },
+                },
+            };
+        }
+    });
+    // ─── Identity: Update ──────────────────────────────────────────────
+    builder.on("action:updateIdentity", async function* (event) {
+        const { content, toolCallId } = event.data;
+        try {
+            await identity.updateIdentity(content);
+            yield {
+                type: "brain:status",
+                data: { message: "Identity updated", severity: "success" },
+            };
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "updateIdentity",
+                    toolCallId,
+                    result: {
+                        success: true,
+                        message: "Identity updated. Changes will take effect on next initialization.",
+                    },
+                },
+            };
+        }
+        catch (error) {
+            yield {
+                type: "brain:status",
+                data: {
+                    message: `Failed to update identity: ${error.message}`,
+                    severity: "error",
+                },
+            };
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "updateIdentity",
+                    toolCallId,
+                    result: { error: error.message },
+                },
+            };
+        }
+    });
+    // ─── Identity: Read ────────────────────────────────────────────────
+    builder.on("action:readIdentity", async function* (event) {
+        const { file, toolCallId } = event.data;
+        try {
+            const content = await identity.readFile(file);
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "readIdentity",
+                    toolCallId,
+                    result: { file, content },
+                },
+            };
+        }
+        catch (error) {
+            yield {
+                type: "action:taskResult",
+                data: {
+                    action: "readIdentity",
+                    toolCallId,
+                    result: { error: `Could not read ${file}: ${error.message}` },
+                },
+            };
+        }
+    });
+};
+export default brainPlugin;

package/dist/plugins/brain/memory.js

@@ -0,0 +1,120 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+// --- Factory ---
+export function createMemoryModule(baseDir) {
+    const memoryDir = path.join(baseDir, "memory");
+    const indexPath = path.join(memoryDir, "index.json");
+    const journalDir = path.join(memoryDir, "journal");
+    // --- Helpers ---
+    async function loadIndex() {
+        try {
+            const data = await fs.readFile(indexPath, "utf-8");
+            return JSON.parse(data);
+        }
+        catch {
+            return { entries: [] };
+        }
+    }
+    async function saveIndex(index) {
+        await fs.writeFile(indexPath, JSON.stringify(index, null, 2), "utf-8");
+    }
+    function generateId() {
+        const timestamp = Date.now().toString(36);
+        const random = Math.random().toString(36).substring(2, 6);
+        return `mem_${timestamp}_${random}`;
+    }
+    /**
+     * Simple keyword-based relevance scoring.
+     * Splits query into terms (ignoring short words) and counts how many
+     * appear in the entry's content + tags. Returns a 0-1 score.
+     */
+    function scoreMatch(entry, query) {
+        const queryTerms = query
+            .toLowerCase()
+            .split(/\s+/)
+            .filter((t) => t.length > 2);
+        if (queryTerms.length === 0)
+            return 0;
+        const searchable = `${entry.content} ${entry.tags.join(" ")}`.toLowerCase();
+        let matched = 0;
+        for (const term of queryTerms) {
+            if (searchable.includes(term)) {
+                matched++;
+            }
+        }
+        return matched / queryTerms.length;
+    }
+    // --- Module ---
+    return {
+        async initialize() {
+            await fs.mkdir(memoryDir, { recursive: true });
+            await fs.mkdir(journalDir, { recursive: true });
+            try {
+                await fs.access(indexPath);
+            }
+            catch {
+                await saveIndex({ entries: [] });
+            }
+        },
+        async store(content, tags = []) {
+            const index = await loadIndex();
+            const entry = {
+                id: generateId(),
+                content,
+                tags,
+                createdAt: new Date().toISOString(),
+            };
+            index.entries.push(entry);
+            await saveIndex(index);
+            return entry;
+        },
+        async recall(query, options) {
+            const { tags, limit = 5 } = options || {};
+            const index = await loadIndex();
+            let candidates = index.entries;
+            // Filter by tags if provided
+            if (tags && tags.length > 0) {
+                candidates = candidates.filter((entry) => tags.some((tag) => entry.tags.includes(tag)));
+            }
+            // Score and sort by relevance
+            const scored = candidates
+                .map((entry) => ({ entry, score: scoreMatch(entry, query) }))
+                .filter(({ score }) => score > 0)
+                .sort((a, b) => b.score - a.score)
+                .slice(0, limit);
+            // If no keyword matches found, fall back to most recent entries
+            if (scored.length === 0) {
+                return candidates.slice(-limit).reverse();
+            }
+            return scored.map(({ entry }) => entry);
+        },
+        async forget(memoryId) {
+            const index = await loadIndex();
+            const before = index.entries.length;
+            index.entries = index.entries.filter((e) => e.id !== memoryId);
+            if (index.entries.length < before) {
+                await saveIndex(index);
+                return true;
+            }
+            return false;
+        },
+        async addJournalEntry(content) {
+            const today = new Date().toISOString().split("T")[0]; // e.g., "2026-02-12"
+            const journalPath = path.join(journalDir, `${today}.md`);
+            const timestamp = new Date().toLocaleTimeString();
+            const entry = `\n## ${timestamp}\n${content}\n`;
+            try {
+                await fs.access(journalPath);
+                await fs.appendFile(journalPath, entry, "utf-8");
+            }
+            catch {
+                const header = `# Journal - ${today}\n`;
+                await fs.writeFile(journalPath, header + entry, "utf-8");
+            }
+        },
+        async getRecentFacts(limit = 3) {
+            const index = await loadIndex();
+            return index.entries.slice(-limit);
+        },
+    };
+}

package/dist/plugins/brain/prompt.js

@@ -0,0 +1,64 @@
+// --- Prompt Builder ---
+/**
+ * Build the brain's section of the system prompt.
+ *
+ * Includes only what the brain owns:
+ * - Environment context
+ * - Identity + Soul (small, static)
+ * - A handful of the most recent memories
+ * - Brain capability instructions
+ *
+ * Skills are handled by the separate skills plugin and composed
+ * at the top level in open-bot.ts.
+ */
+export async function buildBrainPrompt(baseDir, modules, context) {
+    const parts = [];
+    const state = context?.state;
+    const currentCwd = state?.cwd || process.cwd();
+    // 1. Environment context
+    const now = new Date();
+    parts.push(`## Environment
+You are running as a global system agent.
+- **Current Time**: ${now.toLocaleString()} (${Intl.DateTimeFormat().resolvedOptions().timeZone})
+- **Current Working Directory (CWD)**: ${currentCwd}
+- **System Access**: You have access to the entire file system (root: /).
+- **Bot Home (Internal State)**: ${baseDir}
+
+### Path Rules:
+1. **Shell Commands**: All commands (executeCommand) run in the CWD: ${currentCwd}.
+2. **File Operations**: Relative paths in readFile, writeFile, listFiles, etc. resolve against the CWD.
+3. **Changing Directory**: Use \`cd <path>\` in executeCommand to move. Your CWD is persisted across turns.
+4. **Skills/Memory**: To access your own skills and memory, use absolute paths starting with "${baseDir}/".
+
+When you want to execute skill scripts, always use the full path to the skill directory.`);
+    // 2. Identity (small, always included)
+    const soul = await modules.identity.getSoul();
+    if (soul)
+        parts.push(soul);
+    const identity = await modules.identity.getIdentity();
+    if (identity)
+        parts.push(identity);
+    // 3. Recent memories (lean — just a few to keep context fresh)
+    const recentFacts = await modules.memory.getRecentFacts(3);
+    if (recentFacts.length > 0) {
+        const factsList = recentFacts
+            .map((f) => `- ${f.content}${f.tags.length > 0 ? ` [${f.tags.join(", ")}]` : ""}`)
+            .join("\n");
+        parts.push(`## Recent Memory
+
+These are your most recent memories. Use \`recall\` to search for more specific information.
+
+${factsList}`);
+    }
+    // 4. Brain capabilities
+    parts.push(`## Brain Capabilities
+
+You have a brain with long-term memory:
+- Use \`remember\` to store important facts, user preferences, or learned context
+- Use \`recall\` to search your memory when you need past information
+- Use \`forget\` to remove outdated or incorrect memories
+- Use \`journal\` to record session notes and reflections
+- Use \`updateIdentity\` to refine your personality in IDENTITY.md
+- SOUL.md contains your core values and is protected from modification`);
+    return parts.join("\n\n");
+}

package/dist/plugins/brain/types.js

@@ -0,0 +1,60 @@
+import { z } from "zod";
+// --- Tool Definitions ---
+export const brainToolDefinitions = {
+    // Memory tools
+    remember: {
+        description: "Store something important in long-term memory. Use for user preferences, learned facts, project context, etc.",
+        inputSchema: z.object({
+            content: z
+                .string()
+                .describe("The information to remember"),
+            tags: z
+                .array(z.string())
+                .optional()
+                .describe("Tags for categorization (e.g., 'user-preference', 'project', 'learning')"),
+        }),
+    },
+    recall: {
+        description: "Search your memory for relevant information. Use before answering questions that might relate to past interactions.",
+        inputSchema: z.object({
+            query: z.string().describe("What to search for in memory"),
+            tags: z
+                .array(z.string())
+                .optional()
+                .describe("Filter by specific tags"),
+            limit: z
+                .number()
+                .optional()
+                .describe("Max results to return (default: 5)"),
+        }),
+    },
+    forget: {
+        description: "Remove a specific memory entry by ID.",
+        inputSchema: z.object({
+            memoryId: z
+                .string()
+                .describe("The ID of the memory entry to remove"),
+        }),
+    },
+    journal: {
+        description: "Add a journal entry for today. Use for session notes, learnings, and reflections.",
+        inputSchema: z.object({
+            content: z.string().describe("Journal entry content"),
+        }),
+    },
+    // Identity tools
+    updateIdentity: {
+        description: "Update your identity file to refine your personality and traits.",
+        inputSchema: z.object({
+            content: z.string().describe("New content for IDENTITY.md"),
+        }),
+    },
+    readIdentity: {
+        description: "Read your current identity or soul configuration.",
+        inputSchema: z.object({
+            file: z
+                .enum(["IDENTITY.md", "SOUL.md"])
+                .describe("Which identity file to read"),
+        }),
+    },
+};

package/dist/plugins/brain/ui.js

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