sinapse-ai 1.6.1 → 1.8.0

package/.sinapse-ai/core/execution/build-state-manager.js

@@ -23,6 +23,11 @@
 const fs = require('fs');
 const path = require('path');
 const crypto = require('crypto');
+const {
+  normalizeError,
+  sanitizeValue: sanitizeErrorValue,
+  serializeError,
+} = require('../errors');
 
 // Optional dependencies with graceful fallback
 let chalk;
@@ -87,6 +92,66 @@ const NotificationType = {
   ABANDONED: 'abandoned',
 };
 
+/**
+ * Converts arbitrary values into stable, JSON-safe log data.
+ *
+ * @param {*} value - Value to sanitize.
+ * @param {WeakSet<object>} [seen=new WeakSet()] - Objects in the current path.
+ * @returns {*} Data-only representation that JSON.stringify can serialize.
+ */
+function sanitizeLogValue(value, seen = new WeakSet()) {
+  return sanitizeErrorValue(value, seen, {
+    includeStack: shouldExposeLogErrorStack(),
+  });
+}
+
+/**
+ * Checks whether persisted attempt logs may include raw error stack traces.
+ *
+ * @returns {boolean} True when stack trace logging is explicitly enabled.
+ */
+function shouldExposeLogErrorStack() {
+  const stackFlag = process.env.DEBUG_ERROR_STACKS || process.env.DEBUG_STACKS || '';
+  return ['1', 'true', 'yes', 'on'].includes(String(stackFlag).toLowerCase());
+}
+
+/**
+ * Stringifies attempt log details without allowing log formatting to throw.
+ *
+ * @param {*} value - Value to stringify.
+ * @returns {string} JSON string or a fallback marker.
+ */
+function stringifyLogDetails(value) {
+  try {
+    return JSON.stringify(sanitizeLogValue(value));
+  } catch (error) {
+    return JSON.stringify(`[Unserializable: ${error.message}]`);
+  }
+}
+
+/**
+ * Normalize a failed build attempt into legacy message plus canonical details.
+ *
+ * @param {*} error - Raw failure error/value.
+ * @param {object} context - Build/subtask context for metadata.
+ * @returns {{ message: string, details: object }} Normalized failure payload.
+ */
+function normalizeFailureError(error, context = {}) {
+  const normalized = normalizeError(error || 'Unknown error', {
+    code: 'SNPS_EXECUTION_FAILED',
+    metadata: {
+      buildState: context,
+    },
+  });
+
+  return {
+    message: normalized.message,
+    details: serializeError(normalized, {
+      includeStack: shouldExposeLogErrorStack(),
+    }),
+  };
+}
+
 // ═══════════════════════════════════════════════════════════════════════════════════
 //                              SCHEMA VALIDATION
 // ═══════════════════════════════════════════════════════════════════════════════════
@@ -185,6 +250,8 @@ class BuildStateManager {
     // Internal state
     this._state = null;
     this._logBuffer = [];
+    this._persistenceAvailable = true;
+    this._persistenceError = null;
   }
 
   // ─────────────────────────────────────────────────────────────────────────────────
@@ -244,14 +311,24 @@ class BuildStateManager {
    * @returns {Object|null} Loaded state or null if not exists
    */
   loadState() {
+    if (!this._persistenceAvailable) {
+      return this._state;
+    }
+
     if (!fs.existsSync(this.stateFilePath)) {
       return null;
     }
 
+    let content;
     try {
-      const content = fs.readFileSync(this.stateFilePath, 'utf-8');
-      const state = JSON.parse(content);
+      content = fs.readFileSync(this.stateFilePath, 'utf-8');
+    } catch (error) {
+      this._markPersistenceUnavailable(error);
+      return this._state;
+    }
 
+    try {
+      const state = JSON.parse(content);
       // Validate
       const validation = validateBuildState(state);
       if (!validation.valid) {
@@ -277,11 +354,6 @@ class BuildStateManager {
       throw new Error('No state to save. Call createState() or loadState() first.');
     }
 
-    // Ensure directory exists
-    if (!fs.existsSync(this.planDir)) {
-      fs.mkdirSync(this.planDir, { recursive: true });
-    }
-
     // Only update timestamp if explicitly requested (via saveCheckpoint)
     if (options.updateCheckpoint) {
       this._state.lastCheckpoint = new Date().toISOString();
@@ -293,11 +365,24 @@ class BuildStateManager {
       throw new Error(`Invalid state: ${validation.errors.join(', ')}`);
     }
 
-    // Write state file
-    fs.writeFileSync(this.stateFilePath, JSON.stringify(this._state, null, 2), 'utf-8');
+    if (!this._persistenceAvailable) {
+      return this._state;
+    }
+
+    try {
+      // Ensure directory exists
+      if (!fs.existsSync(this.planDir)) {
+        fs.mkdirSync(this.planDir, { recursive: true });
+      }
+
+      // Write state file
+      fs.writeFileSync(this.stateFilePath, JSON.stringify(this._state, null, 2), 'utf-8');
 
-    // Flush log buffer
-    this._flushLogBuffer();
+      // Flush log buffer
+      this._flushLogBuffer();
+    } catch (error) {
+      this._markPersistenceUnavailable(error);
+    }
 
     return this._state;
   }
@@ -341,11 +426,6 @@ class BuildStateManager {
       throw new Error('No state loaded');
     }
 
-    // Ensure checkpoint directory exists
-    if (!fs.existsSync(this.checkpointDir)) {
-      fs.mkdirSync(this.checkpointDir, { recursive: true });
-    }
-
     const checkpointId = this._generateCheckpointId();
     const now = new Date().toISOString();
 
@@ -376,8 +456,19 @@ class BuildStateManager {
     this._updateMetrics(checkpoint);
 
     // Save checkpoint file
-    const checkpointPath = path.join(this.checkpointDir, `${checkpointId}.json`);
-    fs.writeFileSync(checkpointPath, JSON.stringify(checkpoint, null, 2), 'utf-8');
+    if (this._persistenceAvailable) {
+      try {
+        // Ensure checkpoint directory exists
+        if (!fs.existsSync(this.checkpointDir)) {
+          fs.mkdirSync(this.checkpointDir, { recursive: true });
+        }
+
+        const checkpointPath = path.join(this.checkpointDir, `${checkpointId}.json`);
+        fs.writeFileSync(checkpointPath, JSON.stringify(checkpoint, null, 2), 'utf-8');
+      } catch (error) {
+        this._markPersistenceUnavailable(error);
+      }
+    }
 
     // Save main state with checkpoint timestamp update
     this.saveState({ updateCheckpoint: true });
@@ -781,12 +872,21 @@ class BuildStateManager {
       throw new Error('No state loaded');
     }
 
+    const attempt =
+      options.attempt ||
+      this._state.failedAttempts.filter((f) => f.subtaskId === subtaskId).length + 1;
+
+    const normalizedFailure = normalizeFailureError(options.error, {
+      storyId: this.storyId,
+      subtaskId,
+      attempt,
+    });
+
     const failure = {
       subtaskId,
-      attempt:
-        options.attempt ||
-        this._state.failedAttempts.filter((f) => f.subtaskId === subtaskId).length + 1,
-      error: options.error || 'Unknown error',
+      attempt,
+      error: normalizedFailure.message,
+      errorDetails: normalizedFailure.details,
       timestamp: new Date().toISOString(),
       approach: options.approach || null,
       duration: options.duration || null,
@@ -808,6 +908,7 @@ class BuildStateManager {
     this._logAttempt(subtaskId, 'failure', {
       attempt: failure.attempt,
       error: failure.error,
+      errorDetails: failure.errorDetails,
       isStuck: isStuck.stuck,
     });
 
@@ -918,6 +1019,8 @@ class BuildStateManager {
    * @private
    */
   _logAttempt(subtaskId, action, details = {}) {
+    if (!this._persistenceAvailable) return;
+
     const entry = {
       timestamp: new Date().toISOString(),
       storyId: this.storyId,
@@ -927,7 +1030,7 @@ class BuildStateManager {
     };
 
     // Format log line
-    const logLine = `[${entry.timestamp}] [${this.storyId}] [${subtaskId}] ${action}: ${JSON.stringify(details)}\n`;
+    const logLine = `[${entry.timestamp}] [${this.storyId}] [${subtaskId}] ${action}: ${stringifyLogDetails(details)}\n`;
 
     this._logBuffer.push(logLine);
 
@@ -943,15 +1046,20 @@ class BuildStateManager {
    */
   _flushLogBuffer() {
     if (this._logBuffer.length === 0) return;
+    if (!this._persistenceAvailable) return;
 
-    // Ensure directory exists
-    if (!fs.existsSync(this.planDir)) {
-      fs.mkdirSync(this.planDir, { recursive: true });
-    }
+    try {
+      // Ensure directory exists
+      if (!fs.existsSync(this.planDir)) {
+        fs.mkdirSync(this.planDir, { recursive: true });
+      }
 
-    // Append to log file
-    fs.appendFileSync(this.logFilePath, this._logBuffer.join(''), 'utf-8');
-    this._logBuffer = [];
+      // Append to log file
+      fs.appendFileSync(this.logFilePath, this._logBuffer.join(''), 'utf-8');
+      this._logBuffer = [];
+    } catch (error) {
+      this._markPersistenceUnavailable(error);
+    }
   }
 
   /**
@@ -961,11 +1069,22 @@ class BuildStateManager {
    * @returns {string[]} Log lines
    */
   getAttemptLog(options = {}) {
+    if (!this._persistenceAvailable) {
+      return [];
+    }
+
     if (!fs.existsSync(this.logFilePath)) {
       return [];
     }
 
-    const content = fs.readFileSync(this.logFilePath, 'utf-8');
+    let content;
+    try {
+      content = fs.readFileSync(this.logFilePath, 'utf-8');
+    } catch (error) {
+      this._markPersistenceUnavailable(error);
+      return [];
+    }
+
     let lines = content.split('\n').filter((l) => l.trim());
 
     // Filter by subtask if specified
@@ -1143,6 +1262,39 @@ class BuildStateManager {
     // Silent by default - can be overridden
   }
 
+  /**
+   * Check if file-backed persistence is still available.
+   *
+   * @returns {boolean} True when state/checkpoint/log writes are available.
+   */
+  isPersistenceAvailable() {
+    return this._persistenceAvailable;
+  }
+
+  /**
+   * Get the first persistence error that disabled file-backed writes.
+   *
+   * @returns {Error|null} Persistence error or null when persistence is available.
+   */
+  getPersistenceError() {
+    return this._persistenceError;
+  }
+
+  /**
+   * Disable file-backed persistence after an I/O failure.
+   *
+   * @param {Error} error - Underlying persistence error.
+   * @private
+   */
+  _markPersistenceUnavailable(error) {
+    if (!this._persistenceAvailable) return;
+
+    this._persistenceAvailable = false;
+    this._persistenceError = error instanceof Error ? error : new Error(String(error));
+    this._logBuffer = [];
+    this._log(`Persistence unavailable: ${this._persistenceError.message}`);
+  }
+
   // ─────────────────────────────────────────────────────────────────────────────────
   //                              CLI FORMATTING
   // ─────────────────────────────────────────────────────────────────────────────────

package/.sinapse-ai/core/execution/parallel-executor.js

@@ -1,8 +1,14 @@
 /**
- * Parallel Executor
+ * Parallel Executor (PROVIDER-level)
  * Story GEMINI-INT.17 - Multi-Agent Parallel Execution
  *
  * Executes Claude and Gemini in parallel for improved quality and reliability.
+ *
+ * NOT a duplicate of `core/orchestration/parallel-executor.js` (audit 2026-06-11
+ * flagged them as duplicate — they are NOT). This one races/merges AI PROVIDERS
+ * (RACE/CONSENSUS/BEST_OF/MERGE/FALLBACK). The orchestration one runs independent
+ * WORKFLOW PHASES concurrently. Different concerns; do not merge (a merge would
+ * lose one capability).
  */
 
 const EventEmitter = require('events');

package/.sinapse-ai/core/execution/semantic-merge-engine.js

@@ -16,7 +16,7 @@
  * Based on Auto-Claude's merge system architecture.
  */
 
-const { execSync } = require('child_process');
+const { execSync, execFileSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const EventEmitter = require('events');
@@ -180,17 +180,29 @@ class SemanticAnalyzer {
       }));
 
       // Extract functions
+      // DATA-003: the jsFunction regex can degrade to quadratic on pathological
+      // inputs (very large files with lots of whitespace). Cap the analyzed size
+      // and the iteration count so a single oversized file can't stall the engine.
+      // Normal files (well under the limits) are unaffected.
+      const MAX_FUNC_SCAN_BYTES = 200_000;
+      const MAX_FUNC_MATCHES = 10_000;
       let match;
-      const funcRegex = new RegExp(this.patterns.jsFunction.source, 'gm');
-      while ((match = funcRegex.exec(content)) !== null) {
-        const name = match[1] || match[2] || match[3];
-        if (name) {
-          elements.functions.push({
-            type: 'function',
-            name,
-            content: this.extractFunctionBody(content, match.index),
-            location: this.getLocation(content, match.index),
-          });
+      if (content.length <= MAX_FUNC_SCAN_BYTES) {
+        const funcRegex = new RegExp(this.patterns.jsFunction.source, 'gm');
+        let matchCount = 0;
+        while ((match = funcRegex.exec(content)) !== null) {
+          if (++matchCount > MAX_FUNC_MATCHES) break;
+          const name = match[1] || match[2] || match[3];
+          if (name) {
+            elements.functions.push({
+              type: 'function',
+              name,
+              content: this.extractFunctionBody(content, match.index),
+              location: this.getLocation(content, match.index),
+            });
+          }
+          // Guard against zero-width matches causing an infinite loop.
+          if (match.index === funcRegex.lastIndex) funcRegex.lastIndex++;
         }
       }
 
@@ -1521,7 +1533,7 @@ class SemanticMergeEngine extends EventEmitter {
 
     try {
       // Get list of files
-      const fileList = execSync(`git ls-tree -r --name-only ${branch}`, {
+      const fileList = execFileSync('git', ['ls-tree', '-r', '--name-only', branch], {
         cwd: this.rootPath,
         encoding: 'utf8',
       })
@@ -1531,7 +1543,7 @@ class SemanticMergeEngine extends EventEmitter {
       for (const filePath of fileList) {
         if (this.shouldProcessFile(filePath)) {
           try {
-            const content = execSync(`git show ${branch}:${filePath}`, {
+            const content = execFileSync('git', ['show', `${branch}:${filePath}`], {
               cwd: this.rootPath,
               encoding: 'utf8',
             });
@@ -1564,7 +1576,7 @@ class SemanticMergeEngine extends EventEmitter {
 
     try {
       // Get modified files in this task
-      const diffOutput = execSync(`git diff --name-only ${branch || 'main'}...HEAD`, {
+      const diffOutput = execFileSync('git', ['diff', '--name-only', `${branch || 'main'}...HEAD`], {
         cwd: workDir,
         encoding: 'utf8',
       }).trim();