@syntesseraai/opencode-feature-factory 0.2.45 → 0.3.1

package/README.md

@@ -29,6 +29,33 @@ This will:
 - Copy skills to `~/.config/opencode/skills/`
 - Configure MCP servers in `~/.config/opencode/opencode.json`
 
+## Local Recall MCP Daemon
+
+The plugin now includes a local MCP daemon binary: `ff-local-recall-mcp`.
+
+- `ff-deploy` adds a local MCP server entry named `ff-local-recall`
+- The server exposes memory tools:
+  - `local_recall.search`
+  - `local_recall.get`
+  - `local_recall.store`
+  - `local_recall.index.start`
+  - `local_recall.index.status`
+  - `local_recall.index.stop`
+  - `local_recall.index.rebuild`
+
+### Environment Variables
+
+- `FF_LOCAL_RECALL_DIRECTORY` - Directory that contains `.feature-factory/` (default: current working directory)
+- `FF_LOCAL_RECALL_DAEMON_AUTOSTART` - Start index daemon automatically (`true` by default)
+- `FF_LOCAL_RECALL_INDEX_INTERVAL_MS` - Background daemon interval in milliseconds (default: `15000`)
+- `FF_LOCAL_RECALL_EXTRACTION_ENABLED` - Run extraction during daemon cycles (`true` by default)
+- `FF_LOCAL_RECALL_EMBEDDING_PROVIDER` - Embedding provider (`ollama` default, `openai` optional)
+- `FF_LOCAL_RECALL_OLLAMA_URL` - Ollama base URL (default: `http://127.0.0.1:11434`)
+- `FF_LOCAL_RECALL_OLLAMA_MODEL` - Ollama embedding model (default: `nomic-embed-text`)
+- `FF_LOCAL_RECALL_OPENAI_URL` - OpenAI embeddings endpoint base (default: `https://api.openai.com/v1`)
+- `FF_LOCAL_RECALL_OPENAI_MODEL` - OpenAI embedding model (default: `text-embedding-3-small`)
+- `OPENAI_API_KEY` - Required when `FF_LOCAL_RECALL_EMBEDDING_PROVIDER=openai`
+
 ## Agents Provided
 
 ### Primary Agents

package/agents/building.md

@@ -1,7 +1,6 @@
 ---
 description: Implements features and makes code changes based on implementation plans. Use this agent to execute plans, write code, and build features. Prefer delegation for validation, testing, and documentation.
 mode: primary
-temperature: 0.2
 color: '#10b981'
 tools:
   read: true
@@ -463,22 +462,21 @@ Before completing your building task:
    - Error resolutions and debugging insights
    - Integration challenges and solutions
 
-2. **Store important learnings** using ff-learning skill:
-   - Create semantic memories for technical patterns and best practices
-   - Create episodic memories for significant implementation experiences
-   - Create procedural memories for reusable workflows discovered
+2. **Store important learnings** using the `ff-learning-store` MCP tool:
+   - Use category `pattern` for technical patterns and best practices
+   - Use category `context` for significant implementation experiences
+   - Use category `procedure` for reusable workflows discovered
    - Tag with relevant technology names and categories
 
 3. **Example learning capture:**
 
-   ```markdown
-   After implementing feature:
-
-   1. Generate UUID: `uuidgen`
-   2. Determine memory type based on content:
-      - Technical pattern → semantic
-      - Implementation experience → episodic
-      - Reusable workflow → procedural
-   3. Create memory file in appropriate directory
-   4. Include frontmatter with relevant tags and importance
+   ```
+   ff-learning-store(
+     title: "Implementation Pattern: [Pattern Name]",
+     description: "Best practice for [scenario] in [technology]",
+     category: "pattern",
+     tags: ["implementation", "pattern", "{technology}"],
+     importance: 0.8,
+     content: "Detailed explanation of the pattern..."
+   )
    ```

package/agents/ff-acceptance.md

@@ -1,8 +1,6 @@
 ---
 description: Validates implementation against acceptance criteria. Use this to verify that code meets all stated requirements and acceptance criteria with strict binary pass/fail validation. This agent cannot invoke sub-agents - it performs validation directly.
 mode: subagent
-model: anthropic/claude-sonnet-4-20250514
-temperature: 0.1
 tools:
   read: true
   write: false
@@ -290,21 +288,18 @@ Before completing your validation task:
    - Ambiguity resolutions and scope clarifications
    - Common gaps between requirements and implementation
 
-2. **Store important learnings** using ff-learning skill:
-   - Create semantic memories for requirement patterns
-   - Create episodic memories for significant validation findings
+2. **Store important learnings** using `ff-learning-store` MCP tool:
+   - Use category `pattern` for requirement patterns and validation techniques
+   - Use category `decision` for significant scope clarifications and findings
    - Tag with requirement types, categories, and validation insights
 
-3. **Example memory format:**
-   ```yaml
-   ---
-   id: 'uuid-from-uuidgen'
-   title: 'Validation Pattern: [Pattern Name]'
-   description: 'Common pattern of [issue] in [type] requirements'
-   date: '2026-02-02T12:00:00Z'
-   memory_type: 'semantic'
-   agent_id: 'ff-acceptance'
-   importance: 0.7
-   tags: ['validation', 'requirements', 'pattern', '{category}']
-   ---
+3. **Example MCP tool call:**
+   ```
+   ff-learning-store(
+     title: "Validation Pattern: [Pattern Name]",
+     description: "Common pattern of [issue] in [type] requirements",
+     category: "pattern",
+     tags: ["validation", "requirements", "pattern", "{category}"],
+     importance: 0.7
+   )
    ```

package/agents/ff-research.md

@@ -1,7 +1,6 @@
 ---
 description: Research specialist that investigates external topics using MCP tools. Use this agent to research libraries, APIs, best practices, and implementation patterns. This agent cannot invoke sub-agents - it performs research directly.
 mode: subagent
-temperature: 0.2
 tools:
   read: true
   write: false
@@ -434,23 +433,19 @@ Before completing your research task:
    - Best practices discovered
    - Source quality assessments
 
-2. **Store important learnings** using ff-learning skill:
-   - Create semantic memories for key findings and knowledge
-   - Create episodic memories for significant research discoveries
+2. **Store important learnings** using `ff-learning-store` MCP tool:
+   - Use category `pattern` for key findings and reusable knowledge
+   - Use category `context` for significant research discoveries and context
    - Tag with research topics, technologies, and categories
    - Set high importance (0.8-1.0) for critical findings
 
-3. **Example memory format:**
-   ```yaml
-   ---
-   id: 'uuid-from-uuidgen'
-   title: 'Research Finding: [Topic]'
-   description: 'Key finding about [topic] from [source]'
-   date: '2026-02-02T12:00:00Z'
-   memory_type: 'semantic'
-   agent_id: 'ff-research'
-   importance: 0.9
-   tags: ['research', '{topic}', '{technology}', 'best-practices']
-   source: 'research'
-   ---
+3. **Example MCP tool call:**
+   ```
+   ff-learning-store(
+     title: "Research Finding: [Topic]",
+     description: "Key finding about [topic] from [source]",
+     category: "pattern",
+     tags: ["research", "{topic}", "{technology}", "best-practices"],
+     importance: 0.9
+   )
    ```

package/agents/ff-review.md

@@ -1,8 +1,6 @@
 ---
 description: Reviews code changes for correctness, quality, and test coverage. Use this for detailed code review focusing on correctness, quality, testing, and documentation. This agent cannot invoke sub-agents - it performs review directly.
 mode: subagent
-model: anthropic/claude-sonnet-4-20250514
-temperature: 0.1
 tools:
   read: true
   write: false
@@ -293,21 +291,18 @@ Before completing your code review:
    - Best practices identified
    - Review technique improvements
 
-2. **Store important learnings** using ff-learning skill:
-   - Create semantic memories for code patterns and anti-patterns
-   - Create episodic memories for significant review findings
+2. **Store important learnings** using `ff-learning-store` MCP tool:
+   - Use category `pattern` for code patterns and anti-patterns
+   - Use category `decision` for significant review findings and trade-offs
    - Tag with code quality categories, technologies, and patterns
 
-3. **Example memory format:**
-   ```yaml
-   ---
-   id: 'uuid-from-uuidgen'
-   title: 'Code Pattern: [Pattern Name]'
-   description: 'Effective pattern for [scenario] in [technology]'
-   date: '2026-02-02T12:00:00Z'
-   memory_type: 'semantic'
-   agent_id: 'ff-review'
-   importance: 0.7
-   tags: ['code-quality', 'pattern', '{technology}', '{category}']
-   ---
+3. **Example MCP tool call:**
+   ```
+   ff-learning-store(
+     title: "Code Pattern: [Pattern Name]",
+     description: "Effective pattern for [scenario] in [technology]",
+     category: "pattern",
+     tags: ["code-quality", "pattern", "{technology}", "{category}"],
+     importance: 0.7
+   )
    ```

package/agents/ff-security.md

@@ -1,8 +1,6 @@
 ---
 description: Performs deep security audits on code changes. Use this to identify security vulnerabilities, check authentication/authorization, and ensure security best practices. This agent cannot invoke sub-agents - it performs audit directly.
 mode: subagent
-model: anthropic/claude-sonnet-4-20250514
-temperature: 0.1
 tools:
   read: true
   write: false
@@ -327,21 +325,18 @@ Before completing your security audit:
    - Threat model insights
    - Common security mistakes observed
 
-2. **Store important learnings** using ff-learning skill:
-   - Create semantic memories for vulnerability patterns and fixes
-   - Create episodic memories for significant security findings
+2. **Store important learnings** using `ff-learning-store` MCP tool:
+   - Use category `pattern` for vulnerability patterns and fixes
+   - Use category `debugging` for significant security findings and investigations
    - Tag with security categories, vulnerability types, and technologies
 
-3. **Example memory format:**
-   ```yaml
-   ---
-   id: 'uuid-from-uuidgen'
-   title: 'Security Pattern: [Vulnerability Type]'
-   description: 'Common [vulnerability] pattern in [context] and how to fix it'
-   date: '2026-02-02T12:00:00Z'
-   memory_type: 'semantic'
-   agent_id: 'ff-security'
-   importance: 0.9
-   tags: ['security', 'vulnerability', '{type}', '{technology}']
-   ---
+3. **Example MCP tool call:**
+   ```
+   ff-learning-store(
+     title: "Security Pattern: [Vulnerability Type]",
+     description: "Common [vulnerability] pattern in [context] and how to fix it",
+     category: "pattern",
+     tags: ["security", "vulnerability", "{type}", "{technology}"],
+     importance: 0.9
+   )
    ```

package/agents/ff-validate.md

@@ -1,8 +1,6 @@
 ---
 description: Performs comprehensive validation covering acceptance criteria, security, code quality, and architecture. Use this for complete validation across all dimensions. This agent cannot invoke sub-agents - it performs all validation directly.
 mode: subagent
-model: anthropic/claude-sonnet-4-20250514
-temperature: 0.1
 tools:
   read: true
   write: false
@@ -321,21 +319,18 @@ Before completing your validation:
    - Validation efficiency improvements
    - Cross-dimensional finding patterns
 
-2. **Store important learnings** using ff-learning skill:
-   - Create semantic memories for validation patterns
-   - Create episodic memories for significant validation results
+2. **Store important learnings** using `ff-learning-store` MCP tool:
+   - Use category `pattern` for validation patterns and effective techniques
+   - Use category `decision` for significant validation findings
    - Tag with validation types and categories
 
-3. **Example memory format:**
-   ```yaml
-   ---
-   id: 'uuid-from-uuidgen'
-   title: 'Validation Pattern: [Pattern Name]'
-   description: 'Common pattern of [findings] when validating [type] changes'
-   date: '2026-02-02T12:00:00Z'
-   memory_type: 'semantic'
-   agent_id: 'ff-validate'
-   importance: 0.7
-   tags: ['validation', 'pattern', '{category}']
-   ---
+3. **Example MCP tool call:**
+   ```
+   ff-learning-store(
+     title: "Validation Pattern: [Pattern Name]",
+     description: "Common pattern of [findings] when validating [type] changes",
+     category: "pattern",
+     tags: ["validation", "pattern", "{category}"],
+     importance: 0.7
+   )
    ```

package/agents/ff-well-architected.md

@@ -1,8 +1,6 @@
 ---
 description: Reviews code against AWS Well-Architected Framework pillars. Use this for architecture reviews covering Operational Excellence, Security, Reliability, Performance, Cost, and Sustainability. This agent cannot invoke sub-agents - it performs review directly.
 mode: subagent
-model: anthropic/claude-sonnet-4-20250514
-temperature: 0.1
 tools:
   read: true
   write: false
@@ -289,21 +287,18 @@ Before completing your architecture review:
    - Scalability and efficiency considerations
    - Cross-pillar interactions and trade-offs
 
-2. **Store important learnings** using ff-learning skill:
-   - Create semantic memories for architectural patterns
-   - Create episodic memories for significant architectural findings
+2. **Store important learnings** using `ff-learning-store` MCP tool:
+   - Use category `pattern` for architectural patterns and best practices
+   - Use category `decision` for significant architectural trade-offs
    - Tag with pillar names, architecture categories, and patterns
 
-3. **Example memory format:**
-   ```yaml
-   ---
-   id: 'uuid-from-uuidgen'
-   title: 'Architecture Pattern: [Pattern Name]'
-   description: 'Pattern for achieving [pillar] excellence in [context]'
-   date: '2026-02-02T12:00:00Z'
-   memory_type: 'semantic'
-   agent_id: 'ff-well-architected'
-   importance: 0.8
-   tags: ['architecture', '{pillar}', 'pattern', '{category}']
-   ---
+3. **Example MCP tool call:**
+   ```
+   ff-learning-store(
+     title: "Architecture Pattern: [Pattern Name]",
+     description: "Pattern for achieving [pillar] excellence in [context]",
+     category: "pattern",
+     tags: ["architecture", "{pillar}", "pattern", "{category}"],
+     importance: 0.8
+   )
    ```

package/agents/planning.md

@@ -1,7 +1,6 @@
 ---
 description: Creates comprehensive implementation plans before making any code changes. Use this agent to analyze requirements, break down tasks, and create detailed implementation plans. Can delegate to read-only sub-agents for parallel research and validation.
 mode: primary
-temperature: 0.1
 color: '#3b82f6'
 tools:
   read: true
@@ -369,32 +368,20 @@ Before completing your planning task:
    - Pattern discoveries from codebase exploration
    - Estimation accuracy and lessons learned
 
-2. **Store important learnings** using ff-learning skill:
-   - Create semantic memories for architectural patterns discovered
-   - Create episodic memories for significant planning decisions
+2. **Store important learnings** using the `ff-learning-store` MCP tool:
+   - Use category `pattern` for architectural patterns discovered
+   - Use category `decision` for significant planning decisions
    - Tag with relevant keywords (architecture, patterns, risks, decisions)
 
 3. **Example learning capture:**
 
-   ```markdown
-   After completing planning:
-
-   1. Generate UUID: `uuidgen` → `550e8400-e29b-41d4-a716-446655440000`
-   2. Create memory file in `.feature-factory/memories/semantic/architecture/`:
-
-   ---
-
-   id: '550e8400-e29b-41d4-a716-446655440000'
-   title: 'Architecture Decision: [Decision Name]'
-   description: 'Rationale for choosing [approach] over [alternatives]'
-   date: '2026-02-02T14:30:00Z'
-   memory_type: 'semantic'
-   agent_id: 'planning'
-   importance: 0.8
-   tags: ['architecture', 'decision', '{technology}']
-   source: 'planning'
-
-   ---
-
-   Detailed explanation of the decision...
+   ```
+   ff-learning-store(
+     title: "Architecture Decision: [Decision Name]",
+     description: "Rationale for choosing [approach] over [alternatives]",
+     category: "decision",
+     tags: ["architecture", "decision", "{technology}"],
+     importance: 0.8,
+     content: "Detailed explanation of the decision..."
+   )
    ```

package/agents/reviewing.md

@@ -1,7 +1,6 @@
 ---
 description: Comprehensive validation agent that reviews implementation quality and feeds results back to the building agent. Use this to validate code changes across all dimensions. Can delegate to read-only sub-agents for parallel validation.
 mode: primary
-temperature: 0.1
 color: '#f59e0b'
 tools:
   read: true
@@ -493,32 +492,20 @@ Before completing your review task:
    - Review effectiveness and process improvements
    - Tool and technique discoveries
 
-2. **Store important learnings** using ff-learning skill:
-   - Create semantic memories for common issue patterns and solutions
-   - Create episodic memories for significant review findings
+2. **Store important learnings** using the `ff-learning-store` MCP tool:
+   - Use category `pattern` for common issue patterns and solutions
+   - Use category `decision` for significant review findings
    - Tag with review type, categories, and technologies reviewed
 
 3. **Example learning capture:**
 
-   ```markdown
-   After completing review:
-
-   1. Generate UUID: `uuidgen` → `550e8400-e29b-41d4-a716-446655440000`
-   2. Create memory file in `.feature-factory/memories/semantic/review-patterns/`:
-
-   ---
-
-   id: '550e8400-e29b-41d4-a716-446655440000'
-   title: 'Review Pattern: [Common Issue Type]'
-   description: 'Common pattern of [issue] found in [context]'
-   date: '2026-02-02T14:30:00Z'
-   memory_type: 'semantic'
-   agent_id: 'reviewing'
-   importance: 0.7
-   tags: ['review', 'pattern', '{issue-type}', '{technology}']
-   source: 'review'
-
-   ---
-
-   Detailed explanation of the pattern and solution...
+   ```
+   ff-learning-store(
+     title: "Review Pattern: [Common Issue Type]",
+     description: "Common pattern of [issue] found in [context]",
+     category: "pattern",
+     tags: ["review", "pattern", "{issue-type}", "{technology}"],
+     importance: 0.7,
+     content: "Detailed explanation of the pattern and solution..."
+   )
    ```

package/bin/ff-deploy.js

@@ -29,6 +29,11 @@ const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
 
 // Default MCP configuration
 const DEFAULT_MCP_SERVERS = {
+  'ff-local-recall': {
+    type: 'local',
+    command: 'ff-local-recall-mcp',
+    enabled: true,
+  },
   'jina-ai': {
     type: 'remote',
     url: 'https://mcp.jina.ai/v1',

package/bin/ff-local-recall-mcp.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+
+import { runLocalRecallMCPServer } from '../dist/local-recall/mcp-stdio-server.js';
+
+runLocalRecallMCPServer().catch((error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`Failed to start ff-local-recall MCP server: ${message}`);
+  process.exit(1);
+});

package/dist/index.js

@@ -1,11 +1,11 @@
 import { StopQualityGateHooksPlugin } from './stop-quality-gate.js';
+import { updateMCPConfig } from './mcp-config.js';
+import { $ } from 'bun';
 // Import tool creator functions
 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 { createFFLearningStoreTool } from './plugins/ff-learning-store-plugin.js';
-import { createFFLearningSearchTool } from './plugins/ff-learning-search-plugin.js';
-import { createFFLearningGetTool } from './plugins/ff-learning-get-plugin.js';
+import { createLearningStoreTool, createLearningSearchTool, createLearningGetTool, createLearningIndexStartTool, createLearningIndexStatusTool, createLearningIndexStopTool, createLearningIndexRebuildTool, initLocalRecall, } from './local-recall/index.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';
@@ -36,6 +36,17 @@ export const FeatureFactoryPlugin = async (input) => {
     if (!directory || directory === '' || directory === '/') {
         return {};
     }
+    // Initialize local-recall memory system
+    initLocalRecall(directory);
+    // Update MCP server configuration in project opencode.json files
+    // This ensures Feature Factory MCP servers are available in the project
+    try {
+        await updateMCPConfig($, directory);
+    }
+    catch (error) {
+        // Silently fail - don't block plugin initialization if MCP config update fails
+        // This is a convenience feature, not critical for plugin functionality
+    }
     // Load hooks from the quality gate plugin
     const qualityGateHooks = await StopQualityGateHooksPlugin(input).catch(() => ({}));
     // Create all tools
@@ -44,10 +55,14 @@ export const FeatureFactoryPlugin = async (input) => {
         'ff-agents-current': createFFAgentsCurrentTool(),
         'ff-agents-show': createFFAgentsShowTool(),
         'ff-agents-clear': createFFAgentsClearTool(),
-        // Learning/memory tools
-        'ff-learning-store': createFFLearningStoreTool(),
-        'ff-learning-search': createFFLearningSearchTool(),
-        'ff-learning-get': createFFLearningGetTool(),
+        // Learning/memory tools (local-recall)
+        'ff-learning-store': createLearningStoreTool(),
+        'ff-learning-search': createLearningSearchTool(),
+        'ff-learning-get': createLearningGetTool(),
+        'ff-learning-index-start': createLearningIndexStartTool(),
+        'ff-learning-index-status': createLearningIndexStatusTool(),
+        'ff-learning-index-stop': createLearningIndexStopTool(),
+        'ff-learning-index-rebuild': createLearningIndexRebuildTool(),
         // Plan tools
         'ff-plan-create': createFFPlanCreateTool(),
         'ff-plan-update': createFFPlanUpdateTool(),

package/dist/local-recall/daemon-controller.d.ts

@@ -0,0 +1,51 @@
+import { type ExtractionStats } from './daemon.js';
+import { OramaMemoryIndex } from './vector/orama-index.js';
+export interface DaemonRunReport {
+    fullRebuild: boolean;
+    extraction: ExtractionStats | null;
+    upserted: number;
+    removed: number;
+    documents: number;
+    durationMs: number;
+    completedAt: string;
+}
+export interface DaemonStatus {
+    running: boolean;
+    processing: boolean;
+    intervalMs: number;
+    pending: boolean;
+    pendingReason: string | null;
+    lastRun: DaemonRunReport | null;
+    lastError: string | null;
+}
+interface ControllerOptions {
+    directory: string;
+    index: OramaMemoryIndex;
+    intervalMs?: number;
+    extractionEnabled?: boolean;
+}
+export declare class LocalRecallDaemonController {
+    private readonly directory;
+    private readonly index;
+    private readonly extractionEnabled;
+    private intervalMs;
+    private timer;
+    private running;
+    private processing;
+    private pending;
+    private pendingFullRebuild;
+    private pendingReason;
+    private lastRun;
+    private lastError;
+    constructor(options: ControllerOptions);
+    start(intervalMs?: number): DaemonStatus;
+    stop(): DaemonStatus;
+    requestRun(reason?: string, fullRebuild?: boolean): void;
+    runNow(reason?: string, fullRebuild?: boolean): Promise<DaemonStatus>;
+    rebuild(): Promise<DaemonStatus>;
+    getStatus(): DaemonStatus;
+    private runLoop;
+    private runCycle;
+    private waitForIdle;
+}
+export {};