@fermindi/pwn-cli 0.9.4 → 0.9.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fermindi/pwn-cli",
-  "version": "0.9.4",
+  "version": "0.9.6",
   "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

@@ -391,34 +391,24 @@ export async function runBatch(options = {}, cwd = process.cwd()) {
       }
     }
 
-    // --- Branch isolation: create/checkout task branch ---
-    let taskBranch = null;
+    // --- Pre-validation: check existing feat branch before reset ---
+    let storyDone = false;
+    const taskBranchName = `feat/${task.id}`;
+    let branchExists = false;
     try {
-      taskBranch = await createTaskBranch(task.id, cwd);
-      branchesCreated.push(taskBranch);
-      console.log(chalk.blue(`  Branch: ${chalk.bold(taskBranch)}`));
+      await execAsync(`git rev-parse --verify ${taskBranchName}`, { cwd });
+      branchExists = true;
+    } catch {}
 
-      // Track branch in task file
-      if (taskFile) {
-        taskFile.branch = taskBranch;
-        saveTaskFile(taskFile, cwd);
-      }
-    } catch (err) {
-      console.log(chalk.red(`  Failed to create branch feat/${task.id}: ${err.message}`));
-      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
+    if (branchExists) {
       try {
-        const { stdout: diffStat } = await execAsync('git diff --stat HEAD~1 2>/dev/null || echo ""', { cwd });
+        // Checkout WITHOUT reset to inspect existing work
+        await checkoutBranch(taskBranchName, cwd, { stash: true });
         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...`));
+          console.log(chalk.blue(`  Pre-validation: found ${commits} commit(s) on ${taskBranchName}, running quality gates...`));
           const preGates = await runGatesWithStatus(cwd);
 
           if (preGates.success) {
@@ -445,35 +435,56 @@ export async function runBatch(options = {}, cwd = process.cwd()) {
             // Merge into batch branch
             try {
               await checkoutBranch(batchBranch, cwd, { stash: true });
-              await mergeBranch(taskBranch, cwd);
+              await mergeBranch(taskBranchName, cwd);
               mergedCount++;
-              mergedBranches.push(taskBranch);
-              console.log(chalk.green(`  Merged ${taskBranch} → ${batchBranch}`));
+              mergedBranches.push(taskBranchName);
+              console.log(chalk.green(`  Merged ${taskBranchName} → ${batchBranch}`));
             } catch (err) {
               console.log(chalk.red(`  Merge failed: ${err.message}`));
-              console.log(chalk.yellow(`  Branch ${taskBranch} available for manual merge`));
-              unmergedBranches.push(taskBranch);
+              console.log(chalk.yellow(`  Branch ${taskBranchName} available for manual merge`));
+              unmergedBranches.push(taskBranchName);
             }
           } else {
             console.log(chalk.yellow(`  Pre-validation FAILED — will re-execute`));
+            // Return to batch branch so createTaskBranch resets properly
+            await checkoutBranch(batchBranch, cwd, { force: true, stash: true });
           }
+        } else {
+          // No commits — return to batch branch for normal flow
+          await checkoutBranch(batchBranch, cwd, { force: true, stash: true });
         }
       } catch {
-        // No commits or comparison failed — proceed normally
+        // Checkout failed — proceed normally
+        try { await checkoutBranch(batchBranch, cwd, { force: true, stash: true }); } catch {}
       }
     }
 
     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 {}
-      }
+      branchesCreated.push(taskBranchName);
+      try {
+        await checkoutBranch(batchBranch, cwd, { force: true, stash: true });
+        console.log(chalk.dim(`  Returned to branch: ${batchBranch}`));
+      } catch {}
       continue;
     }
 
+    // --- Branch isolation: create/checkout task branch (resets existing) ---
+    let taskBranch = null;
+    try {
+      taskBranch = await createTaskBranch(task.id, cwd);
+      branchesCreated.push(taskBranch);
+      console.log(chalk.blue(`  Branch: ${chalk.bold(taskBranch)}`));
+
+      // Track branch in task file
+      if (taskFile) {
+        taskFile.branch = taskBranch;
+        saveTaskFile(taskFile, cwd);
+      }
+    } catch (err) {
+      console.log(chalk.red(`  Failed to create branch feat/${task.id}: ${err.message}`));
+      console.log(chalk.yellow('  Continuing on current branch...'));
+    }
+
     // --- Phase 2: Execution ---
     const phaseLabel = noPlan ? '' : 'Phase 2';
     console.log(chalk.blue(`  ${noPlan ? 'Executing' : 'Phase 2: Executing'} ${task.id}...`));

package/src/services/batch-service.js

@@ -50,16 +50,10 @@ export async function createTaskBranch(taskId, cwd = process.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 {}
+    // Stash + drop to unblock checkout -b (metadata files re-created by runner)
+    try { await execAsync('git stash --include-untracked', { cwd }); } catch {}
     await execAsync(`git checkout -b ${branch}`, { cwd });
-    if (didStash) {
-      try { await execAsync('git stash pop', { cwd }); } catch {}
-    }
+    try { await execAsync('git stash drop', { cwd }); } catch {}
   }
   return branch;
 }
@@ -73,25 +67,18 @@ export async function createTaskBranch(taskId, cwd = process.cwd()) {
  * @param {{ force?: boolean, stash?: boolean }} options
  */
 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 {}
+    // Stash only to unblock checkout, then drop — these are runner
+    // metadata files (.ai/batch/tasks/*.json) that get re-created by
+    // saveTaskFile, so restoring them causes merge conflicts for no gain.
+    try { await execAsync('git stash --include-untracked', { cwd }); } catch {}
   }
 
   const flag = force ? ' --force' : '';
-  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;
-  }
+  await execAsync(`git checkout${flag} ${branch}`, { cwd });
 
-  if (didStash) {
-    try { await execAsync('git stash pop', { cwd }); } catch {}
+  if (stash) {
+    try { await execAsync('git stash drop', { cwd }); } catch {}
   }
 }