@syntesseraai/opencode-feature-factory 0.2.45 → 0.3.0

package/agents/building.md

@@ -463,22 +463,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

@@ -290,21 +290,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

@@ -434,23 +434,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

@@ -293,21 +293,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

@@ -327,21 +327,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

@@ -321,21 +321,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

@@ -289,21 +289,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

@@ -369,32 +369,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

@@ -493,32 +493,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/dist/index.js

@@ -3,9 +3,7 @@ import { StopQualityGateHooksPlugin } from './stop-quality-gate.js';
 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, 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 +34,8 @@ export const FeatureFactoryPlugin = async (input) => {
     if (!directory || directory === '' || directory === '/') {
         return {};
     }
+    // Initialize local-recall memory system
+    initLocalRecall(directory);
     // Load hooks from the quality gate plugin
     const qualityGateHooks = await StopQualityGateHooksPlugin(input).catch(() => ({}));
     // Create all tools
@@ -44,10 +44,10 @@ 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(),
         // Plan tools
         'ff-plan-create': createFFPlanCreateTool(),
         'ff-plan-update': createFFPlanUpdateTool(),

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

@@ -0,0 +1,35 @@
+/**
+ * daemon.ts — Background extraction daemon for local-recall.
+ *
+ * Scans OpenCode session storage for unprocessed assistant messages,
+ * runs the extraction pipeline (session + thinking extractors),
+ * and stores resulting memories with logical IDs and content-hash
+ * idempotency.
+ *
+ * Logical ID conventions:
+ *   session memories → session-<sessionID>-<messageID>-<index>
+ *   thinking memories → thinking-<sessionID>-<messageID>-<index>
+ *
+ * Idempotency is dual-layer:
+ *   1. Message-ID check (fast skip for already-processed messages)
+ *   2. Content-hash check (skips duplicate content across edits/replays)
+ */
+export interface ExtractionStats {
+    sessionsScanned: number;
+    messagesScanned: number;
+    messagesSkipped: number;
+    newMemories: number;
+    errors: string[];
+}
+/**
+ * Run a full extraction pass for the project rooted at `directory`.
+ *
+ * 1. Find the OpenCode project matching `directory`
+ * 2. Load existing processed log for fast membership checks
+ * 3. Iterate sessions → messages (assistant only)
+ * 4. Skip by message-ID *and* content-hash (dual idempotency)
+ * 5. Run session + thinking extractors
+ * 6. Assign logical IDs (session-<sid>-<msgid>-N / thinking-<sid>-<msgid>-N)
+ * 7. Store new memories & update processed log
+ */
+export declare function runExtraction(directory: string): Promise<ExtractionStats>;

package/dist/local-recall/daemon.js

@@ -0,0 +1,188 @@
+/**
+ * daemon.ts — Background extraction daemon for local-recall.
+ *
+ * Scans OpenCode session storage for unprocessed assistant messages,
+ * runs the extraction pipeline (session + thinking extractors),
+ * and stores resulting memories with logical IDs and content-hash
+ * idempotency.
+ *
+ * Logical ID conventions:
+ *   session memories → session-<sessionID>-<messageID>-<index>
+ *   thinking memories → thinking-<sessionID>-<messageID>-<index>
+ *
+ * Idempotency is dual-layer:
+ *   1. Message-ID check (fast skip for already-processed messages)
+ *   2. Content-hash check (skips duplicate content across edits/replays)
+ */
+import * as path from 'node:path';
+import * as fs from 'node:fs/promises';
+import { findProject, listSessions, listMessages, listParts } from './storage-reader.js';
+import { extractFromMessage } from './session-extractor.js';
+import { extractThinkingFromMessage } from './thinking-extractor.js';
+import { readProcessedLog, getProcessedMessageIDs, getProcessedHashes, markProcessed, contentHash, } from './processed-log.js';
+import { storeMemories } from './memory-service.js';
+// ────────────────────────────────────────────────────────────
+// Helpers
+// ────────────────────────────────────────────────────────────
+/**
+ * Build a deterministic content hash for a message based on its
+ * concatenated part text.  This allows us to detect duplicate
+ * processing even when message IDs change.
+ */
+async function buildMessageContentHash(messageID) {
+    try {
+        const parts = await listParts(messageID);
+        const textParts = parts
+            .filter((p) => p.type === 'text' || p.type === 'reasoning')
+            .map((p) => p.text ?? '')
+            .join('\n');
+        // Hash content only (no messageID) so dedupe works across ID changes
+        return contentHash(textParts);
+    }
+    catch {
+        // Fallback: hash the message ID itself (best effort)
+        return contentHash(messageID);
+    }
+}
+// ────────────────────────────────────────────────────────────
+// Main extraction loop
+// ────────────────────────────────────────────────────────────
+/**
+ * Run a full extraction pass for the project rooted at `directory`.
+ *
+ * 1. Find the OpenCode project matching `directory`
+ * 2. Load existing processed log for fast membership checks
+ * 3. Iterate sessions → messages (assistant only)
+ * 4. Skip by message-ID *and* content-hash (dual idempotency)
+ * 5. Run session + thinking extractors
+ * 6. Assign logical IDs (session-<sid>-<msgid>-N / thinking-<sid>-<msgid>-N)
+ * 7. Store new memories & update processed log
+ */
+export async function runExtraction(directory) {
+    const stats = {
+        sessionsScanned: 0,
+        messagesScanned: 0,
+        messagesSkipped: 0,
+        newMemories: 0,
+        errors: [],
+    };
+    try {
+        // Find project for this directory
+        const project = await findProject(directory);
+        if (!project) {
+            stats.errors.push(`No OpenCode project found for directory: ${directory}`);
+            return stats;
+        }
+        // Ensure local-recall directories exist
+        const recallDir = path.join(directory, '.feature-factory', 'local-recall');
+        await fs.mkdir(path.join(recallDir, 'memories'), { recursive: true });
+        // Pre-load processed log for fast lookups
+        const existingLog = await readProcessedLog(directory);
+        const processedMsgIDs = getProcessedMessageIDs(existingLog);
+        const processedHashes = getProcessedHashes(existingLog);
+        // Iterate sessions
+        const sessions = await listSessions(project.id);
+        stats.sessionsScanned = sessions.length;
+        const newProcessedEntries = [];
+        const allNewMemories = [];
+        for (const session of sessions) {
+            try {
+                const messages = await listMessages(session.id);
+                for (const message of messages) {
+                    stats.messagesScanned++;
+                    // Only process assistant messages
+                    if (message.role !== 'assistant') {
+                        stats.messagesSkipped++;
+                        continue;
+                    }
+                    // Layer 1: skip by message ID
+                    if (processedMsgIDs.has(message.id)) {
+                        stats.messagesSkipped++;
+                        continue;
+                    }
+                    // Layer 2: skip by content hash
+                    const msgHash = await buildMessageContentHash(message.id);
+                    if (processedHashes.has(msgHash)) {
+                        stats.messagesSkipped++;
+                        continue;
+                    }
+                    try {
+                        const input = {
+                            sessionID: session.id,
+                            messageID: message.id,
+                        };
+                        // Run both extractors in parallel
+                        const [sessionResults, thinkingResults] = await Promise.all([
+                            extractFromMessage(input),
+                            extractThinkingFromMessage(input),
+                        ]);
+                        // Convert ExtractionResult → Memory with logical IDs
+                        const sessionMemories = sessionResults.map((r, idx) => ({
+                            id: `session-${session.id}-${message.id}-${idx}`,
+                            sessionID: r.sessionID,
+                            messageID: r.messageID,
+                            category: r.category,
+                            title: r.title,
+                            body: r.body,
+                            tags: r.tags,
+                            importance: r.importance,
+                            createdAt: message.time?.created ?? Date.now(),
+                            extractedBy: 'local-recall-daemon',
+                        }));
+                        const thinkingMemories = thinkingResults.map((r, idx) => ({
+                            id: `thinking-${session.id}-${message.id}-${idx}`,
+                            sessionID: r.sessionID,
+                            messageID: r.messageID,
+                            category: r.category,
+                            title: r.title,
+                            body: r.body,
+                            tags: r.tags,
+                            importance: r.importance,
+                            createdAt: message.time?.created ?? Date.now(),
+                            extractedBy: 'local-recall-daemon',
+                        }));
+                        const memories = [...sessionMemories, ...thinkingMemories];
+                        allNewMemories.push(...memories);
+                        // Add to fast-lookup sets so subsequent messages in this
+                        // pass are also deduplicated
+                        processedMsgIDs.add(message.id);
+                        processedHashes.add(msgHash);
+                        // Mark as processed with content hash
+                        newProcessedEntries.push({
+                            messageID: message.id,
+                            contentHash: msgHash,
+                            processedAt: Date.now(),
+                            memoriesCreated: memories.length,
+                        });
+                    }
+                    catch (err) {
+                        stats.errors.push(`Error processing message ${message.id}: ${err instanceof Error ? err.message : String(err)}`);
+                        // Still mark as processed to avoid re-trying broken messages
+                        newProcessedEntries.push({
+                            messageID: message.id,
+                            contentHash: msgHash,
+                            processedAt: Date.now(),
+                            memoriesCreated: 0,
+                        });
+                    }
+                }
+            }
+            catch (err) {
+                stats.errors.push(`Error processing session ${session.id}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        // Batch store all new memories
+        if (allNewMemories.length > 0) {
+            await storeMemories(directory, allNewMemories);
+            stats.newMemories = allNewMemories.length;
+        }
+        // Batch update processed log
+        if (newProcessedEntries.length > 0) {
+            await markProcessed(directory, newProcessedEntries);
+        }
+    }
+    catch (err) {
+        stats.errors.push(`Extraction failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return stats;
+}

package/dist/local-recall/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * local-recall/index.ts — Barrel export for the local-recall module.
+ *
+ * Re-exports all public APIs from the local-recall memory system.
+ */
+export type { Memory, MemoryCategory, SearchCriteria, MemorySearchResult, ExtractionInput, ExtractionResult, ProcessedEntry, OCProject, OCSession, OCMessage, OCPart, } from './types.js';
+export { findProject, listProjects, listSessions, getSession, listMessages, getMessage, listParts, getPart, } from './storage-reader.js';
+export { storeMemory, storeMemories, getMemory, listAllMemories, searchMemories, } from './memory-service.js';
+export { extractFromMessage, extractFromParts } from './session-extractor.js';
+export { extractThinkingFromMessage, extractFromThinkingParts } from './thinking-extractor.js';
+export { isProcessed, isContentProcessed, markProcessed, readProcessedLog, contentHash, getProcessedMessageIDs, getProcessedHashes, } from './processed-log.js';
+export { runExtraction, type ExtractionStats } from './daemon.js';
+export { initLocalRecall, isInitialized, getDirectory, triggerExtraction, getLastExtractionStats, shutdownLocalRecall, } from './mcp-server.js';
+export { createLearningStoreTool, createLearningSearchTool, createLearningGetTool, } from './mcp-tools.js';

package/dist/local-recall/index.js

@@ -0,0 +1,20 @@
+/**
+ * local-recall/index.ts — Barrel export for the local-recall module.
+ *
+ * Re-exports all public APIs from the local-recall memory system.
+ */
+// Storage reader
+export { findProject, listProjects, listSessions, getSession, listMessages, getMessage, listParts, getPart, } from './storage-reader.js';
+// Memory service
+export { storeMemory, storeMemories, getMemory, listAllMemories, searchMemories, } from './memory-service.js';
+// Extractors
+export { extractFromMessage, extractFromParts } from './session-extractor.js';
+export { extractThinkingFromMessage, extractFromThinkingParts } from './thinking-extractor.js';
+// Processed log
+export { isProcessed, isContentProcessed, markProcessed, readProcessedLog, contentHash, getProcessedMessageIDs, getProcessedHashes, } from './processed-log.js';
+// Daemon
+export { runExtraction } from './daemon.js';
+// MCP server lifecycle
+export { initLocalRecall, isInitialized, getDirectory, triggerExtraction, getLastExtractionStats, shutdownLocalRecall, } from './mcp-server.js';
+// MCP tools (plugin tool creators)
+export { createLearningStoreTool, createLearningSearchTool, createLearningGetTool, } from './mcp-tools.js';