jettypod 4.4.47 → 4.4.49

package/jettypod.js

@@ -1304,21 +1304,67 @@ switch (command) {
         process.exit(1);
       }
     } else if (subcommand === 'tests') {
-      // Create worktree for writing BDD tests
-      const featureId = parseInt(args[1]);
-      if (!featureId) {
-        console.log('Usage: jettypod work tests <feature-id>');
-        console.log('');
-        console.log('Creates a worktree for writing BDD tests for a feature.');
-        console.log('Tests are written in isolation, then merged with: jettypod work merge');
-        process.exit(1);
-      }
+      // Handle: work tests <feature-id> OR work tests merge <feature-id>
       const workCommands = require('./lib/work-commands/index.js');
-      try {
-        await workCommands.testsWork(featureId);
-      } catch (err) {
-        console.error(`Error: ${err.message}`);
-        process.exit(1);
+
+      if (args[1] === 'merge') {
+        // work tests merge <feature-id>
+        const featureId = parseInt(args[2]);
+        if (!featureId) {
+          console.log('Usage: jettypod work tests merge <feature-id>');
+          console.log('');
+          console.log('Merges a test worktree back to main and cleans up.');
+          console.log('');
+          console.log('This command:');
+          console.log('  1. Verifies all changes are committed');
+          console.log('  2. Merges the test branch to main');
+          console.log('  3. Pushes to remote');
+          console.log('  4. Removes the worktree');
+          console.log('  5. Deletes the test branch');
+          process.exit(1);
+        }
+        try {
+          await workCommands.testsMerge(featureId);
+        } catch (err) {
+          console.error(`Error: ${err.message}`);
+          process.exit(1);
+        }
+      } else if (args[1] === 'start') {
+        // work tests start <feature-id> (alias for work tests <feature-id>)
+        const featureId = parseInt(args[2]);
+        if (!featureId) {
+          console.log('Usage: jettypod work tests start <feature-id>');
+          console.log('');
+          console.log('Creates a worktree for writing BDD tests for a feature.');
+          console.log('Tests are written in isolation, then merged with: jettypod work tests merge <feature-id>');
+          process.exit(1);
+        }
+        try {
+          await workCommands.testsWork(featureId);
+        } catch (err) {
+          console.error(`Error: ${err.message}`);
+          process.exit(1);
+        }
+      } else {
+        // work tests <feature-id> (create worktree)
+        const featureId = parseInt(args[1]);
+        if (!featureId) {
+          console.log('Usage: jettypod work tests <feature-id>');
+          console.log('       jettypod work tests start <feature-id>');
+          console.log('       jettypod work tests merge <feature-id>');
+          console.log('');
+          console.log('Commands:');
+          console.log('  work tests <id>       Create a worktree for writing BDD tests');
+          console.log('  work tests start <id> Same as above (explicit alias)');
+          console.log('  work tests merge <id> Merge test worktree to main and clean up');
+          process.exit(1);
+        }
+        try {
+          await workCommands.testsWork(featureId);
+        } catch (err) {
+          console.error(`Error: ${err.message}`);
+          process.exit(1);
+        }
       }
     } else {
       // CRITICAL SAFETY CHECK: Prevent work status changes from within a worktree

package/lib/work-commands/index.js

@@ -1700,11 +1700,196 @@ async function testsWork(featureId) {
   });
 }
 
+/**
+ * Merge a test worktree back to main and clean up
+ * @param {number} featureId - Feature ID whose test worktree to merge
+ * @returns {Promise<void>}
+ */
+async function testsMerge(featureId) {
+  if (!featureId || isNaN(featureId) || featureId < 1) {
+    return Promise.reject(new Error('Invalid feature ID'));
+  }
+
+  // CRITICAL: Refuse to run from inside a worktree
+  const cwd = process.cwd();
+  if (cwd.includes('.jettypod-work')) {
+    const mainRepo = getGitRoot();
+    console.error('❌ Cannot merge from inside a worktree.');
+    console.error('');
+    console.error('   The merge will delete this worktree, breaking your shell session.');
+    console.error('');
+    console.error('   Run from the main repository instead:');
+    console.error(`   cd ${mainRepo}`);
+    console.error(`   jettypod work tests merge ${featureId}`);
+    return Promise.reject(new Error('Cannot merge from inside a worktree'));
+  }
+
+  const db = getDb();
+  const gitRoot = getGitRoot();
+
+  // Find the test worktree for this feature (branch starts with tests/feature-)
+  const worktree = await new Promise((resolve, reject) => {
+    db.get(
+      `SELECT * FROM worktrees
+       WHERE work_item_id = ?
+       AND branch_name LIKE 'tests/feature-%'
+       AND status = 'active'`,
+      [featureId],
+      (err, row) => {
+        if (err) return reject(err);
+        resolve(row);
+      }
+    );
+  });
+
+  if (!worktree) {
+    return Promise.reject(new Error(
+      `No active test worktree found for feature #${featureId}.\n\n` +
+      `Create one with: jettypod work tests ${featureId}`
+    ));
+  }
+
+  const worktreePath = worktree.worktree_path;
+  const branchName = worktree.branch_name;
+
+  console.log(`⏳ Merging test worktree for feature #${featureId}...`);
+  console.log(`   Branch: ${branchName}`);
+  console.log(`   Path: ${worktreePath}`);
+
+  // Check for uncommitted changes in the worktree
+  try {
+    const status = execSync('git status --porcelain', {
+      cwd: worktreePath,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    }).trim();
+
+    if (status) {
+      return Promise.reject(new Error(
+        `Uncommitted changes in test worktree:\n${status}\n\n` +
+        `Commit your changes first:\n` +
+        `  cd ${worktreePath}\n` +
+        `  git add .\n` +
+        `  git commit -m "Add BDD tests for feature #${featureId}"`
+      ));
+    }
+  } catch (err) {
+    return Promise.reject(new Error(`Failed to check worktree status: ${err.message}`));
+  }
+
+  // Check if there are commits to merge
+  try {
+    const mainBranch = execSync('git symbolic-ref refs/remotes/origin/HEAD', {
+      cwd: gitRoot,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    }).trim().replace('refs/remotes/origin/', '');
+
+    const commitCount = execSync(`git rev-list --count ${mainBranch}..${branchName}`, {
+      cwd: gitRoot,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    }).trim();
+
+    if (commitCount === '0') {
+      console.log('⚠️  No commits to merge - worktree has no new changes');
+    }
+  } catch (err) {
+    // Non-fatal - proceed anyway
+    console.log('⚠️  Could not check commit count, proceeding with merge');
+  }
+
+  // Merge the test branch to main
+  try {
+    // First, ensure we're on main
+    execSync('git checkout main', {
+      cwd: gitRoot,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+
+    // Merge the test branch
+    execSync(`git merge ${branchName} --no-ff -m "Merge BDD tests for feature #${featureId}"`, {
+      cwd: gitRoot,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+
+    console.log('✅ Merged test branch to main');
+  } catch (err) {
+    return Promise.reject(new Error(
+      `Merge failed: ${err.message}\n\n` +
+      `Resolve conflicts manually, then run:\n` +
+      `  jettypod work tests merge ${featureId}`
+    ));
+  }
+
+  // Push to remote
+  try {
+    execSync('git push', {
+      cwd: gitRoot,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+    console.log('✅ Pushed to remote');
+  } catch (err) {
+    console.log('⚠️  Failed to push (non-fatal):', err.message);
+  }
+
+  // Clean up the worktree
+  try {
+    execSync(`git worktree remove "${worktreePath}" --force`, {
+      cwd: gitRoot,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+    console.log('✅ Removed worktree directory');
+  } catch (err) {
+    console.log('⚠️  Failed to remove worktree (non-fatal):', err.message);
+  }
+
+  // Delete the test branch
+  try {
+    execSync(`git branch -d ${branchName}`, {
+      cwd: gitRoot,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+    console.log('✅ Deleted test branch');
+  } catch (err) {
+    console.log('⚠️  Failed to delete branch (non-fatal):', err.message);
+  }
+
+  // Update worktree status in database
+  await new Promise((resolve, reject) => {
+    db.run(
+      `UPDATE worktrees SET status = 'merged' WHERE id = ?`,
+      [worktree.id],
+      (err) => {
+        if (err) return reject(err);
+        resolve();
+      }
+    );
+  });
+
+  // Clear current work if it was pointing to this worktree
+  const currentWork = getCurrentWorkSync();
+  if (currentWork && currentWork.worktreePath === worktreePath) {
+    clearCurrentWork();
+  }
+
+  console.log('');
+  console.log(`✅ Test worktree for feature #${featureId} merged successfully`);
+
+  return Promise.resolve();
+}
+
 module.exports = {
   startWork,
   stopWork,
   getCurrentWork,
   cleanupWorktrees,
   mergeWork,
-  testsWork
+  testsWork,
+  testsMerge
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jettypod",
-  "version": "4.4.47",
+  "version": "4.4.49",
   "description": "AI-powered development workflow manager with TDD, BDD, and automatic test generation",
   "main": "jettypod.js",
   "bin": {

package/skills-templates/speed-mode/SKILL.md

@@ -692,7 +692,7 @@ Added error handling and edge case scenarios for stable mode.
 
 # Return to main repo and merge
 cd <main-repo-path>
-jettypod work merge <feature-id>
+jettypod work tests merge <feature-id>
 ```
 
 **7. Present proposal to user:**
@@ -848,8 +848,8 @@ jettypod work start <chore-id>   # Create worktree and start chore
 
 **Create test worktree (for writing BDD scenarios):**
 ```bash
-jettypod work tests <feature-id>  # Create worktree for writing tests
-jettypod work merge <feature-id>  # Merge tests back to main
+jettypod work tests <feature-id>        # Create worktree for writing tests
+jettypod work tests merge <feature-id>  # Merge tests back to main
 ```
 
 **Set feature mode (BEFORE creating chores):**