opencode-memory-pro 1.3.0

package/dist/summarize.d.ts

@@ -0,0 +1,52 @@
+import type { ContentType, ContentDetection, SummarizedContent, SummarizationConfig, InjectionConfig, SearchResult } from "./types.js";
+/**
+ * Detects whether content contains code and its type
+ */
+export declare function detectContentType(text: string): ContentDetection;
+/**
+ * Calculates bracket balance for code detection
+ */
+export declare function calculateBracketBalance(text: string): number;
+/**
+ * Counts code-related keywords
+ */
+export declare function countCodeKeywords(text: string): number;
+/**
+ * Calculates ratio of indented lines
+ */
+export declare function calculateIndentationRatio(text: string): number;
+/**
+ * Estimates token count for content
+ */
+export declare function estimateTokens(text: string, contentType: ContentType): number;
+/**
+ * Truncates text to max characters
+ */
+export declare function truncateText(text: string, maxChars: number): string;
+/**
+ * Smart truncation for code - finds complete statement boundaries
+ */
+export declare function smartTruncateCode(code: string, maxLines: number, config?: {
+    preserveComments?: boolean;
+    preserveImports?: boolean;
+}): string;
+/**
+ * Extracts key sentences from text
+ */
+export declare function extractKeySentences(text: string, targetChars: number): string;
+export declare function splitCodeAndText(text: string): Array<{
+    type: "code" | "text";
+    content: string;
+}>;
+/**
+ * Main summarization function
+ */
+export declare function summarizeContent(text: string, config: SummarizationConfig): SummarizedContent;
+/**
+ * Calculates injection limit based on mode
+ */
+export declare function calculateInjectionLimit(results: SearchResult[], config: InjectionConfig): number;
+/**
+ * Creates default summarization config from injection config
+ */
+export declare function createSummarizationConfig(injection: InjectionConfig): SummarizationConfig;

package/dist/summarize.js

@@ -0,0 +1,350 @@
+// Code keywords used for content detection
+const CODE_KEYWORDS = [
+    "function", "async", "await", "const", "let", "var", "return", "class", "interface", "type",
+    "import", "export", "from", "default", "extends", "implements", "new", "this", "super",
+    "def ", "async def", "func ", "fn ", "pub fn", "impl ", "struct ", "enum ",
+    "=>", "->", "::", "if (", "for (", "while (", "try {", "catch (", "throw ",
+];
+// Keywords for key sentence extraction
+const KEY_SENTENCE_PATTERNS = [
+    /(?:fixed|resolved|works?\s+now|successful|done|完成|已解決|修復|成功)/i,
+    /(?:probleme|issue|bug|error|fail|錯誤|問題|失敗)/i,
+    /(?:solution|fix|resolve|解決方案|修正)/i,
+    /(?:because|root\s+cause|原因|由於)/i,
+    /(?:decide|decision|tradeoff|architecture|決定|架構|採用)/i,
+    /(?:prefer|preference|偏好|習慣)/i,
+];
+/**
+ * Detects whether content contains code and its type
+ */
+export function detectContentType(text) {
+    const hasMarkdownCode = /```[\s\S]*?```/.test(text);
+    const bracketBalance = calculateBracketBalance(text);
+    const codeKeywords = countCodeKeywords(text);
+    const indentationRatio = calculateIndentationRatio(text);
+    const codeScore = (hasMarkdownCode ? 2 : 0) +
+        (bracketBalance > 3 ? 1 : 0) +
+        (codeKeywords > 5 ? 1 : 0) +
+        (indentationRatio > 0.3 ? 1 : 0);
+    if (codeScore >= 5) {
+        return { hasCode: true, isPureCode: true };
+    }
+    if (codeScore >= 3) {
+        return { hasCode: true, isPureCode: false };
+    }
+    if (hasMarkdownCode || codeKeywords > 10) {
+        return { hasCode: true, isPureCode: false };
+    }
+    return { hasCode: false, isPureCode: false };
+}
+/**
+ * Calculates bracket balance for code detection
+ */
+export function calculateBracketBalance(text) {
+    const openBrackets = (text.match(/[{([]/g) || []).length;
+    const closeBrackets = (text.match(/[})\]]/g) || []).length;
+    return Math.abs(openBrackets - closeBrackets) + Math.min(openBrackets, closeBrackets);
+}
+/**
+ * Counts code-related keywords
+ */
+export function countCodeKeywords(text) {
+    const lower = text.toLowerCase();
+    let count = 0;
+    for (const keyword of CODE_KEYWORDS) {
+        if (lower.includes(keyword.toLowerCase())) {
+            count += 1;
+        }
+    }
+    return count;
+}
+/**
+ * Calculates ratio of indented lines
+ */
+export function calculateIndentationRatio(text) {
+    const lines = text.split("\n");
+    if (lines.length === 0)
+        return 0;
+    const indentedLines = lines.filter((line) => /^\s{2,}/.test(line));
+    return indentedLines.length / lines.length;
+}
+/**
+ * Estimates token count for content
+ */
+export function estimateTokens(text, contentType) {
+    // Count Chinese characters
+    const chineseChars = (text.match(/[\u4e00-\u9fff]/g) || []).length;
+    const nonChineseChars = text.length - chineseChars;
+    // Chinese ~2 chars/token, English/other ~4 chars/token
+    const baseTokens = Math.ceil(chineseChars / 2 + nonChineseChars / 4);
+    // Code has higher token density
+    if (contentType === "code") {
+        return Math.ceil(baseTokens * 1.2);
+    }
+    return baseTokens;
+}
+/**
+ * Truncates text to max characters
+ */
+export function truncateText(text, maxChars) {
+    if (text.length <= maxChars)
+        return text;
+    return `${text.slice(0, maxChars - 3)}...`;
+}
+/**
+ * Smart truncation for code - finds complete statement boundaries
+ */
+export function smartTruncateCode(code, maxLines, config) {
+    const lines = code.split("\n");
+    if (lines.length <= maxLines)
+        return code;
+    let braceBalance = 0;
+    let lastCompleteIndex = maxLines;
+    let foundComplete = false;
+    // Calculate brace balance and find last complete statement
+    for (let i = 0; i < Math.min(lines.length, maxLines + 10); i++) {
+        const line = lines[i];
+        braceBalance += (line.match(/{/g) || []).length;
+        braceBalance -= (line.match(/}/g) || []).length;
+        if (i >= maxLines - 5 && braceBalance === 0 && i < lines.length - 1) {
+            lastCompleteIndex = i + 1;
+            foundComplete = true;
+            break;
+        }
+    }
+    // If no complete boundary found, use maxLines
+    if (!foundComplete) {
+        lastCompleteIndex = maxLines;
+    }
+    // Build truncated code
+    let result = lines.slice(0, lastCompleteIndex).join("\n");
+    // Add truncation indicator
+    result += "\n// ... (truncated)";
+    return result;
+}
+/**
+ * Extracts key sentences from text
+ */
+export function extractKeySentences(text, targetChars) {
+    const sentences = text.split(/[。.!?\n]+/).filter((s) => s.trim().length > 0);
+    const keySentences = [];
+    let currentLength = 0;
+    // First pass: sentences matching key patterns
+    for (const sentence of sentences) {
+        const trimmed = sentence.trim();
+        if (KEY_SENTENCE_PATTERNS.some((pattern) => pattern.test(trimmed))) {
+            if (currentLength + trimmed.length > targetChars && keySentences.length > 0) {
+                break;
+            }
+            keySentences.push(trimmed);
+            currentLength += trimmed.length + 1;
+        }
+    }
+    // Second pass: fill remaining with first sentences if needed
+    if (currentLength < targetChars * 0.5) {
+        for (const sentence of sentences) {
+            const trimmed = sentence.trim();
+            if (!keySentences.includes(trimmed)) {
+                if (currentLength + trimmed.length > targetChars) {
+                    break;
+                }
+                keySentences.push(trimmed);
+                currentLength += trimmed.length + 1;
+            }
+        }
+    }
+    return keySentences.join(" → ");
+}
+export function splitCodeAndText(text) {
+    const parts = [];
+    const codeBlockRegex = /```[\s\S]*?```/g;
+    let lastIndex = 0;
+    let match = codeBlockRegex.exec(text);
+    while (match !== null) {
+        if (match.index > lastIndex) {
+            const textPart = text.slice(lastIndex, match.index).trim();
+            if (textPart) {
+                parts.push({ type: "text", content: textPart });
+            }
+        }
+        parts.push({ type: "code", content: match[0] });
+        lastIndex = match.index + match[0].length;
+        match = codeBlockRegex.exec(text);
+    }
+    if (lastIndex < text.length) {
+        const remaining = text.slice(lastIndex).trim();
+        if (remaining) {
+            parts.push({ type: "text", content: remaining });
+        }
+    }
+    return parts;
+}
+/**
+ * Main summarization function
+ */
+export function summarizeContent(text, config) {
+    const detection = detectContentType(text);
+    const originalLength = text.length;
+    // Determine content type
+    const contentType = detection.isPureCode
+        ? "code"
+        : detection.hasCode
+            ? "mixed"
+            : "text";
+    // No summarization
+    if (config.mode === "none") {
+        return {
+            type: "kept",
+            content: truncateText(text, config.textThreshold * 4), // Max chars limit
+            originalLength,
+            estimatedTokens: estimateTokens(text, contentType),
+        };
+    }
+    // Pure text
+    if (contentType === "text") {
+        if (text.length <= config.textThreshold) {
+            return {
+                type: "kept",
+                content: text,
+                originalLength,
+                estimatedTokens: estimateTokens(text, contentType),
+            };
+        }
+        if (config.mode === "truncate") {
+            const truncated = truncateText(text, config.summaryTargetChars);
+            return {
+                type: "truncated",
+                content: truncated,
+                originalLength,
+                estimatedTokens: estimateTokens(truncated, contentType),
+            };
+        }
+        const extracted = extractKeySentences(text, config.summaryTargetChars);
+        return {
+            type: "summarized",
+            content: extracted,
+            originalLength,
+            estimatedTokens: estimateTokens(extracted, contentType),
+        };
+    }
+    // Pure code
+    if (contentType === "code") {
+        if (text.length <= config.codeThreshold) {
+            return {
+                type: "kept",
+                content: text,
+                originalLength,
+                estimatedTokens: estimateTokens(text, contentType),
+            };
+        }
+        const truncated = smartTruncateCode(text, config.maxCodeLines, {
+            preserveComments: config.preserveComments,
+            preserveImports: config.preserveImports,
+        });
+        return {
+            type: "truncated",
+            content: truncated,
+            originalLength,
+            estimatedTokens: estimateTokens(truncated, contentType),
+        };
+    }
+    // Mixed content
+    if (config.mode === "auto" || config.mode === "extract") {
+        const parts = splitCodeAndText(text);
+        const summarizedParts = [];
+        for (const part of parts) {
+            if (part.type === "text") {
+                if (part.content.length <= config.textThreshold) {
+                    summarizedParts.push(part.content);
+                }
+                else {
+                    summarizedParts.push(extractKeySentences(part.content, config.summaryTargetChars / 2));
+                }
+            }
+            else {
+                if (part.content.length <= config.codeThreshold) {
+                    summarizedParts.push(part.content);
+                }
+                else {
+                    summarizedParts.push(smartTruncateCode(part.content, config.maxCodeLines));
+                }
+            }
+        }
+        return {
+            type: "mixed",
+            content: summarizedParts.join("\n\n"),
+            originalLength,
+            estimatedTokens: estimateTokens(summarizedParts.join("\n\n"), contentType),
+        };
+    }
+    // Fallback: truncate
+    return {
+        type: "truncated",
+        content: truncateText(text, config.summaryTargetChars),
+        originalLength,
+        estimatedTokens: estimateTokens(truncateText(text, config.summaryTargetChars), contentType),
+    };
+}
+/**
+ * Calculates injection limit based on mode
+ */
+export function calculateInjectionLimit(results, config) {
+    // Filter by injection floor
+    const filteredResults = results.filter((r) => r.score >= config.injectionFloor);
+    // Fixed mode: simple limit
+    if (config.mode === "fixed") {
+        return Math.min(config.maxMemories, filteredResults.length);
+    }
+    // Budget mode: accumulate until budget exhausted
+    if (config.mode === "budget") {
+        let accumulatedTokens = 0;
+        let count = 0;
+        for (const result of filteredResults) {
+            const tokens = estimateTokens(result.record.text, detectContentType(result.record.text).isPureCode ? "code" : "text");
+            if (accumulatedTokens + tokens > config.budgetTokens && count >= config.minMemories) {
+                break;
+            }
+            accumulatedTokens += tokens;
+            count += 1;
+            if (count >= config.maxMemories) {
+                break;
+            }
+        }
+        return Math.max(config.minMemories, Math.min(count, config.maxMemories));
+    }
+    // Adaptive mode: stop on score drop
+    if (config.mode === "adaptive") {
+        let count = 0;
+        let prevScore = filteredResults[0]?.score ?? 0;
+        for (const result of filteredResults) {
+            const scoreDrop = prevScore - result.score;
+            // Stop if score drops below tolerance (but respect minimum)
+            if (scoreDrop > config.scoreDropTolerance && count >= config.minMemories) {
+                break;
+            }
+            count += 1;
+            prevScore = result.score;
+            if (count >= config.maxMemories) {
+                break;
+            }
+        }
+        return Math.max(config.minMemories, Math.min(count, filteredResults.length));
+    }
+    // Fallback
+    return Math.min(config.maxMemories, filteredResults.length);
+}
+/**
+ * Creates default summarization config from injection config
+ */
+export function createSummarizationConfig(injection) {
+    return {
+        mode: injection.summarization,
+        textThreshold: 300,
+        codeThreshold: injection.codeSummarization.pureCodeThreshold,
+        summaryTargetChars: injection.summaryTargetChars,
+        maxCodeLines: injection.codeSummarization.maxCodeLines,
+        codeTruncationMode: injection.codeSummarization.codeTruncationMode,
+        preserveComments: injection.codeSummarization.preserveComments,
+        preserveImports: injection.codeSummarization.preserveImports,
+    };
+}

package/dist/tools/episodic.d.ts

@@ -0,0 +1,68 @@
+import type { ToolRuntimeState } from "./memory.js";
+export declare function createEpisodicTools(state: ToolRuntimeState): {
+    task_episode_create: {
+        description: string;
+        args: {
+            taskId: import("zod").ZodString;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            taskId: string;
+            scope?: string | undefined;
+            description?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    task_episode_query: {
+        description: string;
+        args: {
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+            state: import("zod").ZodOptional<import("zod").ZodString>;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+        };
+        execute(args: {
+            limit: number;
+            scope?: string | undefined;
+            state?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    similar_task_recall: {
+        description: string;
+        args: {
+            query: import("zod").ZodString;
+            threshold: import("zod").ZodDefault<import("zod").ZodNumber>;
+            limit: import("zod").ZodDefault<import("zod").ZodNumber>;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            query: string;
+            threshold: number;
+            limit: number;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    retry_budget_suggest: {
+        description: string;
+        args: {
+            errorType: import("zod").ZodString;
+            minSamples: import("zod").ZodDefault<import("zod").ZodNumber>;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            errorType: string;
+            minSamples: number;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    recovery_strategy_suggest: {
+        description: string;
+        args: {
+            taskId: import("zod").ZodString;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            taskId: string;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};

package/dist/tools/episodic.js

@@ -0,0 +1,145 @@
+import { tool } from "@opencode-ai/plugin";
+import { deriveProjectScope } from "../scope.js";
+import { generateId, parseJsonObject } from "../utils.js";
+function unavailableMessage(provider) {
+    return `Memory store unavailable (${provider} embedding may be offline). Will retry automatically.`;
+}
+export function createEpisodicTools(state) {
+    return {
+        task_episode_create: tool({
+            description: "Create a new task episode record for tracking",
+            args: {
+                taskId: tool.schema.string().min(1),
+                scope: tool.schema.string().optional(),
+                description: tool.schema.string().optional(),
+            },
+            execute: async (args, context) => {
+                await state.ensureInitialized();
+                if (!state.initialized)
+                    return unavailableMessage(state.config.embedding.provider);
+                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const episode = {
+                    id: generateId(),
+                    sessionId: context.sessionID,
+                    scope: activeScope,
+                    taskId: args.taskId,
+                    state: "pending",
+                    startTime: Date.now(),
+                    endTime: 0,
+                    commandsJson: "[]",
+                    validationOutcomesJson: "[]",
+                    successPatternsJson: "[]",
+                    retryAttemptsJson: "[]",
+                    recoveryStrategiesJson: "[]",
+                    metadataJson: JSON.stringify({ description: args.description }),
+                };
+                await state.store.createTaskEpisode(episode);
+                return `Created task episode ${episode.id} for task ${args.taskId} in scope ${activeScope}`;
+            },
+        }),
+        task_episode_query: tool({
+            description: "Query task episodes by scope and state",
+            args: {
+                scope: tool.schema.string().optional(),
+                state: tool.schema.string().optional(),
+                limit: tool.schema.number().int().min(1).max(100).default(10),
+            },
+            execute: async (args, context) => {
+                await state.ensureInitialized();
+                if (!state.initialized)
+                    return unavailableMessage(state.config.embedding.provider);
+                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const stateFilter = args.state;
+                const episodes = await state.store.queryTaskEpisodes(activeScope, stateFilter);
+                if (episodes.length === 0) {
+                    return `No task episodes found in scope ${activeScope}`;
+                }
+                const limited = episodes.slice(0, args.limit ?? 10);
+                return limited.map((ep) => {
+                    const meta = parseJsonObject(ep.metadataJson, {});
+                    return `[${ep.id}] ${ep.taskId} - ${ep.state} (${new Date(ep.startTime).toISOString().split("T")[0]}) ${meta.description ? `- ${meta.description}` : ""}`;
+                }).join("\n");
+            },
+        }),
+        similar_task_recall: tool({
+            description: "Find similar past tasks using semantic search",
+            args: {
+                query: tool.schema.string().min(1),
+                threshold: tool.schema.number().min(0).max(1).default(0.85),
+                limit: tool.schema.number().int().min(1).max(10).default(3),
+                scope: tool.schema.string().optional(),
+            },
+            execute: async (args, context) => {
+                await state.ensureInitialized();
+                if (!state.initialized)
+                    return unavailableMessage(state.config.embedding.provider);
+                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                let queryVector = [];
+                try {
+                    queryVector = await state.embedder.embed(args.query);
+                }
+                catch {
+                    queryVector = [];
+                }
+                const similar = await state.store.findSimilarTasks(activeScope, args.query, args.threshold ?? 0.85, queryVector);
+                if (similar.length === 0) {
+                    return `No similar tasks found for "${args.query}"`;
+                }
+                const limited = similar.slice(0, args.limit ?? 3);
+                return limited.map((ep) => {
+                    const commands = parseJsonObject(ep.commandsJson, []);
+                    const outcomes = parseJsonObject(ep.validationOutcomesJson, []);
+                    return `Task: ${ep.taskId} (${ep.state})
+  Commands: ${commands.slice(0, 3).join(" → ")}
+  Validations: ${outcomes.map((o) => `${o.type}:${o.status}`).join(", ") || "none"}
+`;
+                }).join("\n");
+            },
+        }),
+        retry_budget_suggest: tool({
+            description: "Get retry budget suggestion based on historical data",
+            args: {
+                errorType: tool.schema.string(),
+                minSamples: tool.schema.number().int().min(1).default(3),
+                scope: tool.schema.string().optional(),
+            },
+            execute: async (args, context) => {
+                await state.ensureInitialized();
+                if (!state.initialized)
+                    return unavailableMessage(state.config.embedding.provider);
+                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const result = await state.store.suggestRetryBudget(activeScope, args.minSamples ?? 3);
+                if (!result) {
+                    return `Insufficient data for retry budget suggestion (need at least ${args.minSamples} failed tasks)`;
+                }
+                return JSON.stringify({
+                    suggestedRetries: result.suggestedRetries,
+                    confidence: result.confidence.toFixed(2),
+                    basedOnCount: result.basedOnCount,
+                    shouldStop: result.shouldStop,
+                    stopReason: result.stopReason,
+                }, null, 2);
+            },
+        }),
+        recovery_strategy_suggest: tool({
+            description: "Get recovery strategy suggestions after failures",
+            args: {
+                taskId: tool.schema.string().min(1),
+                scope: tool.schema.string().optional(),
+            },
+            execute: async (args, context) => {
+                await state.ensureInitialized();
+                if (!state.initialized)
+                    return unavailableMessage(state.config.embedding.provider);
+                const activeScope = args.scope ?? deriveProjectScope(context.directory || context.worktree);
+                const strategies = await state.store.suggestRecoveryStrategies(activeScope, args.taskId);
+                if (strategies.length === 0) {
+                    return `No recovery strategies found for task ${args.taskId}`;
+                }
+                return strategies.map((s) => {
+                    return `- ${s.strategy}: ${s.reason} (confidence: ${s.confidence.toFixed(2)}${s.basedOnTask ? `, based on: ${s.basedOnTask}` : ""})`;
+                }).join("\n");
+            },
+        }),
+    };
+}

package/dist/tools/feedback.d.ts

@@ -0,0 +1,51 @@
+import type { ToolRuntimeState } from "./memory.js";
+export declare function createFeedbackTools(state: ToolRuntimeState): {
+    memory_feedback_missing: {
+        description: string;
+        args: {
+            text: import("zod").ZodString;
+            labels: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            text: string;
+            labels: string[];
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_feedback_wrong: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+            reason: import("zod").ZodOptional<import("zod").ZodString>;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            id: string;
+            reason?: string | undefined;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_feedback_useful: {
+        description: string;
+        args: {
+            id: import("zod").ZodString;
+            helpful: import("zod").ZodBoolean;
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            id: string;
+            helpful: boolean;
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+    memory_effectiveness: {
+        description: string;
+        args: {
+            scope: import("zod").ZodOptional<import("zod").ZodString>;
+        };
+        execute(args: {
+            scope?: string | undefined;
+        }, context: import("@opencode-ai/plugin").ToolContext): Promise<string>;
+    };
+};