@fermindi/pwn-cli 0.8.0 → 0.9.0

package/package.json

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

@@ -22,7 +22,12 @@ import {
   loadConfig,
   commitTask,
   updateBatchState,
-  clearBatchState
+  clearBatchState,
+  getCurrentBranch,
+  createTaskBranch,
+  checkoutBranch,
+  createBatchBranch,
+  mergeBranch
 } from './batch-service.js';
 
 // --- Constants ---
@@ -274,10 +279,21 @@ export async function runBatch(options = {}, cwd = process.cwd()) {
 
   // NO custom SIGINT handler — Ctrl+C uses default Node.js behavior (kills process group)
 
+  // --- Save original branch for isolation ---
+  const originalBranch = await getCurrentBranch(cwd);
+
+  // --- Create batch branch ---
+  const batchBranch = await createBatchBranch(cwd);
+  console.log(chalk.blue(`  Batch branch: ${chalk.bold(batchBranch)}`));
+
   // --- Main loop ---
   let iteration = 0;
   let noProgressCount = 0;
   let storiesCompleted = 0;
+  let mergedCount = 0;
+  const branchesCreated = [];
+  const mergedBranches = [];
+  const unmergedBranches = [];
   const batchStart = Date.now();
 
   updateBatchState({
@@ -372,6 +388,23 @@ export async function runBatch(options = {}, cwd = process.cwd()) {
       }
     }
 
+    // --- Branch isolation: create/checkout task branch ---
+    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}...`));
@@ -400,8 +433,11 @@ export async function runBatch(options = {}, cwd = process.cwd()) {
       // Killed by signal (user did kill or Ctrl+C) — don't retry, exit
       if (result.signal) {
         console.log(chalk.yellow(`  Killed by ${result.signal}`));
+        if (taskBranch) {
+          try { await checkoutBranch(batchBranch, cwd, { force: true }); } catch {}
+        }
         clearBatchState(cwd);
-        printSummary(cwd, iteration, storiesCompleted, batchStart);
+        printSummary(cwd, iteration, storiesCompleted, batchStart, branchesCreated, batchBranch, originalBranch, mergedCount, unmergedBranches);
         return;
       }
 
@@ -504,6 +540,21 @@ export async function runBatch(options = {}, cwd = process.cwd()) {
           current_task: null,
           last_completed_at: new Date().toISOString()
         }, cwd);
+
+        // Merge successful task branch into batch branch
+        if (taskBranch) {
+          try {
+            await checkoutBranch(batchBranch, cwd);
+            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.red(`  Quality gates FAILED`));
         errorContext = gatesResult.errorOutput;
@@ -535,6 +586,19 @@ export async function runBatch(options = {}, cwd = process.cwd()) {
       noProgressCount++;
     }
 
+    // --- Return to batch branch (force: discard dirty state from failed tasks) ---
+    if (taskBranch) {
+      try {
+        await checkoutBranch(batchBranch, cwd, { force: true });
+        console.log(chalk.dim(`  Returned to branch: ${batchBranch}`));
+      } catch (err) {
+        console.log(chalk.red(`  Warning: failed to return to ${batchBranch}: ${err.message}`));
+      }
+      if (!storyDone) {
+        unmergedBranches.push(taskBranch);
+      }
+    }
+
     if (noProgressCount >= MAX_NO_PROGRESS) {
       console.log(chalk.red(`\nCIRCUIT BREAKER: ${MAX_NO_PROGRESS} consecutive failures. Stopping.`));
       break;
@@ -542,7 +606,7 @@ export async function runBatch(options = {}, cwd = process.cwd()) {
   }
 
   clearBatchState(cwd);
-  printSummary(cwd, iteration, storiesCompleted, batchStart);
+  printSummary(cwd, iteration, storiesCompleted, batchStart, branchesCreated, batchBranch, originalBranch, mergedCount, unmergedBranches);
 }
 
 /**
@@ -791,7 +855,7 @@ function printHeader(maxIter, phase, total, done, noPlan = false, cwd = process.
   console.log(chalk.dim('─'.repeat(40)));
 }
 
-function printSummary(cwd, iterations, completed, startTime) {
+function printSummary(cwd, iterations, completed, startTime, branchesCreated = [], batchBranch = null, originalBranch = null, mergedCount = 0, unmergedBranches = []) {
   const stories = parsePrdTasks(cwd);
   const total = stories.length;
   const done = stories.filter(s => s.passes).length;
@@ -828,6 +892,21 @@ function printSummary(cwd, iterations, completed, startTime) {
   if (cleaned > 0 || failedKept > 0) {
     console.log(`  Cleanup:          ${chalk.green(`${cleaned} completed`)} removed, ${failedKept > 0 ? chalk.red(`${failedKept} failed`) : '0 failed'} kept for review`);
   }
+  if (batchBranch) {
+    console.log(`  Batch branch:     ${chalk.cyan(batchBranch)}`);
+    console.log(`  Merged:           ${chalk.green(mergedCount)} tasks merged into batch branch`);
+    if (unmergedBranches.length > 0) {
+      const unique = [...new Set(unmergedBranches)];
+      console.log(`  Unmerged:         ${chalk.yellow(unique.length)} isolated: ${unique.map(b => chalk.yellow(b)).join(', ')}`);
+    }
+  }
+  if (branchesCreated.length > 0) {
+    const unique = [...new Set(branchesCreated)];
+    console.log(`  Branches:         ${unique.map(b => chalk.cyan(b)).join(', ')}`);
+  }
+  if (originalBranch) {
+    console.log(`  Original branch:  ${chalk.green(originalBranch)} (intact)`);
+  }
   console.log(chalk.dim('─'.repeat(40)));
   console.log('');
 }

package/src/services/batch-service.js

@@ -13,6 +13,73 @@ import { getState, updateState, hasWorkspace } from '../core/state.js';
 
 const execAsync = promisify(exec);
 
+// --- Git Helpers ---
+
+/**
+ * Get the current git branch name
+ * @param {string} cwd - Working directory
+ * @returns {Promise<string>} Current branch name
+ */
+export async function getCurrentBranch(cwd = process.cwd()) {
+  const { stdout } = await execAsync('git branch --show-current', { cwd });
+  return stdout.trim();
+}
+
+/**
+ * Create and checkout a task branch from the current HEAD
+ * If branch already exists, just checkout.
+ * @param {string} taskId - Task ID (e.g. "SEC-007")
+ * @param {string} cwd - Working directory
+ * @returns {Promise<string>} Branch name
+ */
+export async function createTaskBranch(taskId, cwd = process.cwd()) {
+  const branch = `feat/${taskId}`;
+  try {
+    await execAsync(`git rev-parse --verify ${branch}`, { cwd });
+    // Branch 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 execAsync(`git reset --hard ${baseRef}`, { cwd });
+  } catch {
+    // Branch doesn't exist — create
+    await execAsync(`git checkout -b ${branch}`, { cwd });
+  }
+  return branch;
+}
+
+/**
+ * Checkout an existing branch
+ * @param {string} branch - Branch name
+ * @param {string} cwd - Working directory
+ */
+export async function checkoutBranch(branch, cwd = process.cwd(), { force = false } = {}) {
+  const flag = force ? ' --force' : '';
+  await execAsync(`git checkout${flag} ${branch}`, { cwd });
+}
+
+/**
+ * Create a batch branch from the current HEAD
+ * @param {string} cwd - Working directory
+ * @returns {Promise<string>} Branch name (batch/{timestamp})
+ */
+export async function createBatchBranch(cwd = process.cwd()) {
+  const ts = new Date().toISOString().replace(/[:.]/g, '').slice(0, 15);
+  const branch = `batch/${ts}`;
+  await execAsync(`git checkout -b ${branch}`, { cwd });
+  return branch;
+}
+
+/**
+ * Merge a source branch into the current branch
+ * @param {string} source - Source branch name
+ * @param {string} cwd - Working directory
+ */
+export async function mergeBranch(source, cwd = process.cwd()) {
+  await execAsync(`git merge ${source} --no-edit`, { cwd });
+}
+
 /**
  * Default batch configuration
  */