@syntesseraai/opencode-feature-factory 0.3.2 → 0.3.4

package/dist/local-recall/daemon.js

@@ -20,6 +20,55 @@ import { extractFromMessage } from './session-extractor.js';
 import { extractThinkingFromMessage } from './thinking-extractor.js';
 import { readProcessedLog, getProcessedMessageIDs, getProcessedHashes, markProcessed, contentHash, } from './processed-log.js';
 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;
+    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)}`;
+            break;
+        case 'session':
+            message = `Error processing session ${failure.sessionID}: ${getErrorMessage(failure.error)}`;
+            break;
+        case 'extraction':
+            message = `Extraction failed: ${getErrorMessage(failure.error)}`;
+            break;
+    }
+    stats.errors.push(message);
+    return message;
+}
 // ────────────────────────────────────────────────────────────
 // Helpers
 // ────────────────────────────────────────────────────────────
@@ -69,7 +118,14 @@ 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}`);
+            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
@@ -147,6 +203,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(),
@@ -154,19 +211,31 @@ 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)}`);
+                const failure = {
+                    scope: 'session',
+                    sessionID: session.id,
+                    error: err,
+                };
+                const failureMessage = recordFailure(stats, failure);
+                newProcessedEntries.push(toProcessedFailureEntry(failure, failureMessage));
             }
         }
         // Batch store all new memories
@@ -180,7 +249,14 @@ export async function runExtraction(directory) {
         }
     }
     catch (err) {
-        stats.errors.push(`Extraction failed: ${err instanceof Error ? err.message : String(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,11 +119,34 @@ 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 ProcessedMessageEntryBase {
     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 ProcessedMessageEntry = (ProcessedMessageEntryBase & {
+    status: 'success';
+    memoriesCreated: number;
+    failure?: undefined;
+}) | (ProcessedMessageEntryBase & {
+    status: 'failed';
+    memoriesCreated: 0;
+    failure: string;
+}) | (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/package.json

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