jettypod 4.3.0 → 4.4.1

package/lib/worktree-manager.js

@@ -14,6 +14,9 @@
 // Database will be required lazily when implementing actual functions
 // const getDb = require('./database');
 
+// Safe delete module - ALWAYS use this for deletions
+const safeDelete = require('./safe-delete');
+
 /**
  * Valid worktree statuses
  */
@@ -44,9 +47,16 @@ async function createWorktree(workItem, options = {}) {
     return Promise.reject(new Error('SAFETY: repoPath must be explicitly provided to createWorktree'));
   }
 
+  // SAFETY CHECK 0: Verify we're not running from within a worktree
+  try {
+    safeDelete.ensureNotInWorktree();
+  } catch (err) {
+    return Promise.reject(err);
+  }
+
   const gitRoot = options.repoPath;
 
-  // SAFETY CHECK: Verify gitRoot is actually the main repository
+  // SAFETY CHECK 1: Verify gitRoot is actually the main repository
   try {
     const gitRootCheck = execSync('git rev-parse --show-toplevel', {
       cwd: gitRoot,
@@ -205,7 +215,11 @@ async function createWorktree(workItem, options = {}) {
           }
         } else {
           // It's a directory - remove it and create symlink
-          fs.rmSync(jettypodLink, { recursive: true, force: true });
+          // SAFETY: Use safe delete with gitRoot validation
+          const deleteResult = safeDelete.safeRmRecursive(jettypodLink, { gitRoot, force: true });
+          if (!deleteResult.success) {
+            throw new Error(`Failed to remove .jettypod directory: ${deleteResult.error}`);
+          }
           fs.symlinkSync(jettypodTarget, jettypodLink, 'dir');
         }
       } else {
@@ -324,10 +338,10 @@ async function createWorktree(workItem, options = {}) {
 
     // Cleanup directory
     if (fs.existsSync(worktreePath)) {
-      try {
-        fs.rmSync(worktreePath, { recursive: true, force: true });
-      } catch (fsErr) {
-        console.error(`Failed to cleanup worktree directory: ${fsErr.message}`);
+      // SAFETY: Use safe delete with gitRoot validation
+      const deleteResult = safeDelete.safeRmRecursive(worktreePath, { gitRoot, force: true });
+      if (!deleteResult.success) {
+        console.error(`Failed to cleanup worktree directory: ${deleteResult.error}`);
       }
     }
 
@@ -478,12 +492,27 @@ async function removeDirectoryResilient(dirPath, gitRoot) {
   const fs = require('fs');
   const { execSync } = require('child_process');
 
+  // CRITICAL SAFETY: Validate path before ANY deletion attempt
+  const validation = safeDelete.validatePath(dirPath, gitRoot);
+  if (!validation.safe) {
+    throw new Error(`SAFETY: Cannot remove directory - ${validation.reason}`);
+  }
+
+  // Additional safety: Ensure dirPath is within .jettypod-work
+  const path = require('path');
+  const resolvedDir = path.resolve(dirPath);
+  const worktreeBase = path.resolve(gitRoot, '.jettypod-work');
+  if (!resolvedDir.startsWith(worktreeBase)) {
+    throw new Error(`SAFETY: Can only remove directories within .jettypod-work/. Got: ${dirPath}`);
+  }
+
   // Stage 1: Try standard git worktree remove (silent)
   try {
     execSync(`git worktree remove "${dirPath}"`, {
       cwd: gitRoot,
       stdio: 'pipe'
     });
+    safeDelete.logDeletion(dirPath, 'git-worktree-remove', true);
     return; // Success - exit silently
   } catch (stage1Err) {
     // Stage 1 failed - escalate with logging
@@ -497,16 +526,18 @@ async function removeDirectoryResilient(dirPath, gitRoot) {
       stdio: 'pipe'
     });
     console.log(`✓ Forced git removal succeeded`);
+    safeDelete.logDeletion(dirPath, 'git-worktree-remove-force', true);
     return;
   } catch (stage2Err) {
-    console.log(`⚠️  Forced git removal failed, escalating to filesystem removal...`);
+    console.log(`⚠️  Forced git removal failed, escalating to safe filesystem removal...`);
   }
 
-  // Stage 3: Try filesystem removal with force
+  // Stage 3: Try SAFE filesystem removal (validates path again)
   if (fs.existsSync(dirPath)) {
-    try {
-      fs.rmSync(dirPath, { recursive: true, force: true });
-      console.log(`✓ Filesystem removal succeeded`);
+    const deleteResult = safeDelete.safeRmRecursive(dirPath, { gitRoot, force: true });
+
+    if (deleteResult.success) {
+      console.log(`✓ Safe filesystem removal succeeded`);
 
       // Clean up git metadata
       try {
@@ -515,25 +546,14 @@ async function removeDirectoryResilient(dirPath, gitRoot) {
         // Non-fatal
       }
       return;
-    } catch (stage3Err) {
-      console.log(`⚠️  Filesystem removal failed, escalating to manual deletion...`);
+    } else {
+      console.log(`⚠️  Safe filesystem removal failed: ${deleteResult.error}`);
+      throw new Error(`Directory removal failed: ${deleteResult.error}`);
     }
   }
 
-  // Stage 4: Manual recursive deletion (last resort)
-  try {
-    await manualRecursiveDelete(dirPath);
-    console.log(`✓ Manual recursive deletion succeeded`);
-
-    // Clean up git metadata
-    try {
-      execSync('git worktree prune', { cwd: gitRoot, stdio: 'pipe' });
-    } catch (pruneErr) {
-      // Non-fatal
-    }
-  } catch (stage4Err) {
-    throw new Error(`All removal strategies failed: ${stage4Err.message}`);
-  }
+  // If we get here, directory doesn't exist - that's fine
+  console.log(`✓ Directory already removed or doesn't exist`);
 }
 
 /**
@@ -566,21 +586,14 @@ async function cleanupWorktree(worktreeId, options = {}) {
   const db = options.db || getDb();
   const deleteBranch = options.deleteBranch || false;
 
-  // SAFETY CHECK 1: Verify we're not running from within a worktree
-  try {
-    const currentGitDir = execSync('git rev-parse --git-dir', {
-      cwd: process.cwd(),
-      encoding: 'utf8'
-    }).trim();
-
-    if (currentGitDir.includes('.jettypod-work') || currentGitDir !== '.git') {
-      return Promise.reject(new Error('SAFETY: Cannot run cleanup from within a worktree'));
-    }
-  } catch (err) {
-    // Ignore - might not be in a git repo
-  }
+  // NOTE: We intentionally do NOT check ensureNotInWorktree() here.
+  // The merge workflow (jettypod work merge) is designed to be run from
+  // within the worktree being merged. Safety comes from:
+  // 1. Requiring explicit repoPath (not relying on process.cwd())
+  // 2. Verifying repoPath is the main repo (check below)
+  // 3. Path validation in removeDirectoryResilient()
 
-  // SAFETY CHECK 2: Verify gitRoot is actually the main repository
+  // SAFETY CHECK: Verify gitRoot is actually the main repository
   try {
     const gitRootCheck = execSync('git rev-parse --show-toplevel', {
       cwd: gitRoot,

package/package.json

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

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

@@ -0,0 +1,396 @@
+---
+name: chore-mode
+description: Guide implementation of standalone chores with type-appropriate guidance, verification steps, and test handling. Receives enriched context from chore-planning and executes with iteration until verification passes.
+---
+
+# Chore Mode Skill
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│  Standalone Chore Execution                                         │
+│                                                                      │
+│  chore-planning → [CHORE MODE] → Done                               │
+│                    ▲▲▲▲▲▲▲▲▲▲▲                                      │
+│                    YOU ARE HERE                                      │
+│                                                                      │
+│  Chores are focused tasks - no speed/stable/production progression. │
+│  Execute once with type-appropriate verification, then done.        │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+Guides Claude Code through chore execution with type-specific guidance, test handling, and verification criteria from the chore taxonomy.
+
+## Instructions
+
+When this skill is activated, you are executing a standalone chore. The chore-planning skill has already classified the type and built enriched context. Follow this structured approach:
+
+### Overview
+
+**Chore Mode Goal:** Execute the chore according to type-specific guidance and verify completion using taxonomy criteria.
+
+**Key Principles:**
+- **Type-aware execution** - Different chore types have different test handling and verification
+- **Guided verification** - Use taxonomy verification checklist, not arbitrary checks
+- **Iteration with limits** - Max 5 iterations to achieve verification
+- **No mode progression** - Chores don't have speed/stable/production phases
+
+**Chore Types Quick Reference:**
+
+| Type | Test Handling | Key Constraint |
+|------|---------------|----------------|
+| refactor | Affected tests only | Do NOT modify test assertions |
+| dependency | Full test suite | Check for deprecation warnings |
+| cleanup | Affected tests | Verify code is actually unused |
+| tooling | CI/manual verification | Focus on verification over unit tests |
+
+---
+
+## Implementation Steps
+
+### Step 1: Receive and Display Context
+
+**Your task:** Acknowledge the context passed from chore-planning.
+
+You will receive:
+- `choreContext.chore` - Chore ID, title, description
+- `choreContext.classification` - Type and confidence
+- `choreContext.guidance` - Scope, verification, testHandling from taxonomy
+- `choreContext.implementationPlan` - Files to modify, affected tests
+
+**Display:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔧 Chore Mode: [Chore Title]
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Type: [TYPE] (confidence: [high/medium/low])
+Chore ID: #[id]
+
+Implementation Plan:
+• Files to modify: [list from context]
+• Affected tests: [list from context]
+```
+
+**Move to Step 2 automatically.**
+
+### Step 2: Create Worktree
+
+**Your task:** Create an isolated worktree for this chore.
+
+```bash
+jettypod work start [chore-id]
+```
+
+This creates a worktree at `.jettypod-work/[id]-[title-slug]` and switches to a new branch.
+
+**Display:**
+
+```
+📁 Worktree created: .jettypod-work/[id]-[title-slug]
+Branch: chore-[id]-[title-slug]
+```
+
+**Move to Step 3 automatically.**
+
+### Step 3: Establish Test Baseline
+
+**Your task:** Run tests to establish baseline before making changes.
+
+**Test handling varies by type:**
+
+**For REFACTOR:**
+```bash
+# Run only affected module tests
+npm test -- [affected-test-patterns]
+```
+
+**For DEPENDENCY:**
+```bash
+# Run full test suite
+npm test
+```
+
+**For CLEANUP:**
+```bash
+# Run affected tests
+npm test -- [affected-test-patterns]
+```
+
+**For TOOLING:**
+```bash
+# Run CI pipeline or specific verification
+# (may not have unit tests)
+```
+
+**Display:**
+
+```
+🧪 Establishing test baseline...
+
+Baseline Result:
+  Tests: [X] passing / [Y] total
+  Execution time: [Z]s
+
+✅ Baseline established - all tests passing
+```
+
+**CRITICAL:** If baseline tests fail, STOP. Fix existing failures before proceeding with chore work.
+
+**Move to Step 4 automatically.**
+
+### Step 4: Display Type-Specific Guidance
+
+**Your task:** Display warnings and constraints based on chore type.
+
+**Load guidance from taxonomy:**
+
+```javascript
+const { getGuidance } = require('./lib/chore-taxonomy');
+const guidance = getGuidance('[chore-type]');
+```
+
+**Display type-specific warnings:**
+
+**For REFACTOR:**
+```
+⚠️  REFACTOR CONSTRAINTS:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+• All existing tests MUST pass WITHOUT modification
+• If tests fail, the refactor broke behavior - FIX THE CODE, not the tests
+• No new functionality - this is restructuring only
+• Behavior must be preserved exactly
+```
+
+**For DEPENDENCY:**
+```
+⚠️  DEPENDENCY CONSTRAINTS:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+• Run FULL test suite to catch regressions
+• Check for deprecation warnings after update
+• Review changelog for breaking changes
+• Update code if API changed
+```
+
+**For CLEANUP:**
+```
+⚠️  CLEANUP CONSTRAINTS:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+• VERIFY code is actually unused before deleting
+• Search for all references (grep for function names)
+• Remove tests ONLY if they test deleted code
+• Check for dynamic references (string-based imports)
+```
+
+**For TOOLING:**
+```
+⚠️  TOOLING CONSTRAINTS:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+• Verify via CI run or manual testing
+• Focus on verification over unit testing
+• Document current behavior before changes
+• Plan rollback strategy
+```
+
+**Move to Step 5 automatically.**
+
+### Step 5: Execute with Iteration
+
+**Your task:** Make changes and iterate until tests pass. Max 5 iterations.
+
+```
+━━━ Iteration [N]/5 ━━━
+
+✍️  Making changes...
+[Describe what you're changing]
+
+🧪 Running tests...
+```
+
+**On each iteration:**
+1. Make focused changes based on implementation plan
+2. Run appropriate tests (type-dependent)
+3. Check results
+
+**Display progress:**
+
+```
+📊 Progress: [X]/[Y] tests passing
+
+✅ Newly passing:
+  • [test name]
+
+❌ Still failing:
+  • [test name]: [brief error]
+
+🔧 Next: [what you'll fix]
+```
+
+**Exit conditions:**
+- ✅ All tests pass → Move to Step 6
+- ❌ Max iterations reached → Display failure, ask user for guidance
+
+**On max iterations:**
+
+```
+⚠️  Maximum iterations (5) reached
+
+Final Progress: [X]/[Y] tests passing
+
+Still failing:
+  • [test name]: [error]
+
+Options:
+1. Review implementation approach
+2. Break into smaller changes
+3. Get user guidance
+
+What would you like to do?
+```
+
+**STOP and wait for user input if max iterations reached.**
+
+### Step 6: Run Verification Checklist
+
+**Your task:** Run through type-specific verification criteria from taxonomy.
+
+**Load verification from taxonomy:**
+
+```javascript
+const { getGuidance } = require('./lib/chore-taxonomy');
+const guidance = getGuidance('[chore-type]');
+// guidance.verification contains the checklist
+```
+
+**Display and verify each item:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔍 Verification Checklist
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+[✅/❌] All existing tests pass without modification
+[✅/❌] No new functionality added
+[✅/❌] Code review confirms behavior preservation
+[✅/❌] Performance is not degraded
+```
+
+**Verification methods:**
+- **Tests pass**: Run `npm test` and check exit code
+- **No new functionality**: Review diff for new features
+- **Behavior preservation**: Compare before/after behavior
+- **Performance**: Run benchmarks if applicable
+
+**If any verification fails:**
+
+```
+❌ Verification failed:
+  • [failed item]: [reason]
+
+Returning to iteration loop...
+```
+
+Go back to Step 5 to fix issues.
+
+**If all verification passes → Move to Step 7.**
+
+### Step 7: Complete and Merge
+
+**Your task:** Commit changes and merge to main.
+
+```bash
+# Stage and commit
+git add .
+git commit -m "chore: [brief description]"
+git push
+
+# Merge to main (auto-marks chore done)
+jettypod work merge
+```
+
+**Display:**
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+✅ Chore Complete
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Type: [TYPE]
+Iterations: [N]/5
+Tests: [X]/[Y] passing
+
+Verification:
+✅ All existing tests pass without modification
+✅ No new functionality added
+✅ Code review confirms behavior preservation
+✅ Performance is not degraded
+
+Merged to main. Chore #[id] marked done.
+```
+
+**End skill.**
+
+---
+
+## Error Handling
+
+### Baseline Tests Fail
+```
+❌ Cannot proceed - baseline tests failing
+
+[X] tests failing before chore work started.
+Fix existing test failures before proceeding.
+
+Failing tests:
+  • [test name]: [error]
+```
+
+### Verification Loop
+If verification fails repeatedly (3+ times on same item):
+```
+⚠️  Verification stuck on: [item]
+
+This has failed [N] times. Options:
+1. Review the implementation approach
+2. Check if this verification is applicable
+3. Ask user for guidance
+```
+
+### Worktree Issues
+```
+❌ Worktree creation failed
+
+Error: [message]
+
+Try:
+  jettypod work cleanup
+  jettypod work start [chore-id]
+```
+
+---
+
+## Type Reference
+
+### REFACTOR
+- **Goal:** Restructure code without changing behavior
+- **Tests:** Affected modules only
+- **Key rule:** NEVER modify test assertions
+- **Verification:** Tests pass, behavior unchanged
+
+### DEPENDENCY
+- **Goal:** Update packages safely
+- **Tests:** Full suite
+- **Key rule:** Check changelogs for breaking changes
+- **Verification:** Tests pass, no deprecation warnings
+
+### CLEANUP
+- **Goal:** Remove unused code
+- **Tests:** Affected modules
+- **Key rule:** Verify code is actually unused
+- **Verification:** No broken references, tests pass
+
+### TOOLING
+- **Goal:** Improve build/CI/dev tools
+- **Tests:** CI pipeline or manual
+- **Key rule:** Plan rollback strategy
+- **Verification:** CI passes, workflows work