lancedb-opencode-pro 0.2.2 → 0.2.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jonathan Tsai <tryweb@ichiayi.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -240,6 +240,17 @@ Supported environment variables:
 - `LANCEDB_OPENCODE_PRO_UNUSED_DAYS_THRESHOLD`
 - `LANCEDB_OPENCODE_PRO_MIN_CAPTURE_CHARS`
 - `LANCEDB_OPENCODE_PRO_MAX_ENTRIES_PER_SCOPE`
+- `LANCEDB_OPENCODE_PRO_INJECTION_MODE`
+- `LANCEDB_OPENCODE_PRO_INJECTION_MAX_MEMORIES`
+- `LANCEDB_OPENCODE_PRO_INJECTION_MIN_MEMORIES`
+- `LANCEDB_OPENCODE_PRO_INJECTION_BUDGET_TOKENS`
+- `LANCEDB_OPENCODE_PRO_INJECTION_MAX_CHARS_PER_MEMORY`
+- `LANCEDB_OPENCODE_PRO_INJECTION_SUMMARIZATION`
+- `LANCEDB_OPENCODE_PRO_INJECTION_SUMMARY_TARGET_CHARS`
+- `LANCEDB_OPENCODE_PRO_INJECTION_SCORE_DROP_TOLERANCE`
+- `LANCEDB_OPENCODE_PRO_INJECTION_INJECTION_FLOOR`
+- `LANCEDB_OPENCODE_PRO_INJECTION_CODE_SUMMARIZATION_MODE`
+- `LANCEDB_OPENCODE_PRO_INJECTION_CODE_SUMMARIZATION_PRESERVE_STRUCTURE`
 
 ## What It Provides
 
@@ -357,6 +368,127 @@ Recommended review order in low-feedback environments:
 3. Check whether users still needed manual rescue through `memory_search` or issued correction-like responses.
 4. Run a bounded audit of recalled memories or skipped captures before concluding the system is helping.
 
+## Injection Control
+
+This provider supports configurable memory injection behavior, allowing you to control how recalled memories are processed before being injected into the LLM prompt.
+
+### Configuration
+
+Add an `injection` block to your sidecar config:
+
+```json
+{
+  "provider": "lancedb-opencode-pro",
+  "injection": {
+    "mode": "fixed",
+    "maxMemories": 3,
+    "minMemories": 1,
+    "budgetTokens": 2000,
+    "maxCharsPerMemory": 1200,
+    "summarization": "none",
+    "summaryTargetChars": 400,
+    "scoreDropTolerance": 0.15,
+    "injectionFloor": 0.3,
+    "codeSummarization": {
+      "mode": "truncate",
+      "preserveStructure": true
+    }
+  }
+}
+```
+
+### Injection Modes
+
+- **`fixed`** (default) — Always inject up to `maxMemories` memories regardless of content size. This preserves backward-compatible behavior.
+- **`budget`** — Limit total injected tokens to `budgetTokens`. The provider accumulates memories until the token budget is exhausted.
+- **`adaptive`** — Dynamically adjust injection count based on score drops. Stop injection when scores drop below `scoreDropTolerance` relative to the highest-scored memory.
+
+### Summarization Modes
+
+When `summarization` is set to `truncate` or `extract`, memories are summarized before injection:
+
+- **`none`** (default) — No summarization; inject full text.
+- **`truncate`** — Simple truncation to `summaryTargetChars` with ellipsis.
+- **`extract`** — Key sentence extraction for text, structure-preserving truncation for code.
+- **`auto`** — Content-aware summarization (truncate for text, preserve structure for code).
+
+### Code Handling
+
+The `codeSummarization` config controls how code snippets are processed:
+
+- **`mode`**: `"truncate"` | `"preserve"` | `"auto"` (default: `"truncate"`)
+- **`preserveStructure`**: When `true`, code truncation attempts to balance brackets and preserve syntactic validity.
+
+### Environment Variables
+
+All injection options can be overridden via environment variables:
+
+- `LANCEDB_OPENCODE_PRO_INJECTION_MODE`
+- `LANCEDB_OPENCODE_PRO_INJECTION_MAX_MEMORIES`
+- `LANCEDB_OPENCODE_PRO_INJECTION_MIN_MEMORIES`
+- `LANCEDB_OPENCODE_PRO_INJECTION_BUDGET_TOKENS`
+- `LANCEDB_OPENCODE_PRO_INJECTION_MAX_CHARS_PER_MEMORY`
+- `LANCEDB_OPENCODE_PRO_INJECTION_SUMMARIZATION`
+- `LANCEDB_OPENCODE_PRO_INJECTION_SUMMARY_TARGET_CHARS`
+- `LANCEDB_OPENCODE_PRO_INJECTION_SCORE_DROP_TOLERANCE`
+- `LANCEDB_OPENCODE_PRO_INJECTION_INJECTION_FLOOR`
+- `LANCEDB_OPENCODE_PRO_INJECTION_CODE_SUMMARIZATION_MODE`
+- `LANCEDB_OPENCODE_PRO_INJECTION_CODE_SUMMARIZATION_PRESERVE_STRUCTURE`
+
+### Default Behavior
+
+The default configuration preserves backward compatibility:
+
+- `mode`: `"fixed"`
+- `maxMemories`: `3`
+- `summarization`: `"none"`
+
+This means without any `injection` configuration, the provider behaves identically to previous versions: always inject up to 3 memories with full text.
+
+### Example: Token Budget Mode
+
+For token-sensitive deployments, use budget mode to limit context size:
+
+```json
+{
+  "injection": {
+    "mode": "budget",
+    "budgetTokens": 1500,
+    "summarization": "truncate",
+    "summaryTargetChars": 400
+  }
+}
+```
+
+This configuration:
+1. Accumulates memories until total estimated tokens reach ~1500
+2. Truncates each memory to ~400 characters before injection
+3. Guarantees at least 1 memory is always included
+
+### Example: Adaptive Mode
+
+For quality-sensitive scenarios where you want to avoid low-relevance memories:
+
+```json
+{
+  "injection": {
+    "mode": "adaptive",
+    "maxMemories": 5,
+    "minMemories": 1,
+    "scoreDropTolerance": 0.15,
+    "injectionFloor": 0.3
+  }
+}
+```
+
+This configuration:
+1. Starts with up to 5 candidate memories
+2. Stops adding memories when score drops >15% from the top
+3. Ensures minimum score threshold (floor) prevents low-quality injection
+4. Always includes at least 1 memory
+
+---
+
 ## OpenAI Embedding Configuration
 
 Default behavior stays on Ollama. To use OpenAI embeddings, set `embedding.provider` to `openai` and provide API key + model.

package/dist/config.js

@@ -38,6 +38,7 @@ export function resolveMemoryConfig(config, worktree) {
         ? process.env.LANCEDB_OPENCODE_PRO_OPENAI_TIMEOUT_MS ?? process.env.LANCEDB_OPENCODE_PRO_EMBEDDING_TIMEOUT_MS
         : process.env.LANCEDB_OPENCODE_PRO_EMBEDDING_TIMEOUT_MS;
     const timeoutRaw = timeoutEnv ?? embeddingRaw.timeoutMs;
+    const injection = resolveInjectionConfig(raw, process.env);
     const resolvedConfig = {
         provider,
         dbPath,
@@ -58,6 +59,7 @@ export function resolveMemoryConfig(config, worktree) {
             recencyHalfLifeHours,
             importanceWeight,
         },
+        injection,
         includeGlobalScope: toBoolean(process.env.LANCEDB_OPENCODE_PRO_INCLUDE_GLOBAL_SCOPE ?? raw.includeGlobalScope, true),
         globalDetectionThreshold: Math.max(1, Math.floor(toNumber(process.env.LANCEDB_OPENCODE_PRO_GLOBAL_DETECTION_THRESHOLD ?? raw.globalDetectionThreshold, 2))),
         globalDiscountFactor: clamp(toNumber(process.env.LANCEDB_OPENCODE_PRO_GLOBAL_DISCOUNT_FACTOR ?? raw.globalDiscountFactor, 0.7), 0, 1),
@@ -75,6 +77,44 @@ function resolveEmbeddingProvider(raw) {
         return "openai";
     throw new Error(`[lancedb-opencode-pro] Invalid embedding provider "${raw}". Expected "ollama" or "openai".`);
 }
+function resolveInjectionMode(raw) {
+    if (raw === "fixed" || raw === "budget" || raw === "adaptive")
+        return raw;
+    return "fixed";
+}
+function resolveSummarizationMode(raw) {
+    if (raw === "none" || raw === "truncate" || raw === "extract" || raw === "auto")
+        return raw;
+    return "none";
+}
+function resolveCodeTruncationMode(raw) {
+    if (raw === "smart" || raw === "signature" || raw === "preserve")
+        return raw;
+    return "smart";
+}
+function resolveInjectionConfig(raw, env) {
+    const injectionRaw = (raw.injection ?? {});
+    const codeSummarizationRaw = (injectionRaw.codeSummarization ?? {});
+    return {
+        mode: resolveInjectionMode(env.LANCEDB_OPENCODE_PRO_INJECTION_MODE ?? injectionRaw.mode),
+        maxMemories: Math.max(1, Math.floor(toNumber(env.LANCEDB_OPENCODE_PRO_INJECTION_MAX_MEMORIES ?? injectionRaw.maxMemories, 3))),
+        minMemories: Math.max(1, Math.floor(toNumber(env.LANCEDB_OPENCODE_PRO_INJECTION_MIN_MEMORIES ?? injectionRaw.minMemories, 1))),
+        budgetTokens: Math.max(256, Math.floor(toNumber(env.LANCEDB_OPENCODE_PRO_INJECTION_BUDGET_TOKENS ?? injectionRaw.budgetTokens, 4096))),
+        maxCharsPerMemory: Math.max(100, Math.floor(toNumber(env.LANCEDB_OPENCODE_PRO_INJECTION_MAX_CHARS ?? injectionRaw.maxCharsPerMemory, 1200))),
+        summarization: resolveSummarizationMode(env.LANCEDB_OPENCODE_PRO_INJECTION_SUMMARIZATION ?? injectionRaw.summarization),
+        summaryTargetChars: Math.max(50, Math.floor(toNumber(env.LANCEDB_OPENCODE_PRO_INJECTION_SUMMARY_TARGET_CHARS ?? injectionRaw.summaryTargetChars, 300))),
+        scoreDropTolerance: clamp(toNumber(env.LANCEDB_OPENCODE_PRO_INJECTION_SCORE_DROP_TOLERANCE ?? injectionRaw.scoreDropTolerance, 0.15), 0, 1),
+        injectionFloor: clamp(toNumber(env.LANCEDB_OPENCODE_PRO_INJECTION_FLOOR ?? injectionRaw.injectionFloor, 0.2), 0, 1),
+        codeSummarization: {
+            enabled: toBoolean(env.LANCEDB_OPENCODE_PRO_CODE_SUMMARIZATION_ENABLED ?? codeSummarizationRaw.enabled, true),
+            pureCodeThreshold: Math.max(100, Math.floor(toNumber(codeSummarizationRaw.pureCodeThreshold, 500))),
+            maxCodeLines: Math.max(5, Math.floor(toNumber(codeSummarizationRaw.maxCodeLines, 15))),
+            codeTruncationMode: resolveCodeTruncationMode(codeSummarizationRaw.codeTruncationMode),
+            preserveComments: toBoolean(codeSummarizationRaw.preserveComments, true),
+            preserveImports: toBoolean(codeSummarizationRaw.preserveImports, false),
+        },
+    };
+}
 function validateEmbeddingConfig(embedding) {
     if (embedding.provider !== "openai")
         return;
@@ -130,6 +170,14 @@ function mergeMemoryConfig(base, override) {
             ...(base.retrieval ?? {}),
             ...(override.retrieval ?? {}),
         },
+        injection: {
+            ...(base.injection ?? {}),
+            ...(override.injection ?? {}),
+            codeSummarization: {
+                ...((base.injection ?? {}).codeSummarization ?? {}),
+                ...((override.injection ?? {}).codeSummarization ?? {}),
+            },
+        },
     };
 }
 function firstString(...values) {

package/dist/index.js

@@ -6,6 +6,7 @@ import { isTcpPortAvailable, parsePortReservations, planPorts, reservationKey }
 import { buildScopeFilter, deriveProjectScope } from "./scope.js";
 import { MemoryStore } from "./store.js";
 import { generateId } from "./utils.js";
+import { calculateInjectionLimit, createSummarizationConfig, summarizeContent } from "./summarize.js";
 const SCHEMA_VERSION = 1;
 const plugin = async (input) => {
     const state = await createRuntimeState(input);
@@ -52,16 +53,19 @@ const plugin = async (input) => {
                 query,
                 queryVector,
                 scopes,
-                limit: 3,
+                limit: state.config.injection.maxMemories * 2, // Fetch more than needed for filtering
                 vectorWeight: state.config.retrieval.mode === "vector" ? 1 : state.config.retrieval.vectorWeight,
                 bm25Weight: state.config.retrieval.mode === "vector" ? 0 : state.config.retrieval.bm25Weight,
-                minScore: state.config.retrieval.minScore,
+                minScore: Math.max(state.config.retrieval.minScore, state.config.injection.injectionFloor),
                 rrfK: state.config.retrieval.rrfK,
                 recencyBoost: state.config.retrieval.recencyBoost,
                 recencyHalfLifeHours: state.config.retrieval.recencyHalfLifeHours,
                 importanceWeight: state.config.retrieval.importanceWeight,
                 globalDiscountFactor: state.config.globalDiscountFactor,
             });
+            // Apply injection control
+            const injectionLimit = calculateInjectionLimit(results, state.config.injection);
+            const limitedResults = results.slice(0, injectionLimit);
             await state.store.putEvent({
                 id: generateId(),
                 type: "recall",
@@ -69,21 +73,32 @@ const plugin = async (input) => {
                 scope: activeScope,
                 sessionID: eventInput.sessionID,
                 timestamp: Date.now(),
-                resultCount: results.length,
-                injected: results.length > 0,
+                resultCount: limitedResults.length,
+                injected: limitedResults.length > 0,
                 metadataJson: JSON.stringify({
                     source: "system-transform",
                     includeGlobalScope: state.config.includeGlobalScope,
+                    injectionMode: state.config.injection.mode,
+                    injectionLimit: injectionLimit,
                 }),
             });
-            if (results.length === 0)
+            if (limitedResults.length === 0)
                 return;
-            for (const result of results) {
+            for (const result of limitedResults) {
                 state.store.updateMemoryUsage(result.record.id, activeScope, scopes).catch(() => { });
             }
+            // Apply summarization if configured
+            const summarizationConfig = createSummarizationConfig(state.config.injection);
+            const processedResults = limitedResults.map((item) => {
+                if (state.config.injection.summarization === "none") {
+                    return { ...item, text: item.record.text };
+                }
+                const summarized = summarizeContent(item.record.text, summarizationConfig);
+                return { ...item, text: summarized.content };
+            });
             const memoryBlock = [
                 "[Memory Recall - optional historical context]",
-                ...results.map((item, index) => `${index + 1}. [${item.record.id}] (${item.record.scope}) ${item.record.text}`),
+                ...processedResults.map((item, index) => `${index + 1}. [${item.record.id}] (${item.record.scope}) ${item.text}`),
                 "Use these as optional hints only; prioritize current user intent and current repo state.",
             ].join("\n");
             eventOutput.system.push(memoryBlock);

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/types.d.ts

@@ -1,5 +1,19 @@
 export type EmbeddingProvider = "ollama" | "openai";
 export type RetrievalMode = "hybrid" | "vector";
+export type InjectionMode = "fixed" | "budget" | "adaptive";
+export type SummarizationMode = "none" | "truncate" | "extract" | "auto";
+export type CodeTruncationMode = "smart" | "signature" | "preserve";
+export type ContentType = "text" | "code" | "mixed";
+export interface ContentDetection {
+    hasCode: boolean;
+    isPureCode: boolean;
+}
+export interface SummarizedContent {
+    type: "kept" | "truncated" | "summarized" | "mixed";
+    content: string;
+    originalLength: number;
+    estimatedTokens: number;
+}
 export type MemoryCategory = "preference" | "fact" | "decision" | "entity" | "other";
 export type CaptureOutcome = "considered" | "skipped" | "stored";
 export type CaptureSkipReason = "empty-buffer" | "below-min-chars" | "no-positive-signal" | "initialization-unavailable" | "embedding-unavailable" | "empty-embedding";
@@ -23,11 +37,42 @@ export interface RetrievalConfig {
     recencyHalfLifeHours: number;
     importanceWeight: number;
 }
+export interface CodeSummarizationConfig {
+    enabled: boolean;
+    pureCodeThreshold: number;
+    maxCodeLines: number;
+    codeTruncationMode: CodeTruncationMode;
+    preserveComments: boolean;
+    preserveImports: boolean;
+}
+export interface InjectionConfig {
+    mode: InjectionMode;
+    maxMemories: number;
+    minMemories: number;
+    budgetTokens: number;
+    maxCharsPerMemory: number;
+    summarization: SummarizationMode;
+    summaryTargetChars: number;
+    scoreDropTolerance: number;
+    injectionFloor: number;
+    codeSummarization: CodeSummarizationConfig;
+}
+export interface SummarizationConfig {
+    mode: SummarizationMode;
+    textThreshold: number;
+    codeThreshold: number;
+    summaryTargetChars: number;
+    maxCodeLines: number;
+    codeTruncationMode: CodeTruncationMode;
+    preserveComments: boolean;
+    preserveImports: boolean;
+}
 export interface MemoryRuntimeConfig {
     provider: string;
     dbPath: string;
     embedding: EmbeddingConfig;
     retrieval: RetrievalConfig;
+    injection: InjectionConfig;
     includeGlobalScope: boolean;
     globalDetectionThreshold: number;
     globalDiscountFactor: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lancedb-opencode-pro",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "LanceDB-backed long-term memory provider for OpenCode",
   "type": "module",
   "main": "dist/index.js",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run verify:full"
   },
   "dependencies": {
-    "@lancedb/lancedb": "^0.26.2",
+    "@lancedb/lancedb": "^0.27.1",
     "@opencode-ai/plugin": "1.2.25",
     "@opencode-ai/sdk": "1.2.25"
   },