@syntesseraai/opencode-feature-factory 0.3.0 → 0.3.2

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 `ff-memories/` (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

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

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

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

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

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

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

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

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

package/bin/ff-deploy.js

@@ -29,6 +29,17 @@ const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
 
 // Default MCP configuration
 const DEFAULT_MCP_SERVERS = {
+  'ff-local-recall': {
+    type: 'local',
+    command: [
+      'npx',
+      '-y',
+      '--package=@syntesseraai/opencode-feature-factory@latest',
+      '--',
+      '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,9 +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 { createLearningStoreTool, createLearningSearchTool, createLearningGetTool, initLocalRecall, } from './local-recall/index.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 +38,15 @@ export const FeatureFactoryPlugin = async (input) => {
     }
     // Initialize local-recall memory system
     initLocalRecall(directory);
+    // Update MCP server configuration in global OpenCode config
+    // This ensures Feature Factory MCP servers are available across projects
+    try {
+        await updateMCPConfig($);
+    }
+    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
@@ -48,6 +59,10 @@ export const FeatureFactoryPlugin = async (input) => {
         '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 {};

package/dist/local-recall/daemon-controller.js

@@ -0,0 +1,166 @@
+import { runExtraction } from './daemon.js';
+import { computeMemoryHash, readIndexState, writeIndexState } from './index-state.js';
+import { listAllMemories } from './memory-service.js';
+const DEFAULT_INTERVAL_MS = 15_000;
+export class LocalRecallDaemonController {
+    directory;
+    index;
+    extractionEnabled;
+    intervalMs;
+    timer = null;
+    running = false;
+    processing = false;
+    pending = false;
+    pendingFullRebuild = false;
+    pendingReason = null;
+    lastRun = null;
+    lastError = null;
+    constructor(options) {
+        this.directory = options.directory;
+        this.index = options.index;
+        this.intervalMs = options.intervalMs ?? DEFAULT_INTERVAL_MS;
+        this.extractionEnabled = options.extractionEnabled ?? true;
+    }
+    start(intervalMs) {
+        if (intervalMs && intervalMs > 0) {
+            this.intervalMs = intervalMs;
+        }
+        if (this.running) {
+            return this.getStatus();
+        }
+        this.running = true;
+        this.timer = setInterval(() => {
+            this.requestRun('interval');
+        }, this.intervalMs);
+        this.requestRun('startup');
+        return this.getStatus();
+    }
+    stop() {
+        this.running = false;
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        return this.getStatus();
+    }
+    requestRun(reason = 'manual', fullRebuild = false) {
+        this.pending = true;
+        this.pendingReason = reason;
+        if (fullRebuild) {
+            this.pendingFullRebuild = true;
+        }
+        void this.runLoop();
+    }
+    async runNow(reason = 'manual', fullRebuild = false) {
+        this.requestRun(reason, fullRebuild);
+        await this.waitForIdle();
+        return this.getStatus();
+    }
+    async rebuild() {
+        return this.runNow('rebuild', true);
+    }
+    getStatus() {
+        return {
+            running: this.running,
+            processing: this.processing,
+            intervalMs: this.intervalMs,
+            pending: this.pending,
+            pendingReason: this.pendingReason,
+            lastRun: this.lastRun,
+            lastError: this.lastError,
+        };
+    }
+    async runLoop() {
+        if (this.processing) {
+            return;
+        }
+        this.processing = true;
+        try {
+            while (this.pending) {
+                const fullRebuild = this.pendingFullRebuild;
+                this.pending = false;
+                this.pendingFullRebuild = false;
+                this.pendingReason = null;
+                await this.runCycle(fullRebuild);
+            }
+        }
+        finally {
+            this.processing = false;
+        }
+    }
+    async runCycle(fullRebuild) {
+        const startedAt = Date.now();
+        this.lastError = null;
+        try {
+            const extraction = this.extractionEnabled ? await runExtraction(this.directory) : null;
+            const allMemories = await listAllMemories(this.directory);
+            const now = Date.now();
+            let upserted = 0;
+            let removed = 0;
+            if (fullRebuild) {
+                upserted = await this.index.rebuild(allMemories);
+            }
+            else {
+                const previousState = await readIndexState(this.directory);
+                const nextEntries = {};
+                const changed = [];
+                for (const memory of allMemories) {
+                    const hash = computeMemoryHash(memory);
+                    nextEntries[memory.id] = {
+                        hash,
+                        updatedAt: now,
+                    };
+                    const previous = previousState.entries[memory.id];
+                    if (!previous || previous.hash !== hash) {
+                        changed.push(memory);
+                    }
+                }
+                const removedIDs = Object.keys(previousState.entries).filter((id) => !nextEntries[id]);
+                if (changed.length > 0) {
+                    upserted = await this.index.upsertMemories(changed);
+                }
+                if (removedIDs.length > 0) {
+                    removed = await this.index.removeMemories(removedIDs);
+                }
+            }
+            await writeIndexState(this.directory, {
+                version: 1,
+                entries: Object.fromEntries(allMemories.map((memory) => [
+                    memory.id,
+                    {
+                        hash: computeMemoryHash(memory),
+                        updatedAt: now,
+                    },
+                ])),
+                updatedAt: now,
+            });
+            const documents = this.index.getStatus().documents;
+            this.lastRun = {
+                fullRebuild,
+                extraction,
+                upserted,
+                removed,
+                documents,
+                durationMs: Date.now() - startedAt,
+                completedAt: new Date().toISOString(),
+            };
+        }
+        catch (error) {
+            this.lastError = error instanceof Error ? error.message : String(error);
+            this.lastRun = {
+                fullRebuild,
+                extraction: null,
+                upserted: 0,
+                removed: 0,
+                documents: this.index.getStatus().documents,
+                durationMs: Date.now() - startedAt,
+                completedAt: new Date().toISOString(),
+            };
+        }
+    }
+    async waitForIdle() {
+        while (this.processing || this.pending) {
+            await new Promise((resolve) => setTimeout(resolve, 25));
+        }
+    }
+}

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

@@ -1,7 +1,7 @@
 /**
  * daemon.ts — Background extraction daemon for local-recall.
  *
- * Scans OpenCode session storage for unprocessed assistant messages,
+ * Scans OpenCode session storage for unprocessed assistant and thinking messages,
  * runs the extraction pipeline (session + thinking extractors),
  * and stores resulting memories with logical IDs and content-hash
  * idempotency.
@@ -26,7 +26,7 @@ export interface ExtractionStats {
  *
  * 1. Find the OpenCode project matching `directory`
  * 2. Load existing processed log for fast membership checks
- * 3. Iterate sessions → messages (assistant only)
+ * 3. Iterate sessions → messages (assistant + thinking)
  * 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)

package/dist/local-recall/daemon.js

@@ -1,7 +1,7 @@
 /**
  * daemon.ts — Background extraction daemon for local-recall.
  *
- * Scans OpenCode session storage for unprocessed assistant messages,
+ * Scans OpenCode session storage for unprocessed assistant and thinking messages,
  * runs the extraction pipeline (session + thinking extractors),
  * and stores resulting memories with logical IDs and content-hash
  * idempotency.
@@ -14,13 +14,12 @@
  *   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';
+import { getMemoriesDir, storeMemories } from './memory-service.js';
 // ────────────────────────────────────────────────────────────
 // Helpers
 // ────────────────────────────────────────────────────────────
@@ -33,7 +32,7 @@ async function buildMessageContentHash(messageID) {
     try {
         const parts = await listParts(messageID);
         const textParts = parts
-            .filter((p) => p.type === 'text' || p.type === 'reasoning')
+            .filter((p) => p.type === 'text' || p.type === 'reasoning' || p.type === 'thinking')
             .map((p) => p.text ?? '')
             .join('\n');
         // Hash content only (no messageID) so dedupe works across ID changes
@@ -52,7 +51,7 @@ async function buildMessageContentHash(messageID) {
  *
  * 1. Find the OpenCode project matching `directory`
  * 2. Load existing processed log for fast membership checks
- * 3. Iterate sessions → messages (assistant only)
+ * 3. Iterate sessions → messages (assistant + thinking)
  * 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)
@@ -74,8 +73,7 @@ export async function runExtraction(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 });
+        await fs.mkdir(getMemoriesDir(directory), { recursive: true });
         // Pre-load processed log for fast lookups
         const existingLog = await readProcessedLog(directory);
         const processedMsgIDs = getProcessedMessageIDs(existingLog);
@@ -90,8 +88,8 @@ export async function runExtraction(directory) {
                 const messages = await listMessages(session.id);
                 for (const message of messages) {
                     stats.messagesScanned++;
-                    // Only process assistant messages
-                    if (message.role !== 'assistant') {
+                    // Only process assistant and thinking messages
+                    if (message.role !== 'assistant' && message.role !== 'thinking') {
                         stats.messagesSkipped++;
                         continue;
                     }

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

@@ -0,0 +1,14 @@
+import type { Memory } from './types.js';
+export interface IndexStateEntry {
+    hash: string;
+    updatedAt: number;
+}
+export interface IndexState {
+    version: 1;
+    entries: Record<string, IndexStateEntry>;
+    updatedAt: number;
+}
+export declare function getIndexStatePath(directory: string): string;
+export declare function readIndexState(directory: string): Promise<IndexState>;
+export declare function writeIndexState(directory: string, state: IndexState): Promise<void>;
+export declare function computeMemoryHash(memory: Memory): string;

package/dist/local-recall/index-state.js

@@ -0,0 +1,76 @@
+import { createHash } from 'node:crypto';
+import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+const EMPTY_STATE = {
+    version: 1,
+    entries: {},
+    updatedAt: 0,
+};
+function getIndexDir(directory) {
+    return path.join(directory, 'ff-memories', 'index');
+}
+export function getIndexStatePath(directory) {
+    return path.join(getIndexDir(directory), 'state.json');
+}
+function normalizeState(raw) {
+    if (!raw || typeof raw !== 'object') {
+        return { ...EMPTY_STATE };
+    }
+    const value = raw;
+    const entries = {};
+    if (value.entries && typeof value.entries === 'object') {
+        for (const [id, entry] of Object.entries(value.entries)) {
+            if (!entry || typeof entry !== 'object') {
+                continue;
+            }
+            const candidate = entry;
+            if (typeof candidate.hash !== 'string') {
+                continue;
+            }
+            entries[id] = {
+                hash: candidate.hash,
+                updatedAt: typeof candidate.updatedAt === 'number' ? candidate.updatedAt : 0,
+            };
+        }
+    }
+    return {
+        version: value.version === 1 ? 1 : 1,
+        entries,
+        updatedAt: typeof value.updatedAt === 'number' ? value.updatedAt : 0,
+    };
+}
+async function writeAtomic(filePath, value) {
+    const tmpPath = `${filePath}.${process.pid}.${Date.now()}.tmp`;
+    await writeFile(tmpPath, JSON.stringify(value, null, 2), 'utf-8');
+    await rename(tmpPath, filePath);
+}
+export async function readIndexState(directory) {
+    const filePath = getIndexStatePath(directory);
+    try {
+        const raw = await readFile(filePath, 'utf-8');
+        return normalizeState(JSON.parse(raw));
+    }
+    catch {
+        return { ...EMPTY_STATE };
+    }
+}
+export async function writeIndexState(directory, state) {
+    const filePath = getIndexStatePath(directory);
+    await mkdir(path.dirname(filePath), { recursive: true });
+    await writeAtomic(filePath, state);
+}
+export function computeMemoryHash(memory) {
+    const stable = JSON.stringify({
+        id: memory.id,
+        sessionID: memory.sessionID,
+        messageID: memory.messageID,
+        category: memory.category,
+        title: memory.title,
+        body: memory.body,
+        tags: [...memory.tags].sort(),
+        importance: memory.importance,
+        createdAt: memory.createdAt,
+        extractedBy: memory.extractedBy,
+    });
+    return createHash('sha256').update(stable).digest('hex');
+}

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

@@ -10,5 +10,11 @@ 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';
+export { LocalRecallDaemonController, type DaemonStatus, type DaemonRunReport, } from './daemon-controller.js';
+export { readIndexState, writeIndexState, computeMemoryHash, getIndexStatePath, type IndexState, type IndexStateEntry, } from './index-state.js';
+export { createEmbeddingProvider, OllamaEmbeddingProvider, OpenAIEmbeddingProvider, } from './vector/embedding-provider.js';
+export { OramaMemoryIndex } from './vector/orama-index.js';
+export type { EmbeddingProvider, EmbeddingProviderName, VectorIndexManifest, VectorIndexDocument, VectorSearchResponse, } from './vector/types.js';
+export { initLocalRecall, isInitialized, getDirectory, triggerExtraction, getLastExtractionStats, shutdownLocalRecall, storeLearningMemory, searchLearningMemories, getLearningMemory, startIndexingDaemon, stopIndexingDaemon, getIndexingStatus, rebuildIndex, listLearningMemories, type LearningStoreInput, type IndexingStatus, } from './mcp-server.js';
+export { runLocalRecallMCPServer, type LocalRecallMCPServerOptions } from './mcp-stdio-server.js';
+export { createLearningStoreTool, createLearningSearchTool, createLearningGetTool, createLearningIndexStartTool, createLearningIndexStatusTool, createLearningIndexStopTool, createLearningIndexRebuildTool, } from './mcp-tools.js';

package/dist/local-recall/index.js

@@ -14,7 +14,14 @@ export { extractThinkingFromMessage, extractFromThinkingParts } from './thinking
 export { isProcessed, isContentProcessed, markProcessed, readProcessedLog, contentHash, getProcessedMessageIDs, getProcessedHashes, } from './processed-log.js';
 // Daemon
 export { runExtraction } from './daemon.js';
+export { LocalRecallDaemonController, } from './daemon-controller.js';
+// Index state
+export { readIndexState, writeIndexState, computeMemoryHash, getIndexStatePath, } from './index-state.js';
+// Vector index
+export { createEmbeddingProvider, OllamaEmbeddingProvider, OpenAIEmbeddingProvider, } from './vector/embedding-provider.js';
+export { OramaMemoryIndex } from './vector/orama-index.js';
 // MCP server lifecycle
-export { initLocalRecall, isInitialized, getDirectory, triggerExtraction, getLastExtractionStats, shutdownLocalRecall, } from './mcp-server.js';
+export { initLocalRecall, isInitialized, getDirectory, triggerExtraction, getLastExtractionStats, shutdownLocalRecall, storeLearningMemory, searchLearningMemories, getLearningMemory, startIndexingDaemon, stopIndexingDaemon, getIndexingStatus, rebuildIndex, listLearningMemories, } from './mcp-server.js';
+export { runLocalRecallMCPServer } from './mcp-stdio-server.js';
 // MCP tools (plugin tool creators)
-export { createLearningStoreTool, createLearningSearchTool, createLearningGetTool, } from './mcp-tools.js';
+export { createLearningStoreTool, createLearningSearchTool, createLearningGetTool, createLearningIndexStartTool, createLearningIndexStatusTool, createLearningIndexStopTool, createLearningIndexRebuildTool, } from './mcp-tools.js';