openbot 0.2.12 → 0.2.13

package/dist/plugins/memory/memory.js

@@ -1,122 +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.mkdir(memoryDir, { recursive: true });
-        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`;
-            await fs.mkdir(journalDir, { recursive: true });
-            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/memory/prompt.js

@@ -1,55 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-// --- Prompt Builder ---
-/**
- * Build the memory's section of the system prompt.
- *
- * Includes only what the memory owns:
- * - Environment context
- * - Agent definition (from AGENT.md)
- * - 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 buildMemoryPrompt(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>
-- Time: ${now.toLocaleString()} (${Intl.DateTimeFormat().resolvedOptions().timeZone})
-- CWD: ${currentCwd}
-- Bot Home: ${baseDir}
-</environment>`);
-    // 2. Agent definition (manual edit only)
-    try {
-        const agentPath = path.join(baseDir, "AGENT.md");
-        const agentMd = await fs.readFile(agentPath, "utf-8");
-        if (agentMd.trim()) {
-            parts.push(`<agent_definition>\n${agentMd.trim()}\n</agent_definition>`);
-        }
-    }
-    catch {
-        // Skip if AGENT.md doesn't exist yet
-    }
-    // 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(`<memory_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
-</memory_tools>`);
-    return `\n${parts.join("\n\n")}\n`;
-}

package/dist/plugins/memory/types.js

@@ -1,45 +0,0 @@
-import { z } from "zod";
-// --- Tool Definitions ---
-export const memoryToolDefinitions = {
-    // 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"),
-        }),
-    },
-};