@syntesseraai/opencode-feature-factory 0.3.1 → 0.3.3

package/README.md

@@ -45,7 +45,7 @@ The plugin now includes a local MCP daemon binary: `ff-local-recall-mcp`.
 
 ### Environment Variables
 
-- `FF_LOCAL_RECALL_DIRECTORY` - Directory that contains `.feature-factory/` (default: current working directory)
+- `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)

package/bin/ff-deploy.js

@@ -31,7 +31,13 @@ const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
 const DEFAULT_MCP_SERVERS = {
   'ff-local-recall': {
     type: 'local',
-    command: 'ff-local-recall-mcp',
+    command: [
+      'npx',
+      '-y',
+      '--package=@syntesseraai/opencode-feature-factory@latest',
+      '--',
+      'ff-local-recall-mcp',
+    ],
     enabled: true,
   },
   'jina-ai': {

package/dist/index.js

@@ -38,10 +38,10 @@ export const FeatureFactoryPlugin = async (input) => {
     }
     // 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
+    // Update MCP server configuration in global OpenCode config
+    // This ensures Feature Factory MCP servers are available across projects
     try {
-        await updateMCPConfig($, directory);
+        await updateMCPConfig($);
     }
     catch (error) {
         // Silently fail - don't block plugin initialization if MCP config update fails

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,42 @@
  *   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';
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function recordFailure(stats, failure) {
+    let message;
+    let rawError;
+    switch (failure.scope) {
+        case 'project':
+            message = `No OpenCode project found for directory: ${failure.directory}`;
+            break;
+        case 'message':
+            message = `Error processing message ${failure.messageID}: ${getErrorMessage(failure.error)}`;
+            rawError = failure.error;
+            break;
+        case 'session':
+            message = `Error processing session ${failure.sessionID}: ${getErrorMessage(failure.error)}`;
+            rawError = failure.error;
+            break;
+        case 'extraction':
+            message = `Extraction failed: ${getErrorMessage(failure.error)}`;
+            rawError = failure.error;
+            break;
+    }
+    stats.errors.push(message);
+    if (rawError !== undefined) {
+        console.error('[local-recall-daemon]', message, rawError);
+        return;
+    }
+    console.error('[local-recall-daemon]', message);
+}
 // ────────────────────────────────────────────────────────────
 // Helpers
 // ────────────────────────────────────────────────────────────
@@ -33,7 +62,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 +81,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)
@@ -70,12 +99,11 @@ export async function runExtraction(directory) {
         // Find project for this directory
         const project = await findProject(directory);
         if (!project) {
-            stats.errors.push(`No OpenCode project found for directory: ${directory}`);
+            recordFailure(stats, { scope: 'project', 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 +118,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;
                     }
@@ -149,6 +177,7 @@ export async function runExtraction(directory) {
                         processedHashes.add(msgHash);
                         // Mark as processed with content hash
                         newProcessedEntries.push({
+                            status: 'success',
                             messageID: message.id,
                             contentHash: msgHash,
                             processedAt: Date.now(),
@@ -156,19 +185,29 @@ export async function runExtraction(directory) {
                         });
                     }
                     catch (err) {
-                        stats.errors.push(`Error processing message ${message.id}: ${err instanceof Error ? err.message : String(err)}`);
+                        recordFailure(stats, {
+                            scope: 'message',
+                            messageID: message.id,
+                            error: err,
+                        });
                         // Still mark as processed to avoid re-trying broken messages
                         newProcessedEntries.push({
+                            status: 'failed',
                             messageID: message.id,
                             contentHash: msgHash,
                             processedAt: Date.now(),
                             memoriesCreated: 0,
+                            failure: getErrorMessage(err),
                         });
                     }
                 }
             }
             catch (err) {
-                stats.errors.push(`Error processing session ${session.id}: ${err instanceof Error ? err.message : String(err)}`);
+                recordFailure(stats, {
+                    scope: 'session',
+                    sessionID: session.id,
+                    error: err,
+                });
             }
         }
         // Batch store all new memories
@@ -182,7 +221,7 @@ export async function runExtraction(directory) {
         }
     }
     catch (err) {
-        stats.errors.push(`Extraction failed: ${err instanceof Error ? err.message : String(err)}`);
+        recordFailure(stats, { scope: 'extraction', error: err });
     }
     return stats;
 }

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

@@ -7,7 +7,7 @@ const EMPTY_STATE = {
     updatedAt: 0,
 };
 function getIndexDir(directory) {
-    return path.join(directory, '.feature-factory', 'local-recall', 'index');
+    return path.join(directory, 'ff-memories', 'index');
 }
 export function getIndexStatePath(directory) {
     return path.join(getIndexDir(directory), 'state.json');

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

@@ -44,9 +44,13 @@ function createRuntime(directory) {
         extractionEnabled: parseBoolean(process.env.FF_LOCAL_RECALL_EXTRACTION_ENABLED, true),
     });
     return index.initialize().then(() => {
-        if (parseBoolean(process.env.FF_LOCAL_RECALL_DAEMON_AUTOSTART, true)) {
+        const autoStart = parseBoolean(process.env.FF_LOCAL_RECALL_DAEMON_AUTOSTART, true);
+        if (autoStart) {
             daemon.start();
         }
+        else {
+            daemon.requestRun('startup');
+        }
         return {
             directory,
             index,

package/dist/local-recall/memory-service.d.ts

@@ -2,9 +2,10 @@
  * Memory Service
  *
  * MCP-backed memory domain service that stores and retrieves
- * extracted memories as JSON files in .feature-factory/local-recall/memories/
+ * extracted memories as JSON files in ff-memories/memories/
  */
 import type { Memory, SearchCriteria, MemorySearchResult } from './types.js';
+export declare function getMemoriesDir(directory: string): string;
 /**
  * Persist a memory to disk.
  */

package/dist/local-recall/memory-service.js

@@ -2,15 +2,15 @@
  * Memory Service
  *
  * MCP-backed memory domain service that stores and retrieves
- * extracted memories as JSON files in .feature-factory/local-recall/memories/
+ * extracted memories as JSON files in ff-memories/memories/
  */
 import { readFile, writeFile, readdir, mkdir } from 'fs/promises';
 import path from 'path';
 const { join, resolve } = path;
 /** Only allow IDs that are safe for filenames: alphanumeric, hyphens, underscores. */
 const SAFE_ID_PATTERN = /^[A-Za-z0-9_-]+$/;
-function getMemoriesDir(directory) {
-    return join(directory, '.feature-factory', 'local-recall', 'memories');
+export function getMemoriesDir(directory) {
+    return join(directory, 'ff-memories', 'memories');
 }
 /**
  * Validate a memory ID and resolve its file path with containment check.

package/dist/local-recall/processed-log.d.ts

@@ -6,7 +6,7 @@
  * hash derived from the message content so re-extractions with identical
  * content are skipped even if message IDs change.
  *
- * Stored as a JSON file at .feature-factory/local-recall/processed.json
+ * Stored as a JSON file at ff-memories/processed.json
  */
 import type { ProcessedEntry } from './types.js';
 /**

package/dist/local-recall/processed-log.js

@@ -6,13 +6,13 @@
  * hash derived from the message content so re-extractions with identical
  * content are skipped even if message IDs change.
  *
- * Stored as a JSON file at .feature-factory/local-recall/processed.json
+ * Stored as a JSON file at ff-memories/processed.json
  */
 import { createHash } from 'node:crypto';
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
 function getLogPath(directory) {
-    return join(directory, '.feature-factory', 'local-recall', 'processed.json');
+    return join(directory, 'ff-memories', 'processed.json');
 }
 // ────────────────────────────────────────────────────────────
 // Content hashing

package/dist/local-recall/thinking-extractor.d.ts

@@ -2,12 +2,12 @@
  * thinking-extractor.ts — Extracts learnings from "thinking" / reasoning blocks.
  *
  * OpenCode stores extended-thinking or chain-of-thought content in parts
- * with type "reasoning". These often contain high-signal insights about
+ * with type "reasoning" or "thinking". These often contain high-signal insights about
  * decision making and problem solving that are worth capturing.
  */
 import type { ExtractionInput, ExtractionResult, OCPart } from './types.js';
 /**
- * Extract learnings specifically from reasoning / thinking parts.
+ * Extract learnings specifically from reasoning/thinking parts.
  */
 export declare function extractFromThinkingParts(input: ExtractionInput, parts: OCPart[]): ExtractionResult[];
 /**

package/dist/local-recall/thinking-extractor.js

@@ -2,7 +2,7 @@
  * thinking-extractor.ts — Extracts learnings from "thinking" / reasoning blocks.
  *
  * OpenCode stores extended-thinking or chain-of-thought content in parts
- * with type "reasoning". These often contain high-signal insights about
+ * with type "reasoning" or "thinking". These often contain high-signal insights about
  * decision making and problem solving that are worth capturing.
  */
 import { listParts } from './storage-reader.js';
@@ -97,13 +97,13 @@ function deriveThinkingTitle(text) {
 // Public API
 // ────────────────────────────────────────────────────────────
 /**
- * Extract learnings specifically from reasoning / thinking parts.
+ * Extract learnings specifically from reasoning/thinking parts.
  */
 export function extractFromThinkingParts(input, parts) {
     const results = [];
     for (const part of parts) {
-        // Accept "reasoning" type parts (extended thinking)
-        if (part.type !== 'reasoning' || !part.text)
+        // Accept reasoning/thinking type parts (extended thinking)
+        if ((part.type !== 'reasoning' && part.type !== 'thinking') || !part.text)
             continue;
         if (part.text.length < MIN_THINKING_LENGTH)
             continue;

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

@@ -32,7 +32,7 @@ export interface OCSession {
 export interface OCMessage {
     id: string;
     sessionID: string;
-    role: 'user' | 'assistant';
+    role: 'user' | 'assistant' | 'thinking';
     time: {
         created: number;
     };
@@ -119,11 +119,24 @@ export interface ExtractionResult {
     /** Where the extraction came from — used to generate logical IDs */
     source: 'session' | 'thinking';
 }
-/** Tracks which messages have already been processed */
-export interface ProcessedEntry {
+interface ProcessedEntryBase {
     messageID: string;
     processedAt: number;
-    memoriesCreated: number;
     /** SHA-256 hex hash of the concatenated extracted bodies for content-level idempotency */
     contentHash: string;
 }
+/** Tracks which messages have already been processed */
+export type ProcessedEntry = (ProcessedEntryBase & {
+    status: 'success';
+    memoriesCreated: number;
+    failure?: undefined;
+}) | (ProcessedEntryBase & {
+    status: 'failed';
+    memoriesCreated: 0;
+    failure: string;
+}) | (ProcessedEntryBase & {
+    status?: undefined;
+    memoriesCreated: number;
+    failure?: undefined;
+});
+export {};

package/dist/local-recall/vector/orama-index.js

@@ -213,7 +213,7 @@ export class OramaMemoryIndex {
         return memories.length;
     }
     get indexDir() {
-        return path.join(this.directory, '.feature-factory', 'local-recall', 'index');
+        return path.join(this.directory, 'ff-memories', 'index');
     }
     get manifestPath() {
         return path.join(this.indexDir, 'manifest.json');

package/dist/mcp-config.d.ts

@@ -1,7 +1,7 @@
 type BunShell = any;
 /**
  * Default MCP server configuration to be added by the plugin
- * These servers will be merged into the project's opencode.json
+ * These servers will be merged into the global OpenCode config.
  */
 export declare const DEFAULT_MCP_SERVERS: {
     readonly 'ff-local-recall': {
@@ -44,20 +44,15 @@ export interface MCPServers {
  */
 export declare function mergeMCPServers(existing: MCPServers | undefined, defaults: typeof DEFAULT_MCP_SERVERS): MCPServers;
 /**
- * Update the MCP servers configuration in opencode.json files.
+ * Update the MCP servers configuration in global opencode.json.
  *
  * This function:
- * 1. Reads existing config from both root and .opencode directories
- * 2. Merges MCP servers from both configs (preserving all existing servers)
+ * 1. Reads existing config from ~/.config/opencode/opencode.json
+ * 2. Preserves existing MCP servers
  * 3. Adds default Feature Factory MCP servers that don't exist
- * 4. Writes updated config to .opencode/opencode.json
- *
- * Note: Writing to .opencode/opencode.json keeps Feature Factory MCP config
- * separate from the user's root opencode.json, following the same pattern
- * as the quality gate configuration.
+ * 4. Writes updated config back to ~/.config/opencode/opencode.json
  *
  * @param $ - Bun shell instance
- * @param directory - The project directory
  */
-export declare function updateMCPConfig($: BunShell, directory: string): Promise<void>;
+export declare function updateMCPConfig($: BunShell): Promise<void>;
 export {};

package/dist/mcp-config.js

@@ -1,7 +1,11 @@
 import { readJsonFile } from './quality-gate-config.js';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const GLOBAL_OPENCODE_DIR = join(homedir(), '.config', 'opencode');
+const GLOBAL_OPENCODE_CONFIG_PATH = join(GLOBAL_OPENCODE_DIR, 'opencode.json');
 /**
  * Default MCP server configuration to be added by the plugin
- * These servers will be merged into the project's opencode.json
+ * These servers will be merged into the global OpenCode config.
  */
 export const DEFAULT_MCP_SERVERS = {
     'ff-local-recall': {
@@ -44,38 +48,21 @@ export function mergeMCPServers(existing, defaults) {
     return result;
 }
 /**
- * Update the MCP servers configuration in opencode.json files.
+ * Update the MCP servers configuration in global opencode.json.
  *
  * This function:
- * 1. Reads existing config from both root and .opencode directories
- * 2. Merges MCP servers from both configs (preserving all existing servers)
+ * 1. Reads existing config from ~/.config/opencode/opencode.json
+ * 2. Preserves existing MCP servers
  * 3. Adds default Feature Factory MCP servers that don't exist
- * 4. Writes updated config to .opencode/opencode.json
- *
- * Note: Writing to .opencode/opencode.json keeps Feature Factory MCP config
- * separate from the user's root opencode.json, following the same pattern
- * as the quality gate configuration.
+ * 4. Writes updated config back to ~/.config/opencode/opencode.json
  *
  * @param $ - Bun shell instance
- * @param directory - The project directory
  */
-export async function updateMCPConfig($, directory) {
-    const rootConfigPath = `${directory}/opencode.json`;
-    const dotOpencodeConfigPath = `${directory}/.opencode/opencode.json`;
-    const dotOpencodeDir = `${directory}/.opencode`;
-    // Read existing configs
-    const [rootJson, dotOpencodeJson] = await Promise.all([
-        readJsonFile($, rootConfigPath),
-        readJsonFile($, dotOpencodeConfigPath),
-    ]);
-    // Get existing MCP servers from both configs
-    const rootMcpServers = (rootJson?.mcp ?? {});
-    const dotOpencodeMcpServers = (dotOpencodeJson?.mcp ?? {});
-    // Merge existing servers (dotOpencode overrides root)
-    const existingMcpServers = {
-        ...rootMcpServers,
-        ...dotOpencodeMcpServers,
-    };
+export async function updateMCPConfig($) {
+    // Read existing global config
+    const globalJson = await readJsonFile($, GLOBAL_OPENCODE_CONFIG_PATH);
+    // Get existing MCP servers from global config
+    const existingMcpServers = (globalJson?.mcp ?? {});
     // Merge with default MCP servers
     const updatedMcpServers = mergeMCPServers(existingMcpServers, DEFAULT_MCP_SERVERS);
     // Check if any changes are needed
@@ -84,24 +71,24 @@ export async function updateMCPConfig($, directory) {
         // All default servers already exist, no need to update
         return;
     }
-    // Prepare updated config for .opencode/opencode.json
-    const updatedDotOpencodeConfig = {
-        ...(dotOpencodeJson ?? {}),
+    // Prepare updated global config
+    const updatedGlobalConfig = {
+        ...(globalJson ?? {}),
         mcp: updatedMcpServers,
     };
-    // Ensure .opencode directory exists
+    // Ensure global config directory exists
     try {
-        await $ `mkdir -p ${dotOpencodeDir}`.quiet();
+        await $ `mkdir -p ${GLOBAL_OPENCODE_DIR}`.quiet();
     }
     catch {
         // Directory might already exist, ignore
     }
-    // Backup existing .opencode/opencode.json if it exists and has content
-    if (dotOpencodeJson && Object.keys(dotOpencodeJson).length > 0) {
+    // Backup existing global config if it exists and has content
+    if (globalJson && Object.keys(globalJson).length > 0) {
         try {
             const timestamp = new Date().toISOString().split('T')[0].replace(/-/g, '');
-            const backupPath = `${dotOpencodeConfigPath}.backup.${timestamp}`;
-            const backupContent = JSON.stringify(dotOpencodeJson, null, 2);
+            const backupPath = `${GLOBAL_OPENCODE_CONFIG_PATH}.backup.${timestamp}`;
+            const backupContent = JSON.stringify(globalJson, null, 2);
             await $ `echo ${backupContent} > ${backupPath}`.quiet();
         }
         catch (error) {
@@ -109,10 +96,10 @@ export async function updateMCPConfig($, directory) {
             console.warn('[feature-factory] Could not create backup:', error);
         }
     }
-    // Write updated config to .opencode/opencode.json
-    const configContent = JSON.stringify(updatedDotOpencodeConfig, null, 2);
+    // Write updated config to global opencode.json
+    const configContent = JSON.stringify(updatedGlobalConfig, null, 2);
     try {
-        await $ `echo ${configContent} > ${dotOpencodeConfigPath}`.quiet();
+        await $ `echo ${configContent} > ${GLOBAL_OPENCODE_CONFIG_PATH}`.quiet();
     }
     catch (error) {
         // Silently fail - don't block if we can't write the config

package/package.json

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

package/skills/ff-learning/SKILL.md

@@ -10,7 +10,7 @@ metadata:
 
 # Learning Skill (Local-Recall)
 
-Use this skill to capture insights, store knowledge, and retrieve past learnings to improve future work. Memories are stored as JSON in `.feature-factory/local-recall/memories/` and automatically extracted from OpenCode session history.
+Use this skill to capture insights, store knowledge, and retrieve past learnings to improve future work. Memories are stored as JSON in `ff-memories/memories/` and automatically extracted from OpenCode session history.
 
 ## How It Works
 
@@ -168,7 +168,7 @@ Search learnings:
 ### Directory Structure
 
 ```
-.feature-factory/local-recall/
+ff-memories/
 ├── memories/           # All memory JSON files
 │   ├── {uuid}.json     # Individual memory files
 │   └── ...