@syntesseraai/opencode-feature-factory 0.3.0 → 0.3.1

package/dist/local-recall/mcp-tools.js

@@ -1,28 +1,24 @@
-/**
- * mcp-tools.ts — OpenCode plugin tool definitions for local-recall.
- *
- * Replaces the legacy ff-learning-{store,search,get} plugins with
- * MCP-backed tools that read from OpenCode's session storage and
- * expose the local-recall memory system.
- *
- * Public contract uses the native MemoryCategory taxonomy
- * (pattern, decision, debugging, preference, context, procedure).
- * The public contract exposes only category-based MCP tools.
- */
 import { tool } from '@opencode-ai/plugin/tool';
-import { searchMemories, getMemory } from './memory-service.js';
-import { runExtraction } from './daemon.js';
-// ────────────────────────────────────────────────────────────
-// ff-learning-store  →  triggers extraction + explicit store
-// ────────────────────────────────────────────────────────────
+import { getIndexingStatus, getLearningMemory, rebuildIndex, searchLearningMemories, startIndexingDaemon, stopIndexingDaemon, storeLearningMemory, } from './mcp-server.js';
+function errorResponse(error) {
+    return JSON.stringify({
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+    });
+}
 export const createLearningStoreTool = () => tool({
-    description: 'Store a new learning/memory. Creates a JSON memory file in .feature-factory/local-recall/memories/. ' +
-        'Also triggers extraction from OpenCode session history so that ' +
-        'new memories are automatically captured from recent conversations.',
+    description: 'Store a memory in local-recall and enqueue asynchronous daemon indexing. Returns memory ID and daemon status.',
     args: {
         title: tool.schema.string('Title for the memory'),
         description: tool.schema.string('Brief description of the learning'),
-        category: tool.schema.enum(['pattern', 'decision', 'debugging', 'preference', 'context', 'procedure'], 'Category of memory: pattern (reusable code), decision (arch/design), debugging (error resolution), preference (user pref), context (domain knowledge), procedure (how-to)'),
+        category: tool.schema.enum([
+            'pattern',
+            'decision',
+            'debugging',
+            'preference',
+            'context',
+            'procedure',
+        ]),
         tags: tool.schema.array(tool.schema.string(), 'Tags for categorization'),
         importance: tool.schema.number('Importance score from 0 to 1').optional(),
         content: tool.schema.string('Full content/body of the memory').optional(),
@@ -38,46 +34,28 @@ export const createLearningStoreTool = () => tool({
     },
     async execute(args, toolCtx) {
         try {
-            // Run extraction to ensure latest session data is captured
-            const stats = await runExtraction(toolCtx.directory);
-            // Also store the explicit memory from the agent
-            const { storeMemory } = await import('./memory-service.js');
-            const memory = {
-                id: crypto.randomUUID(),
-                sessionID: 'agent-explicit',
-                messageID: 'agent-explicit',
-                category: args.category,
+            const result = await storeLearningMemory(toolCtx.directory, {
                 title: args.title,
-                body: args.content ?? args.description,
+                description: args.description,
+                category: args.category,
                 tags: args.tags,
-                importance: args.importance ?? 0.7,
-                createdAt: Date.now(),
-                extractedBy: 'agent-explicit',
-            };
-            const result = await storeMemory(toolCtx.directory, memory);
+                importance: args.importance,
+                content: args.content,
+            });
             return JSON.stringify({
                 success: true,
-                memoryId: result.id,
-                extractionStats: {
-                    sessionsScanned: stats.sessionsScanned,
-                    newMemories: stats.newMemories,
-                },
+                memoryId: result.memoryId,
+                queued: true,
+                daemon: result.daemon,
             });
         }
-        catch (err) {
-            return JSON.stringify({
-                success: false,
-                error: err instanceof Error ? err.message : String(err),
-            });
+        catch (error) {
+            return errorResponse(error);
         }
     },
 });
-// ────────────────────────────────────────────────────────────
-// ff-learning-search  →  searches local-recall memory store
-// ────────────────────────────────────────────────────────────
 export const createLearningSearchTool = () => tool({
-    description: 'Search for memories by query, tags, or category. Returns matching memory metadata sorted by relevance and importance. ' +
-        'Searches the local-recall memory store which is automatically populated from OpenCode session history.',
+    description: 'Search local-recall memories. Uses vector index when available and falls back to lexical search on provider failure.',
     args: {
         query: tool.schema.string('Search query to match against memory content'),
         tags: tool.schema.array(tool.schema.string(), 'Filter by tags').optional(),
@@ -89,7 +67,7 @@ export const createLearningSearchTool = () => tool({
     },
     async execute(args, toolCtx) {
         try {
-            const results = await searchMemories(toolCtx.directory, {
+            const result = await searchLearningMemories(toolCtx.directory, {
                 query: args.query,
                 tags: args.tags,
                 category: args.category,
@@ -97,39 +75,34 @@ export const createLearningSearchTool = () => tool({
                 limit: Math.min(Math.max(args.limit ?? 10, 1), 50),
             });
             return JSON.stringify({
-                count: results.length,
-                memories: results.map((r) => ({
-                    id: r.id,
-                    title: r.title,
-                    category: r.category,
-                    tags: r.tags,
-                    importance: r.importance,
-                    relevance: Math.round(r.relevance * 100) / 100,
-                    createdAt: r.createdAt,
-                    sessionID: r.sessionID,
+                backend: result.backend,
+                fallbackReason: result.fallbackReason,
+                count: result.results.length,
+                memories: result.results.map((memory) => ({
+                    id: memory.id,
+                    title: memory.title,
+                    category: memory.category,
+                    tags: memory.tags,
+                    importance: memory.importance,
+                    relevance: Math.round(memory.relevance * 100) / 100,
+                    createdAt: memory.createdAt,
+                    sessionID: memory.sessionID,
                 })),
             });
         }
-        catch (err) {
-            return JSON.stringify({
-                success: false,
-                error: err instanceof Error ? err.message : String(err),
-            });
+        catch (error) {
+            return errorResponse(error);
         }
     },
 });
-// ────────────────────────────────────────────────────────────
-// ff-learning-get  →  retrieves a specific memory by ID
-// ────────────────────────────────────────────────────────────
 export const createLearningGetTool = () => tool({
-    description: 'Retrieve the full content of a specific memory by its unique ID. ' +
-        'Returns the complete memory including body text from the local-recall store.',
+    description: 'Retrieve the full content of a specific memory by ID from local-recall.',
     args: {
         memoryId: tool.schema.string('Unique memory ID to retrieve'),
     },
     async execute(args, toolCtx) {
         try {
-            const memory = await getMemory(toolCtx.directory, args.memoryId);
+            const memory = await getLearningMemory(toolCtx.directory, args.memoryId);
             if (!memory) {
                 return JSON.stringify({
                     success: false,
@@ -138,25 +111,77 @@ export const createLearningGetTool = () => tool({
             }
             return JSON.stringify({
                 success: true,
-                memory: {
-                    id: memory.id,
-                    sessionID: memory.sessionID,
-                    messageID: memory.messageID,
-                    category: memory.category,
-                    title: memory.title,
-                    body: memory.body,
-                    tags: memory.tags,
-                    importance: memory.importance,
-                    createdAt: memory.createdAt,
-                    extractedBy: memory.extractedBy,
-                },
+                memory,
+            });
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    },
+});
+export const createLearningIndexStartTool = () => tool({
+    description: 'Start local-recall indexing daemon and return status.',
+    args: {
+        intervalMs: tool.schema.number('Optional daemon interval in milliseconds').optional(),
+    },
+    async execute(args, toolCtx) {
+        try {
+            const status = await startIndexingDaemon(toolCtx.directory, args.intervalMs);
+            return JSON.stringify({
+                success: true,
+                ...status,
             });
         }
-        catch (err) {
+        catch (error) {
+            return errorResponse(error);
+        }
+    },
+});
+export const createLearningIndexStatusTool = () => tool({
+    description: 'Get current local-recall indexing daemon and index status.',
+    args: {},
+    async execute(_args, toolCtx) {
+        try {
+            const status = await getIndexingStatus(toolCtx.directory);
             return JSON.stringify({
-                success: false,
-                error: err instanceof Error ? err.message : String(err),
+                success: true,
+                ...status,
             });
         }
+        catch (error) {
+            return errorResponse(error);
+        }
+    },
+});
+export const createLearningIndexStopTool = () => tool({
+    description: 'Stop local-recall indexing daemon and return status.',
+    args: {},
+    async execute(_args, toolCtx) {
+        try {
+            const status = await stopIndexingDaemon(toolCtx.directory);
+            return JSON.stringify({
+                success: true,
+                ...status,
+            });
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
+    },
+});
+export const createLearningIndexRebuildTool = () => tool({
+    description: 'Trigger a full local-recall index rebuild and return status.',
+    args: {},
+    async execute(_args, toolCtx) {
+        try {
+            const status = await rebuildIndex(toolCtx.directory);
+            return JSON.stringify({
+                success: true,
+                ...status,
+            });
+        }
+        catch (error) {
+            return errorResponse(error);
+        }
     },
 });

package/dist/local-recall/vector/embedding-provider.d.ts

@@ -0,0 +1,37 @@
+import type { EmbeddingProvider, EmbeddingProviderName } from './types.js';
+interface EmbeddingProviderEnv extends NodeJS.ProcessEnv {
+    FF_LOCAL_RECALL_EMBEDDING_PROVIDER?: string;
+    FF_LOCAL_RECALL_OLLAMA_URL?: string;
+    FF_LOCAL_RECALL_OLLAMA_MODEL?: string;
+    FF_LOCAL_RECALL_OPENAI_URL?: string;
+    FF_LOCAL_RECALL_OPENAI_MODEL?: string;
+    OPENAI_API_KEY?: string;
+}
+export declare class OllamaEmbeddingProvider implements EmbeddingProvider {
+    readonly name: EmbeddingProviderName;
+    readonly model: string;
+    readonly baseURL: string;
+    dimensions?: number;
+    constructor(options?: {
+        model?: string;
+        baseURL?: string;
+    });
+    embed(input: string[]): Promise<number[][]>;
+    private embedBatch;
+    private embedLegacy;
+}
+export declare class OpenAIEmbeddingProvider implements EmbeddingProvider {
+    readonly name: EmbeddingProviderName;
+    readonly model: string;
+    readonly baseURL: string;
+    readonly apiKey: string;
+    dimensions?: number;
+    constructor(options: {
+        apiKey: string;
+        model?: string;
+        baseURL?: string;
+    });
+    embed(input: string[]): Promise<number[][]>;
+}
+export declare function createEmbeddingProvider(env?: EmbeddingProviderEnv): EmbeddingProvider;
+export {};

package/dist/local-recall/vector/embedding-provider.js

@@ -0,0 +1,184 @@
+const DEFAULT_OLLAMA_URL = 'http://127.0.0.1:11434';
+const DEFAULT_OLLAMA_MODEL = 'nomic-embed-text';
+const DEFAULT_OPENAI_URL = 'https://api.openai.com/v1';
+const DEFAULT_OPENAI_MODEL = 'text-embedding-3-small';
+function normalizeBaseURL(url) {
+    return url.endsWith('/') ? url.slice(0, -1) : url;
+}
+function toErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function assertEmbeddingShape(vectors) {
+    if (!Array.isArray(vectors)) {
+        throw new Error('Embedding response was not an array');
+    }
+    for (const vector of vectors) {
+        if (!Array.isArray(vector) || !vector.every((value) => typeof value === 'number')) {
+            throw new Error('Embedding response contained invalid vectors');
+        }
+    }
+    return vectors;
+}
+function validateDimensions(vectors, currentDimensions) {
+    const first = vectors[0];
+    if (!first) {
+        throw new Error('Embedding provider returned no vectors');
+    }
+    const nextDimensions = first.length;
+    if (nextDimensions === 0) {
+        throw new Error('Embedding provider returned empty vectors');
+    }
+    for (const vector of vectors) {
+        if (vector.length !== nextDimensions) {
+            throw new Error('Embedding provider returned mixed vector dimensions');
+        }
+    }
+    if (currentDimensions && currentDimensions !== nextDimensions) {
+        throw new Error(`Embedding dimensions changed from ${currentDimensions} to ${nextDimensions}`);
+    }
+    return nextDimensions;
+}
+async function parseError(response) {
+    try {
+        const text = await response.text();
+        if (!text) {
+            return `${response.status} ${response.statusText}`;
+        }
+        return `${response.status} ${response.statusText}: ${text}`;
+    }
+    catch {
+        return `${response.status} ${response.statusText}`;
+    }
+}
+export class OllamaEmbeddingProvider {
+    name = 'ollama';
+    model;
+    baseURL;
+    dimensions;
+    constructor(options) {
+        this.model = options?.model ?? DEFAULT_OLLAMA_MODEL;
+        this.baseURL = normalizeBaseURL(options?.baseURL ?? DEFAULT_OLLAMA_URL);
+    }
+    async embed(input) {
+        if (input.length === 0) {
+            return [];
+        }
+        let vectors = null;
+        let primaryError = null;
+        try {
+            vectors = await this.embedBatch(input);
+        }
+        catch (error) {
+            primaryError = toErrorMessage(error);
+        }
+        if (!vectors) {
+            try {
+                const legacyVectors = await Promise.all(input.map((value) => this.embedLegacy(value)));
+                vectors = legacyVectors;
+            }
+            catch (error) {
+                const fallbackError = toErrorMessage(error);
+                throw new Error(`Failed to fetch embeddings from Ollama. batch=${primaryError ?? 'n/a'} fallback=${fallbackError}`);
+            }
+        }
+        const dimensions = validateDimensions(vectors, this.dimensions);
+        this.dimensions = dimensions;
+        return vectors;
+    }
+    async embedBatch(input) {
+        const response = await fetch(`${this.baseURL}/api/embed`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: this.model,
+                input,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(await parseError(response));
+        }
+        const payload = (await response.json());
+        return assertEmbeddingShape(payload.embeddings);
+    }
+    async embedLegacy(input) {
+        const response = await fetch(`${this.baseURL}/api/embeddings`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                model: this.model,
+                prompt: input,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(await parseError(response));
+        }
+        const payload = (await response.json());
+        const [embedding] = assertEmbeddingShape([payload.embedding]);
+        return embedding;
+    }
+}
+export class OpenAIEmbeddingProvider {
+    name = 'openai';
+    model;
+    baseURL;
+    apiKey;
+    dimensions;
+    constructor(options) {
+        this.apiKey = options.apiKey;
+        this.model = options.model ?? DEFAULT_OPENAI_MODEL;
+        this.baseURL = normalizeBaseURL(options.baseURL ?? DEFAULT_OPENAI_URL);
+    }
+    async embed(input) {
+        if (input.length === 0) {
+            return [];
+        }
+        const response = await fetch(`${this.baseURL}/embeddings`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.apiKey}`,
+            },
+            body: JSON.stringify({
+                model: this.model,
+                input,
+            }),
+        });
+        if (!response.ok) {
+            throw new Error(await parseError(response));
+        }
+        const payload = (await response.json());
+        const embeddings = assertEmbeddingShape(payload.data?.map((entry) => entry.embedding) ?? []);
+        const dimensions = validateDimensions(embeddings, this.dimensions);
+        this.dimensions = dimensions;
+        return embeddings;
+    }
+}
+function getRequestedProvider(env) {
+    const value = (env.FF_LOCAL_RECALL_EMBEDDING_PROVIDER ?? 'ollama').trim().toLowerCase();
+    if (value === 'openai') {
+        return 'openai';
+    }
+    return 'ollama';
+}
+export function createEmbeddingProvider(env = process.env) {
+    const provider = getRequestedProvider(env);
+    if (provider === 'openai') {
+        const apiKey = env.OPENAI_API_KEY;
+        if (!apiKey) {
+            throw new Error('OPENAI_API_KEY is required when FF_LOCAL_RECALL_EMBEDDING_PROVIDER=openai');
+        }
+        return new OpenAIEmbeddingProvider({
+            apiKey,
+            model: env.FF_LOCAL_RECALL_OPENAI_MODEL,
+            baseURL: env.FF_LOCAL_RECALL_OPENAI_URL,
+        });
+    }
+    return new OllamaEmbeddingProvider({
+        model: env.FF_LOCAL_RECALL_OLLAMA_MODEL,
+        baseURL: env.FF_LOCAL_RECALL_OLLAMA_URL,
+    });
+}

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

@@ -0,0 +1,37 @@
+import type { Memory, MemorySearchResult, SearchCriteria } from '../types.js';
+import type { EmbeddingProvider } from './types.js';
+export declare class OramaMemoryIndex {
+    private readonly directory;
+    private readonly provider;
+    private db;
+    private readonly documents;
+    private dimensions;
+    private updatedAt;
+    constructor(directory: string, provider: EmbeddingProvider);
+    initialize(): Promise<void>;
+    getStatus(): {
+        documents: number;
+        dimensions: number | null;
+        provider: string;
+        model: string;
+        updatedAt: string | null;
+    };
+    search(criteria: SearchCriteria): Promise<MemorySearchResult[]>;
+    upsertMemories(memories: Memory[]): Promise<number>;
+    removeMemories(memoryIDs: string[]): Promise<number>;
+    rebuild(memories: Memory[]): Promise<number>;
+    private get indexDir();
+    private get manifestPath();
+    private get documentsPath();
+    private buildSchema;
+    private ensureDB;
+    private rebuildDatabaseFromDocuments;
+    private hydrateDB;
+    private loadSnapshot;
+    private persistSnapshot;
+    private writeAtomic;
+    private memoryToEmbeddingInput;
+    private toDocument;
+    private assertEmbeddingDimensions;
+    private embedBatch;
+}