@fermindi/pwn-cli 0.9.2 → 0.9.3

package/package.json

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

@@ -9,13 +9,10 @@
  * Completed files are cleaned up at the end; failed are kept for review.
  */
 
-import { spawn, exec } from 'child_process';
+import { spawn } from 'child_process';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, createWriteStream, appendFileSync, unlinkSync, readdirSync } from 'fs';
 import { join } from 'path';
-import { promisify } from 'util';
 import ora from 'ora';
-
-const execAsync = promisify(exec);
 import chalk from 'chalk';
 import {
   parsePrdTasks,
@@ -34,7 +31,7 @@ import {
 } from './batch-service.js';
 
 // --- Constants ---
-const RUNNER_VERSION = '2.1';
+const RUNNER_VERSION = '2.2';
 const DEFAULT_TIMEOUT_MS = 900_000;  // 15 minutes fallback
 const MIN_TIMEOUT_MS = 300_000;      // 5 minutes minimum (claude init ~30-40s + real work)
 
@@ -437,10 +434,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 +544,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 +586,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 {}
+  }
 }
 
 /**