jettypod 4.1.2 → 4.1.4

package/lib/worktree-reconciler.js

@@ -0,0 +1,429 @@
+/**
+ * Worktree Reconciler - State Reconciliation Engine
+ *
+ * This module detects and fixes inconsistencies between database, git, and
+ * filesystem state. It's the "self-healing" layer that ensures state never
+ * gets permanently corrupted.
+ *
+ * Four reconciliation scenarios:
+ * 1. Orphaned worktrees (git knows, DB doesn't)
+ * 2. Orphaned branches (branch exists, no worktree)
+ * 3. Stale database entries (DB has path, filesystem doesn't)
+ * 4. Git-filesystem mismatch (filesystem has dir, git doesn't know it)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+/**
+ * Reconcile all worktree state
+ *
+ * @param {Object} db - SQLite database connection
+ * @param {string} repoPath - Path to main git repository
+ * @param {Object} options - Reconciliation options
+ * @param {boolean} options.cleanup - Whether to attempt cleanup (default: false)
+ * @returns {Promise<Object>} Reconciliation results with detected issues and cleanup attempts
+ */
+async function reconcileState(db, repoPath, options = {}) {
+  const cleanup = options.cleanup || false;
+
+  const results = {
+    orphanedWorktrees: [],
+    orphanedBranches: [],
+    staleDbEntries: [],
+    gitFilesystemMismatches: [],
+    cleanupAttempts: {
+      orphanedWorktrees: 0,
+      orphanedBranches: 0,
+      staleDbEntries: 0,
+      gitFilesystemMismatches: 0
+    },
+    errors: [],
+    warnings: [],
+    gitCommands: []
+  };
+
+  // Scenario 1: Orphaned worktrees (git knows, DB doesn't)
+  try {
+    const orphanedResults = await detectOrphanedWorktrees(db, repoPath);
+    results.orphanedWorktrees = orphanedResults;
+
+    if (cleanup && orphanedResults.length > 0) {
+      for (const orphaned of orphanedResults) {
+        try {
+          await cleanupOrphanedWorktree(orphaned.path, repoPath);
+          results.cleanupAttempts.orphanedWorktrees++;
+        } catch (err) {
+          results.errors.push(`Failed to cleanup orphaned worktree ${orphaned.path}: ${err.message}`);
+        }
+      }
+    }
+  } catch (err) {
+    results.errors.push(`Orphaned worktree detection failed: ${err.message}`);
+  }
+
+  // Scenario 2: Orphaned branches (branch exists, no worktree)
+  try {
+    const orphanedBranches = await detectOrphanedBranches(db, repoPath);
+    results.orphanedBranches = orphanedBranches;
+
+    if (cleanup && orphanedBranches.length > 0) {
+      for (const branch of orphanedBranches) {
+        try {
+          const hasCommits = await branchHasCommits(branch.name, repoPath);
+          if (!hasCommits) {
+            await cleanupOrphanedBranch(branch.name, repoPath);
+            results.cleanupAttempts.orphanedBranches++;
+          } else {
+            results.warnings.push(`Branch ${branch.name} has commits - preserving it`);
+          }
+        } catch (err) {
+          results.errors.push(`Failed to cleanup orphaned branch ${branch.name}: ${err.message}`);
+        }
+      }
+    }
+  } catch (err) {
+    results.errors.push(`Orphaned branch detection failed: ${err.message}`);
+  }
+
+  // Scenario 3: Stale database entries (DB has path, filesystem doesn't)
+  try {
+    const staleEntries = await detectStaleDbEntries(db, repoPath);
+    results.staleDbEntries = staleEntries;
+
+    if (cleanup && staleEntries.length > 0) {
+      for (const entry of staleEntries) {
+        try {
+          await markWorktreeCorrupted(db, entry.id);
+          results.cleanupAttempts.staleDbEntries++;
+        } catch (err) {
+          results.errors.push(`Failed to mark stale entry as corrupted: ${err.message}`);
+        }
+      }
+
+      // Run git worktree prune
+      try {
+        execSync('git worktree prune', { cwd: repoPath, stdio: 'pipe' });
+        results.gitCommands.push('git worktree prune');
+      } catch (err) {
+        results.errors.push(`Failed to prune git worktrees: ${err.message}`);
+      }
+    }
+  } catch (err) {
+    results.errors.push(`Stale database entry detection failed: ${err.message}`);
+  }
+
+  // Scenario 4: Git-filesystem mismatch (filesystem has dir, git doesn't)
+  try {
+    const mismatches = await detectGitFilesystemMismatches(db, repoPath);
+    results.gitFilesystemMismatches = mismatches;
+
+    if (cleanup && mismatches.length > 0) {
+      for (const mismatch of mismatches) {
+        try {
+          await reregisterWorktree(mismatch, repoPath);
+          await updateWorktreeTimestamp(db, mismatch.id);
+          results.cleanupAttempts.gitFilesystemMismatches++;
+          results.gitCommands.push(`git worktree add --force`);
+        } catch (err) {
+          await markWorktreeCorrupted(db, mismatch.id);
+          results.errors.push(`Failed to re-register worktree ${mismatch.path}: ${err.message}`);
+        }
+      }
+    }
+  } catch (err) {
+    results.errors.push(`Git-filesystem mismatch detection failed: ${err.message}`);
+  }
+
+  return results;
+}
+
+/**
+ * Detect worktrees that git knows about but database doesn't track
+ */
+async function detectOrphanedWorktrees(db, repoPath) {
+  const orphaned = [];
+
+  // Get all git worktrees
+  const gitWorktrees = getGitWorktrees(repoPath);
+
+  // Check each against database
+  for (const worktree of gitWorktrees) {
+    const dbEntry = await new Promise((resolve, reject) => {
+      db.get('SELECT * FROM worktrees WHERE worktree_path = ?', [worktree.path], (err, row) => {
+        if (err) reject(err);
+        else resolve(row);
+      });
+    });
+
+    if (!dbEntry) {
+      orphaned.push({
+        path: worktree.path,
+        branch: worktree.branch
+      });
+    }
+  }
+
+  return orphaned;
+}
+
+/**
+ * Get all git worktrees from git worktree list
+ */
+function getGitWorktrees(repoPath) {
+  try {
+    const output = execSync('git worktree list --porcelain', {
+      cwd: repoPath,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+
+    const worktrees = [];
+    const lines = output.split('\n');
+    let currentWorktree = {};
+
+    for (const line of lines) {
+      if (line.startsWith('worktree ')) {
+        if (currentWorktree.path) {
+          worktrees.push(currentWorktree);
+        }
+        currentWorktree = { path: line.substring(9) };
+      } else if (line.startsWith('branch ')) {
+        currentWorktree.branch = line.substring(7).replace('refs/heads/', '');
+      }
+    }
+
+    if (currentWorktree.path) {
+      worktrees.push(currentWorktree);
+    }
+
+    // Normalize paths to resolve symlinks (e.g., /var -> /private/var on macOS)
+    const normalizedRepoPath = fs.existsSync(repoPath) ? fs.realpathSync(repoPath) : repoPath;
+
+    // Filter out main repository (not a worktree)
+    return worktrees.filter(w => {
+      const normalizedWorktreePath = fs.existsSync(w.path) ? fs.realpathSync(w.path) : w.path;
+      return normalizedWorktreePath !== normalizedRepoPath;
+    });
+  } catch (err) {
+    // If git worktree list fails, return empty array
+    return [];
+  }
+}
+
+/**
+ * Cleanup orphaned worktree
+ */
+async function cleanupOrphanedWorktree(worktreePath, repoPath) {
+  try {
+    execSync(`git worktree remove --force "${worktreePath}"`, {
+      cwd: repoPath,
+      stdio: 'pipe'
+    });
+  } catch (err) {
+    throw new Error(`Failed to remove worktree: ${err.message}`);
+  }
+}
+
+/**
+ * Detect feature branches that have no worktree
+ */
+async function detectOrphanedBranches(db, repoPath) {
+  const orphaned = [];
+
+  // Get all feature branches with work-* pattern
+  const branches = getFeatureBranches(repoPath);
+
+  // Get all tracked worktrees from database
+  const trackedBranches = await new Promise((resolve, reject) => {
+    db.all('SELECT branch_name FROM worktrees', (err, rows) => {
+      if (err) reject(err);
+      else resolve(rows.map(r => r.branch_name));
+    });
+  });
+
+  // Check each branch
+  for (const branchName of branches) {
+    if (!trackedBranches.includes(branchName)) {
+      // Extract work item ID from branch name (e.g., feature/work-123-title)
+      const match = branchName.match(/work-(\d+)-/);
+      const workItemId = match ? parseInt(match[1]) : null;
+
+      orphaned.push({
+        name: branchName,
+        workItemId
+      });
+    }
+  }
+
+  return orphaned;
+}
+
+/**
+ * Get all feature branches with work-* pattern
+ */
+function getFeatureBranches(repoPath) {
+  try {
+    const output = execSync('git branch', {
+      cwd: repoPath,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+
+    return output
+      .split('\n')
+      .map(line => line.trim().replace('* ', ''))
+      .filter(branch => branch.startsWith('feature/work-'));
+  } catch (err) {
+    return [];
+  }
+}
+
+/**
+ * Check if branch has commits beyond main
+ */
+async function branchHasCommits(branchName, repoPath) {
+  try {
+    const output = execSync(`git rev-list --count main..${branchName}`, {
+      cwd: repoPath,
+      encoding: 'utf8',
+      stdio: 'pipe'
+    });
+
+    const commitCount = parseInt(output.trim());
+    return commitCount > 0;
+  } catch (err) {
+    // If command fails, assume it has commits (safer to preserve)
+    return true;
+  }
+}
+
+/**
+ * Cleanup orphaned branch
+ */
+async function cleanupOrphanedBranch(branchName, repoPath) {
+  try {
+    execSync(`git branch -D ${branchName}`, {
+      cwd: repoPath,
+      stdio: 'pipe'
+    });
+  } catch (err) {
+    throw new Error(`Failed to delete branch: ${err.message}`);
+  }
+}
+
+/**
+ * Detect database entries where filesystem path doesn't exist
+ */
+async function detectStaleDbEntries(db, repoPath) {
+  const stale = [];
+
+  // Get all worktrees from database
+  const dbEntries = await new Promise((resolve, reject) => {
+    db.all('SELECT * FROM worktrees', (err, rows) => {
+      if (err) reject(err);
+      else resolve(rows);
+    });
+  });
+
+  // Check each entry
+  for (const entry of dbEntries) {
+    if (!fs.existsSync(entry.worktree_path)) {
+      stale.push({
+        id: entry.id,
+        path: entry.worktree_path,
+        workItemId: entry.work_item_id
+      });
+    }
+  }
+
+  return stale;
+}
+
+/**
+ * Mark worktree as corrupted in database
+ */
+async function markWorktreeCorrupted(db, worktreeId) {
+  return new Promise((resolve, reject) => {
+    db.run(
+      'UPDATE worktrees SET status = ?, updated_at = datetime(\'now\') WHERE id = ?',
+      ['corrupted', worktreeId],
+      (err) => {
+        if (err) reject(err);
+        else resolve();
+      }
+    );
+  });
+}
+
+/**
+ * Detect directories that exist but git doesn't track
+ */
+async function detectGitFilesystemMismatches(db, repoPath) {
+  const mismatches = [];
+
+  // Get all worktrees from database
+  const dbEntries = await new Promise((resolve, reject) => {
+    db.all('SELECT * FROM worktrees', (err, rows) => {
+      if (err) reject(err);
+      else resolve(rows);
+    });
+  });
+
+  // Get all git worktrees
+  const gitWorktrees = getGitWorktrees(repoPath);
+  const gitPaths = gitWorktrees.map(w => w.path);
+
+  // Check each database entry
+  for (const entry of dbEntries) {
+    const dirExists = fs.existsSync(entry.worktree_path);
+    const gitKnows = gitPaths.includes(entry.worktree_path);
+
+    if (dirExists && !gitKnows) {
+      mismatches.push({
+        id: entry.id,
+        path: entry.worktree_path,
+        branchName: entry.branch_name,
+        workItemId: entry.work_item_id
+      });
+    }
+  }
+
+  return mismatches;
+}
+
+/**
+ * Re-register worktree directory with git
+ */
+async function reregisterWorktree(mismatch, repoPath) {
+  try {
+    // Try to re-register the worktree with git
+    execSync(`git worktree add --force -b ${mismatch.branchName} "${mismatch.path}"`, {
+      cwd: repoPath,
+      stdio: 'pipe'
+    });
+  } catch (err) {
+    throw new Error(`Failed to re-register worktree: ${err.message}`);
+  }
+}
+
+/**
+ * Update worktree timestamp in database
+ */
+async function updateWorktreeTimestamp(db, worktreeId) {
+  return new Promise((resolve, reject) => {
+    db.run(
+      'UPDATE worktrees SET updated_at = datetime(\'now\') WHERE id = ?',
+      [worktreeId],
+      (err) => {
+        if (err) reject(err);
+        else resolve();
+      }
+    );
+  });
+}
+
+module.exports = {
+  reconcileState
+};

package/package.json

@@ -1,17 +1,40 @@
 {
   "name": "jettypod",
-  "version": "4.1.2",
-  "description": "Simplified development mode manager",
+  "version": "4.1.4",
+  "description": "AI-powered development workflow manager with TDD, BDD, and automatic test generation",
   "main": "jettypod.js",
   "bin": {
     "jettypod": "./jettypod.js"
   },
+  "keywords": [
+    "workflow",
+    "tdd",
+    "bdd",
+    "testing",
+    "ai-development",
+    "cucumber",
+    "jest",
+    "development-tools",
+    "test-automation",
+    "project-management"
+  ],
+  "author": "Erik Spangenberg",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/spangbaryn/jettypod-source.git"
+  },
+  "bugs": {
+    "url": "https://github.com/spangbaryn/jettypod-source/issues"
+  },
+  "homepage": "https://github.com/spangbaryn/jettypod-source#readme",
   "scripts": {
     "test": "npm run test:unit && npm run test:bdd && npm run test:cleanup",
     "test:bdd": "NODE_ENV=test cucumber-js",
     "test:unit": "NODE_ENV=test jest",
     "test:unit:watch": "NODE_ENV=test jest --watch",
-    "test:cleanup": "node -e \"const fs = require('fs'); const path = require('path'); const testDb = path.join(process.cwd(), '.jettypod', 'test-work.db'); if (fs.existsSync(testDb)) { fs.unlinkSync(testDb); console.log('✅ Cleaned up test database'); }\""
+    "test:cleanup": "node scripts/test-cleanup.js",
+    "prepublishOnly": "echo '🔄 Syncing skills to templates...' && cp -r .claude/skills/* skills-templates/ && echo '✅ Skills synced'"
   },
   "devDependencies": {
     "@cucumber/cucumber": "^10.0.1",
@@ -31,6 +54,10 @@
     "coverageDirectory": "coverage"
   },
   "dependencies": {
+    "chalk": "^4.1.2",
     "sqlite3": "^5.1.7"
+  },
+  "engines": {
+    "node": "22.x"
   }
 }

package/skills-templates/external-transition/SKILL.md

@@ -200,7 +200,29 @@ After user selects preset, ask 3-5 refinement questions to tailor standards:
 
 ### Step 5: Generate and Show Recommendations
 
-After collecting answers, use the `lib/production-standards-engine.js` to generate tailored standards, then show recommendations:
+After collecting answers, use the `lib/production-standards-engine.js` to generate tailored standards.
+
+**Execute this code:**
+
+```javascript
+const { generateStandards } = require('../../lib/production-standards-engine');
+
+// Build input from collected answers
+const input = {
+  preset: '[user-selected-preset]', // startup-mvp, production-saas, enterprise, or regulated
+  refinement: {
+    user_count: '[answer-from-question-2]',      // e.g., '100-1k'
+    downtime_impact: '[answer-from-question-3]',  // e.g., 'Users annoyed'
+    data_loss_impact: '[answer-from-question-4]', // e.g., 'Annoying'
+    sensitive_data: '[answer-from-question-5]'    // e.g., 'Passwords only'
+  }
+};
+
+// Generate standards
+const generatedStandards = generateStandards(input);
+```
+
+Then show recommendations to the user:
 
 ```
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -279,9 +301,18 @@ Allow user to toggle/adjust standards, then regenerate the summary.
 
 ### Step 7: Save Production Standards
 
-After user accepts, save standards to `.jettypod/production-standards.json` using the engine's output format.
+After user accepts, save standards to `.jettypod/production-standards.json`.
+
+**Execute this code:**
+
+```javascript
+const { saveStandards } = require('../../lib/production-standards-writer');
+
+// Save the generated standards from Step 5
+saveStandards(generatedStandards);
+```
 
-Confirm to user:
+Then confirm to user:
 
 ```
 ✅ Production standards saved to .jettypod/production-standards.json