entkapp 4.1.0

package/src/healing/GitSandbox.js

@@ -0,0 +1,82 @@
+import { execa } from 'execa';
+import path from 'path';
+
+/**
+ * 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.initialBranch = '';
+    this.healingBranch = `scaffold-healing-${Date.now()}`;
+  }
+
+  /**
+   * Captures the current repository state before applying structural modifications.
+   */
+  async captureState() {
+    try {
+      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(`[Git] State captured in temporary branch: ${this.healingBranch}`);
+      }
+    } catch (e) {
+      throw new Error(`Git state capture failed: Ensure the directory is a git repository. (${e.message})`);
+    }
+  }
+
+  /**
+   * Reverts all changes applied during the healing cycle if verification fails.
+   */
+  async rollback() {
+    try {
+      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}`);
+    }
+  }
+
+  /**
+   * Finalizes the healing cycle by merging changes back to the original branch.
+   */
+  async commit() {
+    try {
+      await execa('git', ['add', '.'], { cwd: this.context.cwd });
+      await execa('git', ['commit', '-m', 'chore: automated structural healing (entkapp)'], { cwd: this.context.cwd });
+      
+      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}`);
+    }
+  }
+
+  /**
+   * Runs a verification command (e.g., npm test) to ensure structural integrity.
+   */
+  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.warn(`[Git] Integrity verification failed: ${e.message}`);
+      }
+      return false;
+    }
+  }
+}

package/src/healing/SelfHealer.js

@@ -0,0 +1,52 @@
+import ansis from 'ansis';
+
+/**
+ * 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, txManager, gitSandbox) {
+    this.context = context;
+    this.txManager = txManager;
+    this.gitSandbox = gitSandbox;
+  }
+
+  /**
+   * Executes a structural healing cycle with automatic rollback on failure.
+   * @param {Function} refactorLogic - Async function that stages structural changes
+   */
+  async runSelfHealingLifecycle(refactorLogic) {
+    console.log(ansis.bold.blue('\n🩹 Initiating Automated Structural Healing Cycle...'));
+    
+    try {
+      // 1. Capture current stable state
+      await this.gitSandbox.captureState();
+
+      // 1b. Initialize transaction tracking
+      await this.txManager.begin();
+
+      // 2. Execute the provided refactoring logic (staging deletions/writes)
+      await refactorLogic();
+
+      // 3. Commit staged changes to disk
+      await this.txManager.commit();
+
+      // 4. Verify structural integrity (e.g., run tests)
+      console.log(ansis.dim('🧪 Verifying codebase integrity...'));
+      const isHealthy = await this.gitSandbox.verifyIntegrity();
+
+      if (isHealthy) {
+        console.log(ansis.bold.green('✅ Structural integrity verified. Finalizing changes.'));
+        await this.gitSandbox.commit();
+      } else {
+        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 (error) {
+      console.error(ansis.bold.red(`\n🚨 Healing Cycle Aborted: ${error.message}`));
+      await this.gitSandbox.rollback();
+    }
+  }
+}