openbot 0.2.3 → 0.2.6

package/dist/plugins/brain/index.js

@@ -1,7 +1,6 @@
 import { ui } from "@melony/ui-kit/server";
 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";
 import { statusWidget } from "../../ui/widgets/status.js";
@@ -16,44 +15,40 @@ function expandPath(p) {
 }
 /**
  * Create a prompt-builder function bound to a baseDir.
- * Returns the brain's portion of the system prompt (identity + memory).
+ * Returns the brain's portion of the system prompt (base context + memory).
  */
-export function createBrainPromptBuilder(baseDir) {
+export function createBrainPromptBuilder(baseDir, baseContext) {
     const expandedBase = expandPath(baseDir);
     const modules = {
-        identity: createIdentityModule(expandedBase),
         memory: createMemoryModule(expandedBase),
     };
-    return async (context) => buildBrainPrompt(expandedBase, modules, context);
+    return async (context) => buildBrainPrompt(expandedBase, modules, baseContext || "", context);
 }
 // --- Plugin ---
 /**
  * Brain Plugin for Melony
  *
- * Provides the bot's "brain": identity and long-term memory with recall.
+ * Provides memory capabilities (long-term memory + 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.
+ * Architecture: thin facade over memory module.
  */
 export const brainPlugin = (options) => (builder) => {
     const { baseDir } = options;
     const expandedBase = expandPath(baseDir);
-    // Create sub-modules
-    const identity = createIdentityModule(expandedBase);
+    // Create sub-module
     const memory = createMemoryModule(expandedBase);
     // ─── Initialization ───────────────────────────────────────────────
-    builder.on("init", async function* (_event, context) {
+    builder.on("init", async function* (_event) {
         yield {
             type: "brain:status",
-            data: { message: "Initializing brain..." },
+            data: { message: "Initializing memory..." },
         };
         await fs.mkdir(expandedBase, { recursive: true, mode: 0o700 });
-        await identity.initialize();
         await memory.initialize();
         yield {
             type: "brain:status",
-            data: { message: "Brain initialized", severity: "success" },
+            data: { message: "Memory initialized", severity: "success" },
         };
     });
     // ─── Memory: Remember ─────────────────────────────────────────────
@@ -66,7 +61,7 @@ export const brainPlugin = (options) => (builder) => {
                 data: { message: "Remembered", severity: "success" },
             };
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "remember",
                     toolCallId,
@@ -87,7 +82,7 @@ export const brainPlugin = (options) => (builder) => {
                 },
             };
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "remember",
                     toolCallId,
@@ -102,7 +97,7 @@ export const brainPlugin = (options) => (builder) => {
         try {
             const results = await memory.recall(query, { tags, limit });
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "recall",
                     toolCallId,
@@ -120,7 +115,7 @@ export const brainPlugin = (options) => (builder) => {
         }
         catch (error) {
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "recall",
                     toolCallId,
@@ -142,7 +137,7 @@ export const brainPlugin = (options) => (builder) => {
                 },
             };
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "forget",
                     toolCallId,
@@ -157,7 +152,7 @@ export const brainPlugin = (options) => (builder) => {
         }
         catch (error) {
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "forget",
                     toolCallId,
@@ -176,7 +171,7 @@ export const brainPlugin = (options) => (builder) => {
                 data: { message: "Journal entry added", severity: "success" },
             };
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "journal",
                     toolCallId,
@@ -193,7 +188,7 @@ export const brainPlugin = (options) => (builder) => {
                 },
             };
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "journal",
                     toolCallId,
@@ -202,70 +197,6 @@ export const brainPlugin = (options) => (builder) => {
             };
         }
     });
-    // ─── 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}` },
-                },
-            };
-        }
-    });
     builder.on("brain:status", async function* (event) {
         yield ui.event(statusWidget(event.data.message, event.data.severity));
     });

package/dist/plugins/brain/memory.js

@@ -114,7 +114,7 @@ export function createMemoryModule(baseDir) {
         },
         async getRecentFacts(limit = 3) {
             const index = await loadIndex();
-            return index.entries.slice(-limit);
+            return (index?.entries ?? []).slice(-limit);
         },
     };
 }

package/dist/plugins/brain/prompt.js

@@ -4,14 +4,14 @@
  *
  * Includes only what the brain owns:
  * - Environment context
- * - Identity + Soul (small, static)
+ * - Base context from settings (optional)
  * - A handful of the most recent memories
- * - Brain capability instructions
+ * - 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, context) {
+export async function buildBrainPrompt(baseDir, modules, baseContext, context) {
     const parts = [];
     const state = context?.state;
     const currentCwd = state?.cwd || process.cwd();
@@ -22,13 +22,10 @@ export async function buildBrainPrompt(baseDir, modules, context) {
 - CWD: ${currentCwd}
 - Bot Home: ${baseDir}
 </environment>`);
-    // 2. Identity (small, always included)
-    const identity = await modules.identity.getIdentity();
-    if (identity)
-        parts.push(`<identity>\n${identity}\n</identity>`);
-    const soul = await modules.identity.getSoul();
-    if (soul)
-        parts.push(`<soul>\n${soul}\n</soul>`);
+    // 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) {
@@ -37,15 +34,13 @@ export async function buildBrainPrompt(baseDir, modules, context) {
             .join("\n");
         parts.push(`<recent_memories>\n${factsList}\n</recent_memories>`);
     }
-    // 4. Brain capabilities
+    // 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
-- \`updateIdentity(content)\`: Refine your persona
-- \`readIdentity(file)\`: Inspect SOUL.md or IDENTITY.md
 </brain_tools>`);
     return `\n${parts.join("\n\n")}\n`;
 }

package/dist/plugins/brain/types.js

@@ -42,19 +42,4 @@ export const brainToolDefinitions = {
             content: z.string().describe("Journal entry content"),
         }),
     },
-    // Identity tools
-    updateIdentity: {
-        description: "Update your identity file to refine your personality and traits. Start it with # Identity.",
-        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/file-system/index.js

@@ -56,7 +56,7 @@ export const fileSystemPlugin = (options = {}) => (builder) => {
         try {
             const content = await fs.readFile(resolvePath(filePath, state.cwd), "utf-8");
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: {
                     action: "readFile",
                     result: { content: truncate(content, maxFileReadLength) },
@@ -70,7 +70,7 @@ export const fileSystemPlugin = (options = {}) => (builder) => {
         }
         catch (error) {
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: { action: "readFile", result: { error: error.message }, toolCallId },
             };
             yield {
@@ -90,7 +90,7 @@ export const fileSystemPlugin = (options = {}) => (builder) => {
             await fs.mkdir(path.dirname(fullPath), { recursive: true });
             await fs.writeFile(fullPath, content, "utf-8");
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: { action: "writeFile", result: { success: true }, toolCallId },
             };
             yield {
@@ -100,7 +100,7 @@ export const fileSystemPlugin = (options = {}) => (builder) => {
         }
         catch (error) {
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: { action: "writeFile", result: { error: error.message }, toolCallId },
             };
             yield {
@@ -122,7 +122,7 @@ export const fileSystemPlugin = (options = {}) => (builder) => {
                 data: { message: `Files listed successfully`, severity: "success" }
             };
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: { action: "listFiles", result: { files }, toolCallId },
             };
         }
@@ -132,7 +132,7 @@ export const fileSystemPlugin = (options = {}) => (builder) => {
                 data: { message: `Files listing failed: ${error.message}`, severity: "error" }
             };
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: { action: "listFiles", result: { error: error.message }, toolCallId },
             };
         }
@@ -146,7 +146,7 @@ export const fileSystemPlugin = (options = {}) => (builder) => {
         try {
             await fs.unlink(resolvePath(filePath, state.cwd));
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: { action: "deleteFile", result: { success: true }, toolCallId },
             };
             yield {
@@ -156,7 +156,7 @@ export const fileSystemPlugin = (options = {}) => (builder) => {
         }
         catch (error) {
             yield {
-                type: "action:taskResult",
+                type: "action:result",
                 data: { action: "deleteFile", result: { error: error.message }, toolCallId },
             };
             yield {

package/dist/plugins/llm/context-shaping.js

@@ -0,0 +1,177 @@
+const DEFAULT_OPTIONS = {
+    maxRecentRawMessages: 4,
+    maxRelevantMessages: 6,
+    maxContextChars: 12000,
+    maxTurnSummaries: 20,
+    maxConstraints: 8,
+};
+const STOP_WORDS = new Set([
+    "the",
+    "and",
+    "for",
+    "that",
+    "with",
+    "this",
+    "from",
+    "have",
+    "your",
+    "will",
+    "would",
+    "should",
+    "could",
+    "about",
+    "what",
+    "when",
+    "where",
+    "which",
+    "into",
+    "just",
+    "like",
+    "than",
+    "then",
+    "there",
+    "their",
+    "them",
+    "also",
+    "need",
+    "want",
+    "please",
+]);
+function mergeOptions(overrides) {
+    return {
+        ...DEFAULT_OPTIONS,
+        ...(overrides ?? {}),
+    };
+}
+function clip(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, maxChars - 3)}...`;
+}
+function toSearchText(message) {
+    return message.content.toLowerCase();
+}
+function tokenize(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, " ")
+        .split(/\s+/)
+        .filter((token) => token.length > 2 && !STOP_WORDS.has(token));
+}
+function overlapScore(messageText, queryTerms) {
+    if (queryTerms.length === 0)
+        return 0;
+    let matched = 0;
+    for (const term of queryTerms) {
+        if (messageText.includes(term))
+            matched += 1;
+    }
+    return matched / queryTerms.length;
+}
+function recencyBoost(index, total) {
+    if (total <= 1)
+        return 0;
+    return index / (total - 1);
+}
+function estimateChars(messages) {
+    return messages.reduce((sum, m) => sum + (m.content?.length ?? 0), 0);
+}
+function buildContextBrief(state, maxChars) {
+    if (!state)
+        return "";
+    const lines = [];
+    if (state.currentGoal)
+        lines.push(`Current objective: ${state.currentGoal}`);
+    if (state.constraints && state.constraints.length > 0) {
+        lines.push(`Constraints: ${state.constraints.join(" | ")}`);
+    }
+    if (state.rollingSummary)
+        lines.push(`Recent summary: ${state.rollingSummary}`);
+    if (lines.length === 0)
+        return "";
+    return clip(`System context for this turn:\n${lines.map((line) => `- ${line}`).join("\n")}`, maxChars);
+}
+export function buildShapedContext(input) {
+    const options = mergeOptions(input.options);
+    const messages = input.messages;
+    if (messages.length <= options.maxRecentRawMessages) {
+        const brief = buildContextBrief(input.contextState, 1500);
+        return brief
+            ? [{ role: "user", content: brief }, ...messages]
+            : messages;
+    }
+    const recentStart = Math.max(0, messages.length - options.maxRecentRawMessages);
+    const recent = messages.slice(recentStart);
+    const older = messages.slice(0, recentStart);
+    const latestUser = [...messages]
+        .reverse()
+        .find((message) => message.role === "user");
+    const queryTerms = latestUser ? tokenize(latestUser.content) : [];
+    const scored = older
+        .map((message, index) => {
+        const text = toSearchText(message);
+        const relevance = overlapScore(text, queryTerms);
+        const score = relevance * 0.8 + recencyBoost(index, older.length) * 0.2;
+        return { index, score };
+    })
+        .filter((row) => row.score > 0)
+        .sort((a, b) => b.score - a.score)
+        .slice(0, options.maxRelevantMessages)
+        .sort((a, b) => a.index - b.index);
+    const selectedOlder = scored.map((row) => older[row.index]);
+    const brief = buildContextBrief(input.contextState, 1500);
+    let selected = [
+        ...(brief ? [{ role: "user", content: brief }] : []),
+        ...selectedOlder,
+        ...recent,
+    ];
+    while (estimateChars(selected) > options.maxContextChars) {
+        const removableIndex = selected.findIndex((message, index) => {
+            if (brief && index === 0)
+                return false;
+            return index < selected.length - options.maxRecentRawMessages;
+        });
+        if (removableIndex === -1)
+            break;
+        selected.splice(removableIndex, 1);
+    }
+    return selected;
+}
+function extractConstraints(text, existing, maxConstraints) {
+    const hasConstraintLanguage = /\b(do not|don't|must|never|always|only)\b/i.test(text);
+    if (!hasConstraintLanguage)
+        return existing;
+    const normalized = clip(text.trim().replace(/\s+/g, " "), 180);
+    if (!normalized)
+        return existing;
+    if (existing.includes(normalized))
+        return existing;
+    const next = [...existing, normalized];
+    return next.slice(-maxConstraints);
+}
+export function updateContextState(input, optionsOverride) {
+    const options = mergeOptions(optionsOverride);
+    const existing = input.contextState ?? {};
+    const constraints = extractConstraints(input.latestUserMessage, existing.constraints ?? [], options.maxConstraints);
+    const compactUser = clip(input.latestUserMessage.trim().replace(/\s+/g, " "), 200);
+    const compactAssistant = clip(input.latestAssistantMessage.trim().replace(/\s+/g, " "), 240);
+    const turnSummary = compactUser || compactAssistant
+        ? `U: ${compactUser || "-"} | A: ${compactAssistant || "-"}`
+        : "";
+    const turnSummaries = turnSummary
+        ? [...(existing.turnSummaries ?? []), turnSummary].slice(-options.maxTurnSummaries)
+        : existing.turnSummaries ?? [];
+    const rollingSummary = turnSummaries.slice(-6).join(" || ");
+    const latestUserMessage = input.latestUserMessage.trim();
+    const isToolEcho = latestUserMessage.startsWith("System: Action ");
+    const currentGoal = !isToolEcho && latestUserMessage
+        ? clip(latestUserMessage, 240)
+        : existing.currentGoal;
+    return {
+        currentGoal,
+        constraints,
+        turnSummaries,
+        rollingSummary,
+        updatedAt: new Date().toISOString(),
+    };
+}