@syntesseraai/opencode-feature-factory 0.3.5 → 0.3.6

package/README.md

@@ -42,6 +42,7 @@ The plugin now includes a local MCP daemon binary: `ff-local-recall-mcp`.
   - `local_recall.index.status`
   - `local_recall.index.stop`
   - `local_recall.index.rebuild`
+- In headless and TUI sessions, relevant memories are automatically injected into model context per user prompt
 
 ### Environment Variables
 
@@ -56,6 +57,19 @@ The plugin now includes a local MCP daemon binary: `ff-local-recall-mcp`.
 - `FF_LOCAL_RECALL_OPENAI_MODEL` - OpenAI embedding model (default: `text-embedding-3-small`)
 - `OPENAI_API_KEY` - Required when `FF_LOCAL_RECALL_EMBEDDING_PROVIDER=openai`
 
+### Prompt Injection Controls
+
+- `FF_LOCAL_RECALL_PROMPT_INJECTION_ENABLED` - Enable automatic per-prompt memory injection (`true` by default)
+- `FF_LOCAL_RECALL_PROMPT_INJECTION_MIN_PROMPT_CHARS` - Minimum user prompt length before searching (default: `20`)
+- `FF_LOCAL_RECALL_PROMPT_INJECTION_MAX_QUERY_CHARS` - Maximum characters from prompt used for retrieval (default: `2000`)
+- `FF_LOCAL_RECALL_PROMPT_INJECTION_SEARCH_LIMIT` - Max memories fetched before ranking/filtering (default: `8`)
+- `FF_LOCAL_RECALL_PROMPT_INJECTION_MAX_RESULTS` - Max memories injected into model context (default: `5`)
+- `FF_LOCAL_RECALL_PROMPT_INJECTION_MIN_RELEVANCE` - Minimum relevance score for inclusion (default: `0.2`)
+- `FF_LOCAL_RECALL_PROMPT_INJECTION_MIN_IMPORTANCE` - Minimum memory importance used in search (default: `0.2`)
+- `FF_LOCAL_RECALL_PROMPT_INJECTION_MAX_TOKENS` - Approx token budget for injected memory block (default: `400`)
+- `FF_LOCAL_RECALL_PROMPT_INJECTION_SESSION_ONLY` - Restrict retrieval to current session memories only (`false` by default)
+- `FF_LOCAL_RECALL_PROMPT_INTERNAL_MARKERS` - Comma-separated markers that skip injection (default: `[LOCAL_RECALL_INTERNAL]`)
+
 ## Agents Provided
 
 ### Primary Agents

package/dist/index.js

@@ -6,6 +6,7 @@ import { createFFAgentsCurrentTool } from './plugins/ff-agents-current-plugin.js
 import { createFFAgentsShowTool } from './plugins/ff-agents-show-plugin.js';
 import { createFFAgentsClearTool } from './plugins/ff-agents-clear-plugin.js';
 import { createLearningStoreTool, createLearningSearchTool, createLearningGetTool, createLearningIndexStartTool, createLearningIndexStatusTool, createLearningIndexStopTool, createLearningIndexRebuildTool, initLocalRecall, } from './local-recall/index.js';
+import { createLocalRecallPromptHooks } from './local-recall/prompt-injection.js';
 import { createFFPlanCreateTool } from './plugins/ff-plan-create-plugin.js';
 import { createFFPlanUpdateTool } from './plugins/ff-plan-update-plugin.js';
 import { createFFAgentContextCreateTool } from './plugins/ff-agent-context-create-plugin.js';
@@ -49,6 +50,8 @@ export const FeatureFactoryPlugin = async (input) => {
     }
     // Load hooks from the quality gate plugin
     const qualityGateHooks = await StopQualityGateHooksPlugin(input).catch(() => ({}));
+    // Load local-recall prompt injection hooks (headless-safe)
+    const localRecallPromptHooks = createLocalRecallPromptHooks(directory);
     // Create all tools
     const tools = {
         // Agent management tools
@@ -89,6 +92,7 @@ export const FeatureFactoryPlugin = async (input) => {
     // Return combined hooks and tools
     return {
         ...qualityGateHooks,
+        ...localRecallPromptHooks,
         tool: tools,
     };
 };

package/dist/local-recall/prompt-injection.d.ts

@@ -0,0 +1,2 @@
+import type { Hooks } from '@opencode-ai/plugin';
+export declare function createLocalRecallPromptHooks(directory: string): Partial<Hooks>;

package/dist/local-recall/prompt-injection.js

@@ -0,0 +1,194 @@
+import { searchLearningMemories } from './mcp-server.js';
+const MEMORY_CONTEXT_HEADER = '## Local Recall: Relevant Memories';
+const MEMORY_CONTEXT_GUIDANCE = 'Use these prior project learnings only when they directly improve the current response.';
+const DEFAULT_INTERNAL_MARKERS = ['[LOCAL_RECALL_INTERNAL]'];
+const APPROX_CHARS_PER_TOKEN = 4;
+const pendingContextBySession = new Map();
+function parseBooleanEnv(name, fallback) {
+    const value = process.env[name];
+    if (!value) {
+        return fallback;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(normalized)) {
+        return true;
+    }
+    if (['0', 'false', 'no', 'off'].includes(normalized)) {
+        return false;
+    }
+    return fallback;
+}
+function parseNumberEnv(name, fallback, options) {
+    const value = process.env[name];
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        return fallback;
+    }
+    const withInteger = options?.integer ? Math.trunc(parsed) : parsed;
+    const min = options?.min ?? Number.NEGATIVE_INFINITY;
+    const max = options?.max ?? Number.POSITIVE_INFINITY;
+    return Math.min(max, Math.max(min, withInteger));
+}
+function parseInternalMarkers() {
+    const configured = process.env.FF_LOCAL_RECALL_PROMPT_INTERNAL_MARKERS;
+    if (!configured) {
+        return DEFAULT_INTERNAL_MARKERS;
+    }
+    const markers = configured
+        .split(',')
+        .map((entry) => entry.trim())
+        .filter((entry) => entry.length > 0);
+    return markers.length > 0 ? markers : DEFAULT_INTERNAL_MARKERS;
+}
+function getPromptInjectionConfig() {
+    return {
+        enabled: parseBooleanEnv('FF_LOCAL_RECALL_PROMPT_INJECTION_ENABLED', true),
+        minPromptChars: parseNumberEnv('FF_LOCAL_RECALL_PROMPT_INJECTION_MIN_PROMPT_CHARS', 20, {
+            min: 1,
+            max: 2000,
+            integer: true,
+        }),
+        maxQueryChars: parseNumberEnv('FF_LOCAL_RECALL_PROMPT_INJECTION_MAX_QUERY_CHARS', 2000, {
+            min: 64,
+            max: 20000,
+            integer: true,
+        }),
+        searchLimit: parseNumberEnv('FF_LOCAL_RECALL_PROMPT_INJECTION_SEARCH_LIMIT', 8, {
+            min: 1,
+            max: 50,
+            integer: true,
+        }),
+        maxResults: parseNumberEnv('FF_LOCAL_RECALL_PROMPT_INJECTION_MAX_RESULTS', 5, {
+            min: 1,
+            max: 20,
+            integer: true,
+        }),
+        minRelevance: parseNumberEnv('FF_LOCAL_RECALL_PROMPT_INJECTION_MIN_RELEVANCE', 0.2, {
+            min: 0,
+            max: 1,
+        }),
+        minImportance: parseNumberEnv('FF_LOCAL_RECALL_PROMPT_INJECTION_MIN_IMPORTANCE', 0.2, {
+            min: 0,
+            max: 1,
+        }),
+        maxTokens: parseNumberEnv('FF_LOCAL_RECALL_PROMPT_INJECTION_MAX_TOKENS', 400, {
+            min: 50,
+            max: 4000,
+            integer: true,
+        }),
+        sessionOnly: parseBooleanEnv('FF_LOCAL_RECALL_PROMPT_INJECTION_SESSION_ONLY', false),
+        internalMarkers: parseInternalMarkers(),
+    };
+}
+function estimateTokens(text) {
+    return Math.ceil(text.length / APPROX_CHARS_PER_TOKEN);
+}
+function normalizeInlineText(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function extractUserPromptText(parts) {
+    const text = parts
+        .filter((part) => part.type === 'text')
+        .filter((part) => !part.synthetic)
+        .map((part) => part.text)
+        .join('\n')
+        .trim();
+    return text;
+}
+function isInternalPrompt(prompt, markers) {
+    return markers.some((marker) => marker.length > 0 && prompt.includes(marker));
+}
+function scoreMemory(memory) {
+    return memory.relevance * 0.75 + memory.importance * 0.25;
+}
+function rankMemories(memories, config) {
+    return memories
+        .filter((memory) => memory.relevance >= config.minRelevance)
+        .sort((a, b) => {
+        const scoreDifference = scoreMemory(b) - scoreMemory(a);
+        if (scoreDifference !== 0) {
+            return scoreDifference;
+        }
+        return b.createdAt - a.createdAt;
+    });
+}
+function formatMemoryLine(index, memory) {
+    const title = normalizeInlineText(memory.title);
+    const tags = memory.tags.length > 0 ? ` | tags: ${memory.tags.slice(0, 5).join(', ')}` : '';
+    return `${index}. ${title} (category: ${memory.category}, relevance: ${memory.relevance.toFixed(2)}, importance: ${memory.importance.toFixed(2)}${tags})`;
+}
+function buildMemoryContext(memories, config) {
+    const lines = [];
+    let usedTokens = estimateTokens(MEMORY_CONTEXT_HEADER) + estimateTokens(MEMORY_CONTEXT_GUIDANCE);
+    for (const memory of memories) {
+        if (lines.length >= config.maxResults) {
+            break;
+        }
+        const line = formatMemoryLine(lines.length + 1, memory);
+        const lineTokens = estimateTokens(line);
+        if (lines.length > 0 && usedTokens + lineTokens > config.maxTokens) {
+            break;
+        }
+        lines.push(line);
+        usedTokens += lineTokens;
+    }
+    if (lines.length === 0) {
+        return null;
+    }
+    return [MEMORY_CONTEXT_HEADER, MEMORY_CONTEXT_GUIDANCE, ...lines.map((line) => `- ${line}`)].join('\n');
+}
+export function createLocalRecallPromptHooks(directory) {
+    const config = getPromptInjectionConfig();
+    if (!config.enabled) {
+        return {};
+    }
+    return {
+        'chat.message': async (input, output) => {
+            const promptText = extractUserPromptText(output.parts);
+            if (promptText.length < config.minPromptChars) {
+                pendingContextBySession.delete(input.sessionID);
+                return;
+            }
+            if (isInternalPrompt(promptText, config.internalMarkers)) {
+                pendingContextBySession.delete(input.sessionID);
+                return;
+            }
+            const criteria = {
+                query: promptText.slice(0, config.maxQueryChars),
+                limit: config.searchLimit,
+                minImportance: config.minImportance,
+            };
+            if (config.sessionOnly) {
+                criteria.sessionID = input.sessionID;
+            }
+            try {
+                const searchOutput = await searchLearningMemories(directory, criteria);
+                const ranked = rankMemories(searchOutput.results, config);
+                const context = buildMemoryContext(ranked, config);
+                if (!context) {
+                    pendingContextBySession.delete(input.sessionID);
+                    return;
+                }
+                pendingContextBySession.set(input.sessionID, context);
+            }
+            catch {
+                pendingContextBySession.delete(input.sessionID);
+            }
+        },
+        'experimental.chat.system.transform': async (input, output) => {
+            const sessionID = input.sessionID;
+            if (!sessionID) {
+                return;
+            }
+            const pendingContext = pendingContextBySession.get(sessionID);
+            if (!pendingContext) {
+                return;
+            }
+            output.system.push(pendingContext);
+            pendingContextBySession.delete(sessionID);
+        },
+    };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@syntesseraai/opencode-feature-factory",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "type": "module",
   "description": "OpenCode plugin for Feature Factory agents - provides sub-agents and skills for validation, review, security, and architecture assessment",
   "license": "MIT",