openbot 0.2.12 → 0.2.13

package/dist/plugins/brain/index.js

@@ -1,204 +0,0 @@
-import { ui } from "@melony/ui-kit/server";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { createMemoryModule } from "./memory.js";
-import { buildBrainPrompt } from "./prompt.js";
-import { statusWidget } from "../../ui/widgets/status.js";
-// Re-exports
-export { brainToolDefinitions } from "./types.js";
-export { buildBrainPrompt } from "./prompt.js";
-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 (base context + memory).
- */
-export function createBrainPromptBuilder(baseDir, baseContext) {
-    const expandedBase = expandPath(baseDir);
-    const modules = {
-        memory: createMemoryModule(expandedBase),
-    };
-    return async (context) => buildBrainPrompt(expandedBase, modules, baseContext || "", context);
-}
-// --- Plugin ---
-/**
- * Brain Plugin for Melony
- *
- * Provides memory capabilities (long-term memory + recall).
- * Skills are managed by the separate skills plugin.
- *
- * Architecture: thin facade over memory module.
- */
-export const brainPlugin = (options) => (builder) => {
-    const { baseDir } = options;
-    const expandedBase = expandPath(baseDir);
-    // Create sub-module
-    const memory = createMemoryModule(expandedBase);
-    // ─── Initialization ───────────────────────────────────────────────
-    builder.on("init", async function* (_event) {
-        yield {
-            type: "brain:status",
-            data: { message: "Initializing memory..." },
-        };
-        await fs.mkdir(expandedBase, { recursive: true, mode: 0o700 });
-        await memory.initialize();
-        yield {
-            type: "brain:status",
-            data: { message: "Memory 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:result",
-                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:result",
-                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:result",
-                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:result",
-                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:result",
-                data: {
-                    action: "forget",
-                    toolCallId,
-                    result: {
-                        success: removed,
-                        message: removed
-                            ? "Memory removed"
-                            : `Memory "${memoryId}" not found`,
-                    },
-                },
-            };
-        }
-        catch (error) {
-            yield {
-                type: "action:result",
-                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:result",
-                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:result",
-                data: {
-                    action: "journal",
-                    toolCallId,
-                    result: { error: error.message },
-                },
-            };
-        }
-    });
-    builder.on("brain:status", async function* (event) {
-        yield ui.event(statusWidget(event.data.message, event.data.severity));
-    });
-};
-export default brainPlugin;

package/dist/plugins/brain/memory.js

@@ -1,120 +0,0 @@
-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

@@ -1,46 +0,0 @@
-// --- Prompt Builder ---
-/**
- * Build the brain's section of the system prompt.
- *
- * Includes only what the brain owns:
- * - Environment context
- * - Base context from settings (optional)
- * - A handful of the most recent memories
- * - Memory 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, baseContext, context) {
-    const parts = [];
-    const state = context?.state;
-    const currentCwd = state?.cwd || process.cwd();
-    // 1. Environment context
-    const now = new Date();
-    parts.push(`<environment>
-- Time: ${now.toLocaleString()} (${Intl.DateTimeFormat().resolvedOptions().timeZone})
-- CWD: ${currentCwd}
-- Bot Home: ${baseDir}
-</environment>`);
-    // 2. Base context from settings (optional)
-    if (baseContext.trim()) {
-        parts.push(`<base_context>\n${baseContext.trim()}\n</base_context>`);
-    }
-    // 3. Recent memories (lean — just a few to keep context fresh)
-    const recentFacts = await modules.memory.getRecentFacts(5);
-    if (recentFacts.length > 0) {
-        const factsList = recentFacts
-            .map((f) => `- ${f.content}${f.tags.length > 0 ? ` [${f.tags.join(", ")}]` : ""}`)
-            .join("\n");
-        parts.push(`<recent_memories>\n${factsList}\n</recent_memories>`);
-    }
-    // 4. Memory capabilities
-    parts.push(`<brain_tools>
-Use these to manage your persistent state:
-- \`remember(content, tags)\`: Store facts/preferences
-- \`recall(query, tags)\`: Search long-term memory
-- \`forget(memoryId)\`: Remove outdated info
-- \`journal(content)\`: Record session reflections
-</brain_tools>`);
-    return `\n${parts.join("\n\n")}\n`;
-}

package/dist/plugins/brain/types.js

@@ -1,45 +0,0 @@
-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"),
-        }),
-    },
-};

package/dist/plugins/brain/ui.js

@@ -1,7 +0,0 @@
-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));
-    });
-};