@fermindi/pwn-cli 0.9.2 → 0.9.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fermindi/pwn-cli",
-  "version": "0.9.2",
+  "version": "0.9.4",
   "description": "Professional AI Workspace - Inject structured memory and automation into any project for AI-powered development",
   "type": "module",
   "bin": {

package/src/services/batch-runner.js

@@ -34,7 +34,7 @@ import {
 } from './batch-service.js';
 
 // --- Constants ---
-const RUNNER_VERSION = '2.1';
+const RUNNER_VERSION = '2.3';
 const DEFAULT_TIMEOUT_MS = 900_000;  // 15 minutes fallback
 const MIN_TIMEOUT_MS = 300_000;      // 5 minutes minimum (claude init ~30-40s + real work)
 
@@ -408,13 +408,78 @@ export async function runBatch(options = {}, cwd = process.cwd()) {
       console.log(chalk.yellow('  Continuing on current branch...'));
     }
 
+    // --- Pre-validation: check if existing branch already passes gates ---
+    let storyDone = false;
+    if (taskBranch) {
+      // Check if this branch has commits beyond the batch branch
+      try {
+        const { stdout: diffStat } = await execAsync('git diff --stat HEAD~1 2>/dev/null || echo ""', { cwd });
+        const { stdout: logCount } = await execAsync(`git rev-list --count ${batchBranch}..HEAD`, { cwd });
+        const commits = parseInt(logCount.trim(), 10);
+
+        if (commits > 0) {
+          console.log(chalk.blue(`  Pre-validation: found ${commits} commit(s) on ${taskBranch}, running quality gates...`));
+          const preGates = await runGatesWithStatus(cwd);
+
+          if (preGates.success) {
+            console.log(chalk.green(`  Pre-validation PASSED — skipping execution`));
+            markStoryDone(task.id, cwd);
+            appendProgress(progressPath, task.id, 'Pre-validation: existing code passed quality gates');
+
+            storyDone = true;
+            storiesCompleted++;
+            noProgressCount = 0;
+
+            if (taskFile) {
+              taskFile.status = 'completed';
+              taskFile.completed_at = new Date().toISOString();
+              saveTaskFile(taskFile, cwd);
+            }
+
+            updateBatchState({
+              completed: [task.id],
+              current_task: null,
+              last_completed_at: new Date().toISOString()
+            }, cwd);
+
+            // Merge into batch branch
+            try {
+              await checkoutBranch(batchBranch, cwd, { stash: true });
+              await mergeBranch(taskBranch, cwd);
+              mergedCount++;
+              mergedBranches.push(taskBranch);
+              console.log(chalk.green(`  Merged ${taskBranch} → ${batchBranch}`));
+            } catch (err) {
+              console.log(chalk.red(`  Merge failed: ${err.message}`));
+              console.log(chalk.yellow(`  Branch ${taskBranch} available for manual merge`));
+              unmergedBranches.push(taskBranch);
+            }
+          } else {
+            console.log(chalk.yellow(`  Pre-validation FAILED — will re-execute`));
+          }
+        }
+      } catch {
+        // No commits or comparison failed — proceed normally
+      }
+    }
+
+    if (storyDone) {
+      // Return to batch branch
+      if (taskBranch) {
+        try {
+          await checkoutBranch(batchBranch, cwd, { force: true, stash: true });
+          console.log(chalk.dim(`  Returned to branch: ${batchBranch}`));
+        } catch {}
+      }
+      continue;
+    }
+
     // --- Phase 2: Execution ---
     const phaseLabel = noPlan ? '' : 'Phase 2';
     console.log(chalk.blue(`  ${noPlan ? 'Executing' : 'Phase 2: Executing'} ${task.id}...`));
 
     let retry = 0;
     let rateLimitAttempts = 0;
-    let storyDone = false;
     let errorContext = '';
 
     while (retry <= MAX_RETRIES && !storyDone) {
@@ -437,10 +502,7 @@ export async function runBatch(options = {}, cwd = process.cwd()) {
       if (result.signal) {
         console.log(chalk.yellow(`  Killed by ${result.signal}`));
         if (taskBranch) {
-          try {
-            try { await execAsync('git stash --include-untracked', { cwd }); } catch {}
-            await checkoutBranch(batchBranch, cwd, { force: true });
-          } catch {}
+          try { await checkoutBranch(batchBranch, cwd, { force: true, stash: true }); } catch {}
         }
         clearBatchState(cwd);
         printSummary(cwd, iteration, storiesCompleted, batchStart, branchesCreated, batchBranch, originalBranch, mergedCount, unmergedBranches);
@@ -550,21 +612,15 @@ export async function runBatch(options = {}, cwd = process.cwd()) {
         // Merge successful task branch into batch branch
         if (taskBranch) {
           try {
-            // Stash uncommitted metadata (task files etc.) before switching
-            await execAsync('git stash --include-untracked', { cwd });
-            await checkoutBranch(batchBranch, cwd);
+            await checkoutBranch(batchBranch, cwd, { stash: true });
             await mergeBranch(taskBranch, cwd);
             mergedCount++;
             mergedBranches.push(taskBranch);
             console.log(chalk.green(`  Merged ${taskBranch} → ${batchBranch}`));
-            // Restore stashed metadata on batch branch
-            try { await execAsync('git stash pop', { cwd }); } catch {}
           } catch (err) {
             console.log(chalk.red(`  Merge failed: ${err.message}`));
             console.log(chalk.yellow(`  Branch ${taskBranch} available for manual merge`));
             unmergedBranches.push(taskBranch);
-            // Drop stash if checkout/merge failed (still on feat branch)
-            try { await execAsync('git stash drop', { cwd }); } catch {}
           }
         }
       } else {
@@ -598,12 +654,10 @@ export async function runBatch(options = {}, cwd = process.cwd()) {
       noProgressCount++;
     }
 
-    // --- Return to batch branch (stash untracked + force for dirty state) ---
+    // --- Return to batch branch ---
     if (taskBranch) {
       try {
-        try { await execAsync('git stash --include-untracked', { cwd }); } catch {}
-        await checkoutBranch(batchBranch, cwd, { force: true });
-        try { await execAsync('git stash pop', { cwd }); } catch {}
+        await checkoutBranch(batchBranch, cwd, { force: true, stash: true });
         console.log(chalk.dim(`  Returned to branch: ${batchBranch}`));
       } catch (err) {
         console.log(chalk.red(`  Warning: failed to return to ${batchBranch}: ${err.message}`));

package/src/services/batch-service.js

@@ -42,39 +42,57 @@ export async function createTaskBranch(taskId, cwd = process.cwd()) {
     // Branch doesn't exist
   }
 
-  // Stash untracked files (task metadata etc.) that block checkout
-  let stashed = false;
-  try {
-    const { stdout: stashOut } = await execAsync('git stash --include-untracked', { cwd });
-    stashed = !stashOut.includes('No local changes');
-  } catch {}
-
   if (exists) {
     // Rerun — checkout and reset to current HEAD
     // so we don't carry stale/dirty state from previous attempt
     const { stdout } = await execAsync('git rev-parse HEAD', { cwd });
     const baseRef = stdout.trim();
-    await execAsync(`git checkout ${branch}`, { cwd });
+    await checkoutBranch(branch, cwd, { stash: true });
     await execAsync(`git reset --hard ${baseRef}`, { cwd });
   } else {
+    // Stash before -b too (untracked files block checkout -b as well)
+    let didStash = false;
+    try {
+      const { stdout } = await execAsync('git stash --include-untracked', { cwd });
+      didStash = !stdout.includes('No local changes');
+    } catch {}
     await execAsync(`git checkout -b ${branch}`, { cwd });
-  }
-
-  // Restore stashed files on the new branch
-  if (stashed) {
-    try { await execAsync('git stash pop', { cwd }); } catch {}
+    if (didStash) {
+      try { await execAsync('git stash pop', { cwd }); } catch {}
+    }
   }
   return branch;
 }
 
 /**
- * Checkout an existing branch
+ * Checkout an existing branch.
+ * When stash=true, stashes untracked/dirty files before checkout and
+ * restores them after — prevents .ai/batch/tasks/*.json from blocking.
  * @param {string} branch - Branch name
  * @param {string} cwd - Working directory
+ * @param {{ force?: boolean, stash?: boolean }} options
  */
-export async function checkoutBranch(branch, cwd = process.cwd(), { force = false } = {}) {
+export async function checkoutBranch(branch, cwd = process.cwd(), { force = false, stash = false } = {}) {
+  let didStash = false;
+  if (stash) {
+    try {
+      const { stdout } = await execAsync('git stash --include-untracked', { cwd });
+      didStash = !stdout.includes('No local changes');
+    } catch {}
+  }
+
   const flag = force ? ' --force' : '';
-  await execAsync(`git checkout${flag} ${branch}`, { cwd });
+  try {
+    await execAsync(`git checkout${flag} ${branch}`, { cwd });
+  } catch (err) {
+    // If checkout failed, drop stash so it doesn't pile up
+    if (didStash) { try { await execAsync('git stash drop', { cwd }); } catch {} }
+    throw err;
+  }
+
+  if (didStash) {
+    try { await execAsync('git stash pop', { cwd }); } catch {}
+  }
 }
 
 /**