openbot 0.2.12 → 0.2.13

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

@@ -1,171 +0,0 @@
-import { uiEvent } from "../../ui/block.js";
-import { z } from "zod";
-import * as fs from "node:fs/promises";
-import * as path from "node:path";
-import { statusWidget } from "../../ui/widgets/status.js";
-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:result",
-                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:result",
-                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:result",
-                data: { action: "writeFile", result: { success: true }, toolCallId },
-            };
-            yield {
-                type: "file-system:status",
-                data: { message: `File written successfully`, severity: "success" }
-            };
-        }
-        catch (error) {
-            yield {
-                type: "action:result",
-                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:result",
-                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:result",
-                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:result",
-                data: { action: "deleteFile", result: { success: true }, toolCallId },
-            };
-            yield {
-                type: "file-system:status",
-                data: { message: `File deleted successfully`, severity: "success" }
-            };
-        }
-        catch (error) {
-            yield {
-                type: "action:result",
-                data: { action: "deleteFile", result: { error: error.message }, toolCallId },
-            };
-            yield {
-                type: "file-system:status",
-                data: { message: `File deletion failed: ${error.message}`, severity: "error" }
-            };
-        }
-    });
-    builder.on("file-system:status", async function* (event) {
-        yield uiEvent(statusWidget(event.data.message, event.data.severity));
-    });
-};

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

@@ -1,6 +0,0 @@
-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/context-budget.js

@@ -1,139 +0,0 @@
-function truncateMiddle(value, maxChars) {
-    if (value.length <= maxChars)
-        return value;
-    const half = Math.floor(maxChars / 2);
-    const removed = value.length - maxChars;
-    return `${value.slice(0, half)}\n\n[... ${removed} characters truncated ...]\n\n${value.slice(-half)}`;
-}
-function estimateStringTokens(value) {
-    if (!value)
-        return 0;
-    return Math.max(1, Math.ceil(value.length / 4));
-}
-function estimateMessageTokens(message) {
-    if (typeof message.content === "string") {
-        return estimateStringTokens(message.content);
-    }
-    if (Array.isArray(message.content)) {
-        let total = 0;
-        for (const part of message.content) {
-            if (typeof part === "string") {
-                total += estimateStringTokens(part);
-            }
-            else if (part && typeof part === "object") {
-                total += estimateStringTokens(JSON.stringify(part));
-            }
-        }
-        return total;
-    }
-    return 0;
-}
-function cloneWithTrimmedSystemMessages(messages, maxSystemChars) {
-    return messages.map((message) => {
-        if (message.role !== "system" || typeof message.content !== "string") {
-            return message;
-        }
-        return {
-            ...message,
-            content: truncateMiddle(message.content, maxSystemChars),
-        };
-    });
-}
-function getLeadingSystemCount(messages) {
-    let count = 0;
-    for (const message of messages) {
-        if (message.role !== "system")
-            break;
-        count++;
-    }
-    return count;
-}
-function collectAssistantToolPairings(messages) {
-    const toolCallToAssistant = new Map();
-    const assistantToToolResults = new Map();
-    messages.forEach((message, index) => {
-        if (message.role !== "assistant" || !Array.isArray(message.content))
-            return;
-        for (const part of message.content) {
-            if (part
-                && typeof part === "object"
-                && part.type === "tool-call"
-                && typeof part.toolCallId === "string") {
-                toolCallToAssistant.set(part.toolCallId, index);
-            }
-        }
-    });
-    messages.forEach((message, index) => {
-        if (message.role !== "tool" || !Array.isArray(message.content))
-            return;
-        for (const part of message.content) {
-            if (!part || typeof part !== "object")
-                continue;
-            const toolCallId = part.toolCallId;
-            if (typeof toolCallId !== "string")
-                continue;
-            const assistantIndex = toolCallToAssistant.get(toolCallId);
-            if (typeof assistantIndex !== "number")
-                continue;
-            const bucket = assistantToToolResults.get(assistantIndex) ?? new Set();
-            bucket.add(index);
-            assistantToToolResults.set(assistantIndex, bucket);
-        }
-    });
-    return assistantToToolResults;
-}
-function buildAtomicGroupIndices(index, messages, assistantToToolResults) {
-    const message = messages[index];
-    if (!message)
-        return [];
-    if (message.role === "assistant") {
-        const results = assistantToToolResults.get(index);
-        if (!results || results.size === 0)
-            return [index];
-        return [index, ...Array.from(results)].sort((a, b) => a - b);
-    }
-    if (message.role === "tool") {
-        for (const [assistantIndex, resultIndices] of assistantToToolResults.entries()) {
-            if (resultIndices.has(index)) {
-                return [assistantIndex, ...Array.from(resultIndices)].sort((a, b) => a - b);
-            }
-        }
-    }
-    return [index];
-}
-export function buildBudgetedMessages(messages, options) {
-    if (messages.length === 0)
-        return messages;
-    const normalized = cloneWithTrimmedSystemMessages(messages, options.maxSystemChars);
-    const systemCount = getLeadingSystemCount(normalized);
-    const leadingSystem = normalized.slice(0, systemCount);
-    const history = normalized.slice(systemCount);
-    const usableBudget = Math.max(1, options.maxContextTokens - options.reserveOutputTokens);
-    let used = leadingSystem.reduce((sum, message) => sum + estimateMessageTokens(message), 0);
-    const requiredIndices = new Set();
-    for (let i = history.length - 1; i >= 0; i--) {
-        if (history[i].role === "user") {
-            requiredIndices.add(i);
-            break;
-        }
-    }
-    const assistantToToolResults = collectAssistantToolPairings(history);
-    const included = new Set();
-    const visited = new Set();
-    for (let i = history.length - 1; i >= 0; i--) {
-        if (visited.has(i))
-            continue;
-        const group = buildAtomicGroupIndices(i, history, assistantToToolResults);
-        for (const idx of group)
-            visited.add(idx);
-        const groupTokens = group.reduce((sum, idx) => sum + estimateMessageTokens(history[idx]), 0);
-        const isRequired = group.some((idx) => requiredIndices.has(idx));
-        if (isRequired || used + groupTokens <= usableBudget) {
-            for (const idx of group)
-                included.add(idx);
-            used += groupTokens;
-        }
-    }
-    const selectedHistory = history.filter((_, index) => included.has(index));
-    return [...leadingSystem, ...selectedHistory];
-}

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

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