@syntesseraai/opencode-feature-factory 0.3.3 → 0.3.5

package/dist/local-recall/daemon.js

@@ -23,32 +23,51 @@ import { getMemoriesDir, storeMemories } from './memory-service.js';
 function getErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+function toProcessedFailureEntry(failure, failureMessage) {
+    switch (failure.scope) {
+        case 'project':
+            return {
+                kind: 'failure',
+                scope: 'project',
+                processedAt: Date.now(),
+                failure: failureMessage,
+                directory: failure.directory,
+            };
+        case 'session':
+            return {
+                kind: 'failure',
+                scope: 'session',
+                processedAt: Date.now(),
+                failure: failureMessage,
+                sessionID: failure.sessionID,
+            };
+        case 'extraction':
+            return {
+                kind: 'failure',
+                scope: 'extraction',
+                processedAt: Date.now(),
+                failure: failureMessage,
+            };
+    }
+}
 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);
+    return message;
 }
 // ────────────────────────────────────────────────────────────
 // Helpers
@@ -99,7 +118,14 @@ export async function runExtraction(directory) {
         // Find project for this directory
         const project = await findProject(directory);
         if (!project) {
-            recordFailure(stats, { scope: 'project', directory });
+            const failure = { scope: 'project', directory };
+            const failureMessage = recordFailure(stats, failure);
+            try {
+                await markProcessed(directory, [toProcessedFailureEntry(failure, failureMessage)]);
+            }
+            catch (persistErr) {
+                stats.errors.push(`Failed to persist processing failure: ${getErrorMessage(persistErr)}`);
+            }
             return stats;
         }
         // Ensure local-recall directories exist
@@ -203,11 +229,13 @@ export async function runExtraction(directory) {
                 }
             }
             catch (err) {
-                recordFailure(stats, {
+                const failure = {
                     scope: 'session',
                     sessionID: session.id,
                     error: err,
-                });
+                };
+                const failureMessage = recordFailure(stats, failure);
+                newProcessedEntries.push(toProcessedFailureEntry(failure, failureMessage));
             }
         }
         // Batch store all new memories
@@ -221,7 +249,14 @@ export async function runExtraction(directory) {
         }
     }
     catch (err) {
-        recordFailure(stats, { scope: 'extraction', error: err });
+        const failure = { scope: 'extraction', error: err };
+        const failureMessage = recordFailure(stats, failure);
+        try {
+            await markProcessed(directory, [toProcessedFailureEntry(failure, failureMessage)]);
+        }
+        catch (persistErr) {
+            stats.errors.push(`Failed to persist processing failure: ${getErrorMessage(persistErr)}`);
+        }
     }
     return stats;
 }

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

@@ -11,6 +11,9 @@
 import { createHash } from 'node:crypto';
 import { readFile, writeFile, mkdir } from 'node:fs/promises';
 import { join, dirname } from 'node:path';
+function isProcessedMessageEntry(entry) {
+    return 'messageID' in entry && 'contentHash' in entry;
+}
 function getLogPath(directory) {
     return join(directory, 'ff-memories', 'processed.json');
 }
@@ -48,7 +51,7 @@ export async function readProcessedLog(directory) {
  */
 export async function isProcessed(directory, messageID) {
     const log = await readProcessedLog(directory);
-    return log.some((entry) => entry.messageID === messageID);
+    return log.some((entry) => isProcessedMessageEntry(entry) && entry.messageID === messageID);
 }
 /**
  * Check if a content hash has already been processed.
@@ -56,7 +59,7 @@ export async function isProcessed(directory, messageID) {
  */
 export async function isContentProcessed(directory, hash) {
     const log = await readProcessedLog(directory);
-    return log.some((entry) => entry.contentHash === hash);
+    return log.some((entry) => isProcessedMessageEntry(entry) && entry.contentHash === hash);
 }
 /**
  * Mark messages as processed by appending entries to the log.
@@ -72,11 +75,11 @@ export async function markProcessed(directory, entries) {
  * Get the set of already-processed message IDs for fast lookup.
  */
 export function getProcessedMessageIDs(log) {
-    return new Set(log.map((e) => e.messageID));
+    return new Set(log.filter(isProcessedMessageEntry).map((e) => e.messageID));
 }
 /**
  * Get the set of already-processed content hashes for fast lookup.
  */
 export function getProcessedHashes(log) {
-    return new Set(log.map((e) => e.contentHash));
+    return new Set(log.filter(isProcessedMessageEntry).map((e) => e.contentHash));
 }

package/dist/local-recall/storage-reader.js

@@ -45,6 +45,10 @@ async function dirExists(dirPath) {
         return false;
     }
 }
+function getPartStartTime(part) {
+    const start = part.time?.start;
+    return typeof start === 'number' ? start : Number.POSITIVE_INFINITY;
+}
 // ── Project Reader ──────────────────────────────────────────────
 /**
  * Find the project record whose worktree matches `directory`.
@@ -131,7 +135,13 @@ export async function listParts(messageID) {
     if (!(await dirExists(partDir)))
         return [];
     const parts = await readAllJsonInDir(partDir);
-    return parts.sort((a, b) => a.time.start - b.time.start);
+    return parts.sort((a, b) => {
+        const timeDelta = getPartStartTime(a) - getPartStartTime(b);
+        if (timeDelta !== 0) {
+            return timeDelta;
+        }
+        return a.id.localeCompare(b.id);
+    });
 }
 /**
  * Get a single part by ID.

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

@@ -54,10 +54,10 @@ export interface OCPart {
     messageID: string;
     type: string;
     text?: string;
-    synthetic: boolean;
-    time: {
-        start: number;
-        end: number;
+    synthetic?: boolean;
+    time?: {
+        start?: number;
+        end?: number;
     };
 }
 /** A memory extracted from a conversation turn */
@@ -119,24 +119,34 @@ export interface ExtractionResult {
     /** Where the extraction came from — used to generate logical IDs */
     source: 'session' | 'thinking';
 }
-interface ProcessedEntryBase {
+interface ProcessedMessageEntryBase {
     messageID: string;
     processedAt: 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 & {
+export type ProcessedMessageEntry = (ProcessedMessageEntryBase & {
     status: 'success';
     memoriesCreated: number;
     failure?: undefined;
-}) | (ProcessedEntryBase & {
+}) | (ProcessedMessageEntryBase & {
     status: 'failed';
     memoriesCreated: 0;
     failure: string;
-}) | (ProcessedEntryBase & {
+}) | (ProcessedMessageEntryBase & {
     status?: undefined;
     memoriesCreated: number;
     failure?: undefined;
 });
+/** Persistent daemon-level failures that are not tied to a specific message record. */
+export type ProcessedFailureEntry = {
+    kind: 'failure';
+    scope: 'project' | 'session' | 'extraction';
+    processedAt: number;
+    failure: string;
+    directory?: string;
+    sessionID?: string;
+};
+export type ProcessedEntry = ProcessedMessageEntry | ProcessedFailureEntry;
 export {};

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

@@ -5,6 +5,7 @@ export declare class OramaMemoryIndex {
     private readonly provider;
     private db;
     private readonly documents;
+    private readonly embedMaxChars;
     private dimensions;
     private updatedAt;
     constructor(directory: string, provider: EmbeddingProvider);
@@ -31,6 +32,7 @@ export declare class OramaMemoryIndex {
     private persistSnapshot;
     private writeAtomic;
     private memoryToEmbeddingInput;
+    private prepareEmbeddingInput;
     private toDocument;
     private assertEmbeddingDimensions;
     private embedBatch;

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

@@ -3,9 +3,23 @@ import { mkdir, readFile, rename, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 const INDEX_VERSION = 1;
 const EMBED_BATCH_SIZE = 16;
+const DEFAULT_EMBED_MAX_CHARS = 6000;
+const MIN_EMBED_MAX_CHARS = 256;
+const MAX_EMBED_MAX_CHARS = 200_000;
+const TRUNCATION_MARKER = '\n\n...[truncated]...\n\n';
 function clamp(value, min, max) {
     return Math.min(Math.max(value, min), max);
 }
+function resolveEmbedMaxChars(rawValue) {
+    if (!rawValue) {
+        return DEFAULT_EMBED_MAX_CHARS;
+    }
+    const parsedValue = Number.parseInt(rawValue, 10);
+    if (!Number.isFinite(parsedValue)) {
+        return DEFAULT_EMBED_MAX_CHARS;
+    }
+    return clamp(parsedValue, MIN_EMBED_MAX_CHARS, MAX_EMBED_MAX_CHARS);
+}
 function isVector(value) {
     return Array.isArray(value) && value.every((entry) => typeof entry === 'number');
 }
@@ -77,6 +91,7 @@ export class OramaMemoryIndex {
     provider;
     db = null;
     documents = new Map();
+    embedMaxChars = resolveEmbedMaxChars(process.env.FF_LOCAL_RECALL_EMBED_MAX_CHARS);
     dimensions = null;
     updatedAt = null;
     constructor(directory, provider) {
@@ -114,7 +129,7 @@ export class OramaMemoryIndex {
                 .map((document) => toSearchResult(document, 0));
             return filtered;
         }
-        const [queryEmbedding] = await this.provider.embed([query]);
+        const [queryEmbedding] = await this.provider.embed([this.prepareEmbeddingInput(query)]);
         if (!queryEmbedding) {
             return [];
         }
@@ -332,7 +347,21 @@ export class OramaMemoryIndex {
         await rename(tmpPath, filePath);
     }
     memoryToEmbeddingInput(memory) {
-        return `${memory.title}\n\n${memory.body}`.trim();
+        return this.prepareEmbeddingInput(`${memory.title}\n\n${memory.body}`);
+    }
+    prepareEmbeddingInput(input) {
+        const normalized = input.trim();
+        if (normalized.length <= this.embedMaxChars) {
+            return normalized;
+        }
+        const availableContent = this.embedMaxChars - TRUNCATION_MARKER.length;
+        if (availableContent <= 1) {
+            return normalized.slice(0, this.embedMaxChars);
+        }
+        const headLength = Math.ceil(availableContent * 0.8);
+        const tailLength = availableContent - headLength;
+        const suffix = tailLength > 0 ? normalized.slice(-tailLength) : '';
+        return `${normalized.slice(0, headLength)}${TRUNCATION_MARKER}${suffix}`;
     }
     toDocument(memory, embedding) {
         return {

package/package.json

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