pkg-scaffold 3.3.3 → 3.3.5

package/src/healing/GitSandbox.js

@@ -1,160 +1,82 @@
-import { execSync } from 'child_process';
+import { execa } from 'execa';
 import path from 'path';
 
 /**
- * Ephemeral Git Sandbox & Version Control Islolation Gateway
- * Manages atomic branch switching, working-tree stashing, and systemic rollbacks.
+ * Deterministic Version Control Guard for Structural Healing Operations.
+ * Manages atomic state rollbacks when automated refactoring breaks the build.
  */
 export class GitSandbox {
   constructor(context) {
     this.context = context;
-    this.originalBranch = null;
-    this.sandboxBranch = null;
-    this.hasStashedChanges = false;
-    this.isGitRepository = false;
+    this.initialBranch = '';
+    this.healingBranch = `scaffold-healing-${Date.now()}`;
   }
 
   /**
-   * Validates the active environment and isolates the working directory.
+   * Captures the current repository state before applying structural modifications.
    */
-  async establishIsolationCheckpoint() {
-    this.verifyGitRepositoryPresence();
-    if (!this.isGitRepository) return;
-
+  async captureState() {
     try {
-      // Capture the current branch name
-      this.originalBranch = execSync('git rev-parse --abbrev-ref HEAD', { 
-        cwd: this.context.cwd, 
-        encoding: 'utf8' 
-      }).trim();
-
-      // Check for uncommitted working directory changes
-      const statusOutput = execSync('git status --porcelain', { 
-        cwd: this.context.cwd, 
-        encoding: 'utf8' 
-      }).trim();
-
-      if (statusOutput.length > 0) {
-        if (this.context.verbose) {
-          console.log('📦 Working tree contains uncommitted changes. Stashing before running pipeline...');
-        }
-        execSync('git stash save "pkg-scaffold: Ephemeral Checkpoint Stash"', { 
-          cwd: this.context.cwd, 
-          stdio: 'ignore' 
-        });
-        this.hasStashedChanges = true;
-      }
-
-      // Generate an isolated tracking branch name
-      this.sandboxBranch = `scaffold-heal-${Date.now()}`;
-      execSync(`git checkout -b ${this.sandboxBranch}`, { 
-        cwd: this.context.cwd, 
-        stdio: 'ignore' 
-      });
-
+      const { stdout } = await execa('git', ['rev-parse', '--abbrev-ref', 'HEAD'], { cwd: this.context.cwd });
+      this.initialBranch = stdout.trim();
+      
+      // Create a temporary recovery branch
+      await execa('git', ['checkout', '-b', this.healingBranch], { cwd: this.context.cwd });
       if (this.context.verbose) {
-        console.log(`🌿 Isolated sandbox branch successfully initialized: [${this.sandboxBranch}]`);
+        console.log(`[Git] State captured in temporary branch: ${this.healingBranch}`);
       }
-    } catch (error) {
-      throw new Error(`Git Sandbox separation failure: ${error.message}`);
+    } catch (e) {
+      throw new Error(`Git state capture failed: Ensure the directory is a git repository. (${e.message})`);
     }
   }
 
   /**
-   * Commits all modifications within the sandbox branch for validation testing.
+   * Reverts all changes applied during the healing cycle if verification fails.
    */
-  async stageAndCheckpointChanges(commitMessage = 'refactor(scaffold): apply structural optimizations') {
-    if (!this.isGitRepository) return;
-    this.assertActiveIsolation();
-
+  async rollback() {
     try {
-      execSync('git add .', { cwd: this.context.cwd, stdio: 'ignore' });
-      
-      // Check if any mutations were actually staged
-      const diffIndex = execSync('git diff --cached --name-only', { 
-        cwd: this.context.cwd, 
-        encoding: 'utf8' 
-      }).trim();
-
-      if (diffIndex.length === 0) return; // No modifications to verify
-
-      execSync(`git commit -m "${commitMessage}" --no-verify`, { 
-        cwd: this.context.cwd, 
-        stdio: 'ignore' 
-      });
-    } catch (error) {
-      throw new Error(`Failed to stage changes inside the sandbox: ${error.message}`);
+      console.log(`[Git] Rolling back structural modifications...`);
+      await execa('git', ['reset', '--hard', 'HEAD'], { cwd: this.context.cwd });
+      await execa('git', ['checkout', this.initialBranch], { cwd: this.context.cwd });
+      await execa('git', ['branch', '-D', this.healingBranch], { cwd: this.context.cwd });
+    } catch (e) {
+      console.error(`[Git] Critical rollback failure: ${e.message}`);
     }
   }
 
   /**
-   * Merges modifications back into the mainline branch if all validation test suites pass.
+   * Finalizes the healing cycle by merging changes back to the original branch.
    */
-  async acceptAndMergeOptimizations() {
-    if (!this.isGitRepository) return;
-    this.assertActiveIsolation();
-
+  async commit() {
     try {
-      // Return to the original project branch boundary
-      execSync(`git checkout ${this.originalBranch}`, { cwd: this.context.cwd, stdio: 'ignore' });
+      await execa('git', ['add', '.'], { cwd: this.context.cwd });
+      await execa('git', ['commit', '-m', 'chore: automated structural healing (pkg-scaffold)'], { cwd: this.context.cwd });
       
-      // Merge the verified changes without creating a fast-forward bottleneck
-      execSync(`git merge --squash ${this.sandboxBranch}`, { cwd: this.context.cwd, stdio: 'ignore' });
-      execSync('git commit -m "chore(refactor): apply verified dead-code removals" --no-verify', {
-        cwd: this.context.cwd,
-        stdio: 'ignore'
-      });
-
-      // Purge the temporary branch tracking reference
-      execSync(`git branch -D ${this.sandboxBranch}`, { cwd: this.context.cwd, stdio: 'ignore' });
-      this.restorePreviousWorkingState();
-    } catch (error) {
-      throw new Error(`Failed to merge sandbox modifications into mainline branch: ${error.message}`);
+      await execa('git', ['checkout', this.initialBranch], { cwd: this.context.cwd });
+      await execa('git', ['merge', this.healingBranch], { cwd: this.context.cwd });
+      await execa('git', ['branch', '-D', this.healingBranch], { cwd: this.context.cwd });
+      
+      if (this.context.verbose) {
+        console.log(`[Git] Structural modifications successfully merged into ${this.initialBranch}`);
+      }
+    } catch (e) {
+      console.error(`[Git] Commit failed: ${e.message}`);
     }
   }
 
   /**
-   * Reverts all disk changes instantly if testing suites flag an error.
+   * Runs a verification command (e.g., npm test) to ensure structural integrity.
    */
-  async rejectAndAbortOptimizations() {
-    if (!this.isGitRepository) return;
-    if (!this.sandboxBranch) return;
-
+  async verifyIntegrity() {
     try {
+      const [cmd, ...args] = this.context.testCommand.split(' ');
+      await execa(cmd, args, { cwd: this.context.cwd });
+      return true;
+    } catch (e) {
       if (this.context.verbose) {
-        console.log('🔄 Aborting transaction loop. Resetting file systems...');
+        console.warn(`[Git] Integrity verification failed: ${e.message}`);
       }
-      
-      execSync('git add . && git reset --hard HEAD', { cwd: this.context.cwd, stdio: 'ignore' });
-      execSync(`git checkout ${this.originalBranch}`, { cwd: this.context.cwd, stdio: 'ignore' });
-      execSync(`git branch -D ${this.sandboxBranch}`, { cwd: this.context.cwd, stdio: 'ignore' });
-      
-      this.restorePreviousWorkingState();
-    } catch (error) {
-      console.error(`🚨 Critical Recovery Error: Failed to drop sandbox branch cleanly: ${error.message}`);
-    }
-  }
-
-  restorePreviousWorkingState() {
-    if (this.hasStashedChanges) {
-      execSync('git stash pop', { cwd: this.context.cwd, stdio: 'ignore' });
-      this.hasStashedChanges = false;
-    }
-    this.sandboxBranch = null;
-  }
-
-  verifyGitRepositoryPresence() {
-    try {
-      execSync('git rev-parse --is-inside-work-tree', { cwd: this.context.cwd, stdio: 'ignore' });
-      this.isGitRepository = true;
-    } catch {
-      this.isGitRepository = false;
-    }
-  }
-
-  assertActiveIsolation() {
-    if (!this.sandboxBranch) {
-      throw new Error('Git Sandbox operation error: No active sandbox tracking context exists.');
+      return false;
     }
   }
 }

package/src/healing/SelfHealer.js

@@ -1,150 +1,49 @@
-import { spawn } from 'child_process';
-import path from 'path';
+import ansis from 'ansis';
 
 /**
- * Self-Healing Test Orchestration & Regression Scanner
- * Runs validation suites, intercepts stack traces, and controls transaction rollbacks.
+ * Automated Structural Healing Orchestrator.
+ * Manages the lifecycle of applying structural fixes and verifying codebase health.
+ * This is a deterministic engine and does not use AI/LLMs.
  */
 export class SelfHealer {
-  constructor(context, transactionManager, gitSandbox) {
+  constructor(context, txManager, gitSandbox) {
     this.context = context;
-    this.transactionManager = transactionManager;
+    this.txManager = txManager;
     this.gitSandbox = gitSandbox;
-    this.executionTimeout = 45000; // 45-second execution timeout wall
   }
 
   /**
-   * Validates the stability of staged code changes by running your project's test suite.
-   * @param {Function} refactorTask - The function containing code changes to evaluate
+   * Executes a structural healing cycle with automatic rollback on failure.
+   * @param {Function} refactorLogic - Async function that stages structural changes
    */
-  async runSelfHealingLifecycle(refactorTask) {
-    console.log('🛡️  Initializing transaction safety sandbox...');
+  async runSelfHealingLifecycle(refactorLogic) {
+    console.log(ansis.bold.blue('\n🩹 Initiating Automated Structural Healing Cycle...'));
     
-    // Step 1: Open the transaction boundaries
-    await this.gitSandbox.establishIsolationCheckpoint();
-    await this.transactionManager.begin();
-
     try {
-      // Step 2: Execute the codebase pruning transformations
-      await refactorTask();
+      // 1. Capture current stable state
+      await this.gitSandbox.captureState();
+
+      // 2. Execute the provided refactoring logic (staging deletions/writes)
+      await refactorLogic();
 
-      // Step 3: Stage changes inside our Git tracking context
-      await this.gitSandbox.stageAndCheckpointChanges();
+      // 3. Commit staged changes to disk
+      await this.txManager.commitAll();
 
-      console.log('🧪 Running testing suites to verify workspace integrity...');
-      const validationPassed = await this.verifyProjectHealthStatus();
+      // 4. Verify structural integrity (e.g., run tests)
+      console.log(ansis.dim('🧪 Verifying codebase integrity...'));
+      const isHealthy = await this.gitSandbox.verifyIntegrity();
 
-      if (validationPassed) {
-        console.log('✨ Build stable. Merging verified code improvements.');
-        await this.transactionManager.commit();
-        await this.gitSandbox.acceptAndMergeOptimizations();
-        return true;
+      if (isHealthy) {
+        console.log(ansis.bold.green('✅ Structural integrity verified. Finalizing changes.'));
+        await this.gitSandbox.commit();
       } else {
-        console.warn('⚠️  Regression flagged during validation. Triggering self-healing rollback...');
-        await this.revertWorkspaceToSafeState();
-        return false;
+        console.log(ansis.bold.red('❌ Structural integrity compromised. Rolling back changes.'));
+        await this.gitSandbox.rollback();
+        this.context.metrics.securityVulnerabilitiesMitigated = 0; // Reset metrics for failed cycle
       }
-    } catch (pipelineError) {
-      console.error(`🚨 Critical Exception Intercepted: ${pipelineError.message}`);
-      await this.revertWorkspaceToSafeState();
-      return false;
-    }
-  }
-
-  /**
-   * Spawns testing processes to detect exit code alerts or compiler trace metrics.
-   * @returns {Promise<boolean>} True if the test suite runs with an exit code of 0
-   */
-  verifyProjectHealthStatus() {
-    return new Promise((resolve) => {
-      const commandTokens = this.context.testCommand.split(' ');
-      const executionBinary = commandTokens.shift();
-      
-      const processBuffer = [];
-      const testProcess = spawn(executionBinary, commandTokens, {
-        cwd: this.context.cwd,
-        shell: true
-      });
-
-      // Implement an execution timeout monitor to prevent hanging test suites from blocking the pipeline
-      const timeoutWatch = setTimeout(() => {
-        console.warn('⏱️  Test execution exceeded timeout limit. Terminating subprocess...');
-        testProcess.kill('SIGKILL');
-      }, this.executionTimeout);
-
-      testProcess.stdout.on('data', (data) => {
-        processBuffer.push(data);
-        if (this.context.verbose) {
-          process.stdout.write(data);
-        }
-      });
-
-      testProcess.stderr.on('data', (data) => {
-        processBuffer.push(data);
-        if (this.context.verbose) {
-          process.stderr.write(data);
-        }
-      });
-
-      testProcess.on('close', (exitCode) => {
-        clearTimeout(timeoutWatch);
-        
-        if (exitCode !== 0) {
-          const fullConsoleOutput = Buffer.concat(processBuffer).toString('utf8');
-          this.diagnoseErrorOutput(fullConsoleOutput);
-          resolve(false);
-        } else {
-          resolve(true);
-        }
-      });
-
-      testProcess.on('error', (err) => {
-        clearTimeout(timeoutWatch);
-        if (this.context.verbose) {
-          console.error(`Subprocess execution error: ${err.message}`);
-        }
-        resolve(false);
-      });
-    });
-  }
-
-  /**
-   * Traces error codes and console log outputs to identify the root cause of a broken build.
-   */
-  diagnoseErrorOutput(consoleLogOutput) {
-    console.log('\n🔍 [Diagnostics] Reviewing error output...');
-    
-    // Scan for standard TypeScript Compilation errors
-    const tsErrorPattern = /error\s+TS(\d+):\s+([\s\S]*?)$/m;
-    const tsMatches = consoleLogOutput.match(tsErrorPattern);
-    
-    if (tsMatches) {
-      console.error(`❌ Mapped Type Error Code [TS${tsMatches[1]}]: ${tsMatches[2].trim()}`);
-      return;
-    }
-
-    // Scan for missing file imports or runtime resolution exceptions
-    const missingModulePattern = /Cannot find module '([^']+)'/i;
-    const moduleMatches = consoleLogOutput.match(missingModulePattern);
-    
-    if (moduleMatches) {
-      console.error(`❌ Missing Dependency Reference Pointer: Cannot locate element [${moduleMatches[1]}]`);
-      return;
-    }
-
-    console.error('❌ Test suite execution failed. Check standard console output for details.');
-  }
-
-  /**
-   * Automatically executes a rollback event, restoring both file states and Git status.
-   */
-  async revertWorkspaceToSafeState() {
-    try {
-      await this.transactionManager.rollback();
-      await this.gitSandbox.rejectAndAbortOptimizations();
-      console.log('🔄 [Self-Healing] Rollback complete. Original project states restored.');
-    } catch (recoveryError) {
-      console.error(`🚨 Fatal Recovery Error: Failed to restore prior workspace configuration: ${recoveryError.message}`);
+    } catch (error) {
+      console.error(ansis.bold.red(`\n🚨 Healing Cycle Aborted: ${error.message}`));
+      await this.gitSandbox.rollback();
     }
   }
 }