jettypod 4.4.46 → 4.4.48

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.46",
+  "version": "4.4.48",
   "description": "AI-powered development workflow manager with TDD, BDD, and automatic test generation",
   "main": "jettypod.js",
   "bin": {

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

@@ -78,6 +78,14 @@ Implementation Plan:
 
 **Your task:** Create an isolated worktree for this chore.
 
+**🚫 FORBIDDEN: Manual Git Worktree Commands**
+```
+❌ git worktree add ...
+❌ git checkout -b feature/...
+❌ git branch feature/...
+```
+**ALWAYS use `jettypod work start`** - it handles branch naming, path conventions, database tracking, and cleanup. Manual git commands will create orphaned worktrees that break the merge workflow.
+
 ```bash
 jettypod work start [chore-id]
 ```

package/skills-templates/feature-planning/SKILL.md

@@ -588,6 +588,14 @@ Now I'll write the BDD tests in an isolated worktree...
 
 **CRITICAL:** Tests are written in an isolated worktree, not directly on main. This ensures agent failures don't leave uncommitted garbage on main.
 
+**🚫 FORBIDDEN: Manual Git Worktree Commands**
+```
+❌ git worktree add ...
+❌ git checkout -b tests/...
+❌ git branch tests/...
+```
+**ALWAYS use jettypod commands** - they handle branch naming, path conventions, database tracking, and cleanup. Manual git commands will create orphaned worktrees that break the merge workflow.
+
 **Sub-step 1: Create test worktree**
 
 ```bash
@@ -756,6 +764,14 @@ End feature-planning skill without starting a chore. Do NOT invoke speed-mode.
 
 **After user picks a chore, execute these steps IN ORDER:**
 
+**🚫 FORBIDDEN: Manual Git Worktree Commands**
+```
+❌ git worktree add ...
+❌ git checkout -b feature/...
+❌ git branch feature/...
+```
+**ALWAYS use `jettypod work start`** - it handles branch naming, path conventions, database tracking, and cleanup. Manual git commands will create orphaned worktrees that break the merge workflow.
+
 **Step 1: Start the chore (creates worktree and branch):**
 ```bash
 jettypod work start [chore-id]

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

@@ -629,6 +629,14 @@ After merge, you are on main branch. Ready to generate stable mode scenarios.
 
 **1. Create a test worktree for writing stable mode scenarios:**
 
+**🚫 FORBIDDEN: Manual Git Worktree Commands**
+```
+❌ git worktree add ...
+❌ git checkout -b tests/...
+❌ git branch tests/...
+```
+**ALWAYS use jettypod commands** - they handle branch naming, path conventions, database tracking, and cleanup. Manual git commands will create orphaned worktrees that break the merge workflow.
+
 ```bash
 jettypod work tests <feature-id>
 ```

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

@@ -72,6 +72,14 @@ sqlite3 .jettypod/work.db "SELECT wi.id, wi.title, wi.status, wt.worktree_path,
 
 **🛑 STOP GATE:** If `worktree_path` is NULL or no rows returned, you MUST run `jettypod work start [chore-id]` before continuing. DO NOT proceed without a valid worktree.
 
+**🚫 FORBIDDEN: Manual Git Worktree Commands**
+```
+❌ git worktree add ...
+❌ git checkout -b feature/...
+❌ git branch feature/...
+```
+**ALWAYS use `jettypod work start`** - it handles branch naming, path conventions, database tracking, and cleanup. Manual git commands will create orphaned worktrees that break the merge workflow.
+
 **Example of valid output:**
 ```
 4|Add error handling|in_progress|/Users/erik/project/.jettypod-work/4-add-error-handling|feature/work-4-add-error-handling