jettypod 3.0.2 → 4.0.0

package/features/step_definitions/backlog-command.steps.js

@@ -0,0 +1,37 @@
+const { Given, Then } = require('@cucumber/cucumber');
+
+// Test data setup
+Given('I have work items in various statuses', async function () {
+  // Speed mode will implement: Create test work items with different statuses
+  // (backlog, todo, in_progress, done, cancelled)
+  this.testWorkItems = null; // Placeholder for speed mode
+});
+
+// Output assertions
+Then('I see only active work items \\(backlog, todo, in_progress)', function () {
+  // Speed mode will implement: Parse output and verify only active items shown
+  // Check output contains items with status: backlog, todo, in_progress
+  // Check output does NOT contain items with status: done, cancelled
+});
+
+Then('I see all work items regardless of status', function () {
+  // Speed mode will implement: Parse output and verify all items shown
+  // Check output contains items with all statuses
+});
+
+Then('I see only completed work items \\(done, cancelled)', function () {
+  // Speed mode will implement: Parse output and verify only completed items shown
+  // Check output contains items with status: done, cancelled
+  // Check output does NOT contain items with status: backlog, todo, in_progress
+});
+
+Then('I see the items in a tree hierarchy', function () {
+  // Speed mode will implement: Verify tree structure in output
+  // Check for indentation or tree symbols (├──, └──, etc.)
+  // Check parent-child relationships are preserved
+});
+
+Then('completed items are hidden', function () {
+  // Speed mode will implement: Verify no completed items in output
+  // Check output does NOT contain items with status: done, cancelled
+});

package/features/work-commands/index.js

@@ -163,7 +163,7 @@ function startWork(id) {
         console.log('');
         console.log('💬 Claude Code is ready to guide you through feature discovery.');
         console.log('');
-        console.log('📋 The feature-discover skill will automatically activate.');
+        console.log('📋 The feature-planning skill will automatically activate.');
         console.log('');
       }
 
@@ -279,14 +279,21 @@ function stopWork(newStatus = null) {
           return reject(new Error(`Database error: ${err.message}`));
         }
 
-        try {
-          clearCurrentWork();
-        } catch (unlinkErr) {
-          return reject(new Error(`Failed to remove current work file: ${unlinkErr.message}`));
-        }
+        // Check if this completes all stable mode chores for the parent feature
+        checkStableModeCompletion(db, currentWork, newStatus, (completionErr) => {
+          if (completionErr) {
+            console.warn(`Warning: ${completionErr.message}`);
+          }
+
+          try {
+            clearCurrentWork();
+          } catch (unlinkErr) {
+            return reject(new Error(`Failed to remove current work file: ${unlinkErr.message}`));
+          }
 
-        console.log(`Stopped work on #${currentWork.id}, status set to ${newStatus}`);
-        resolve({ id: currentWork.id, status: newStatus });
+          console.log(`Stopped work on #${currentWork.id}, status set to ${newStatus}`);
+          resolve({ id: currentWork.id, status: newStatus });
+        });
       });
     } else {
       try {
@@ -301,6 +308,183 @@ function stopWork(newStatus = null) {
   });
 }
 
+/**
+ * Check if stable mode is complete for a feature and trigger production chore generation
+ * @param {Object} db - Database connection
+ * @param {Object} currentWork - Current work item that was just completed
+ * @param {string} newStatus - Status that was just set
+ * @param {Function} callback - Callback function
+ */
+async function checkStableModeCompletion(db, currentWork, newStatus, callback) {
+  // Only check if:
+  // 1. Current work is a chore
+  // 2. Status was just set to 'done'
+  // 3. Current work has a parent (feature)
+  if (currentWork.type !== 'chore' || newStatus !== 'done' || !currentWork.parent_id) {
+    return callback(null);
+  }
+
+  // Get parent feature details and check its mode
+  db.get(`
+    SELECT id, title, mode, type
+    FROM work_items
+    WHERE id = ?
+  `, [currentWork.parent_id], async (err, parent) => {
+    if (err) {
+      return callback(new Error(`Failed to get parent feature: ${err.message}`));
+    }
+
+    if (!parent) {
+      return callback(new Error(`Parent feature #${currentWork.parent_id} not found`));
+    }
+
+    // Only proceed if parent is a feature in stable mode
+    if (parent.type !== 'feature' || parent.mode !== 'stable') {
+      return callback(null);
+    }
+
+    // Check if all stable chores for this feature are done
+    db.get(`
+      SELECT COUNT(*) as incomplete_count
+      FROM work_items
+      WHERE parent_id = ?
+        AND type = 'chore'
+        AND mode = 'stable'
+        AND status != 'done'
+    `, [parent.id], async (countErr, result) => {
+      if (countErr) {
+        return callback(new Error(`Failed to check stable chore completion: ${countErr.message}`));
+      }
+
+      // If all stable chores are done, stable mode is complete
+      if (result.incomplete_count === 0) {
+        console.log('');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('✅ STABLE MODE COMPLETE');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('');
+        console.log(`All stable chores for feature #${parent.id} "${parent.title}" are done.`);
+        console.log('');
+
+        // Trigger production chore generation
+        try {
+          await generateAndConfirmProductionChores(parent);
+        } catch (genErr) {
+          console.error('Warning: Production chore generation failed:', genErr.message);
+        }
+      }
+
+      callback(null);
+    });
+  });
+}
+
+/**
+ * Generate production chores and get user confirmation
+ * @param {Object} feature - Feature object with id and title
+ */
+async function generateAndConfirmProductionChores(feature) {
+  const { analyzeImplementation, generateProductionChores } = require('../../lib/production-chore-generator');
+  const readline = require('readline');
+
+  console.log('🔍 Analyzing implementation for production gaps...');
+  console.log('');
+
+  // Analyze implementation
+  let analysisResult;
+  try {
+    analysisResult = await analyzeImplementation(feature.id);
+  } catch (analysisErr) {
+    console.error(`Failed to analyze implementation: ${analysisErr.message}`);
+    return;
+  }
+
+  // Display warning if no git commits found
+  if (analysisResult.warning) {
+    console.log(`⚠️  ${analysisResult.warning}`);
+    console.log('');
+  }
+
+  console.log(`✅ Analyzed ${analysisResult.filesAnalyzed.length} implementation files`);
+  console.log('');
+
+  // Generate production chore proposals
+  const proposedChores = generateProductionChores(analysisResult, feature.title);
+
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('📋 PROPOSED PRODUCTION CHORES');
+  console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+  console.log('');
+  console.log('These production chores will be created:');
+  console.log('');
+
+  proposedChores.forEach((chore, index) => {
+    console.log(`${index + 1}. ${chore.title}`);
+    console.log(`   ${chore.description.split('\n')[0]}`);
+    console.log('');
+  });
+
+  // Get user confirmation
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    rl.question('Create these production chores? (yes/skip): ', async (answer) => {
+      rl.close();
+
+      const response = answer.trim().toLowerCase();
+
+      if (response === 'yes' || response === 'y') {
+        console.log('');
+        console.log('Creating production chores...');
+
+        try {
+          await createProductionChoresAndElevate(feature, proposedChores);
+          console.log('');
+          console.log(`✅ Created ${proposedChores.length} production chores. Feature elevated to production mode.`);
+          console.log('');
+        } catch (createErr) {
+          console.error(`Failed to create production chores: ${createErr.message}`);
+        }
+      } else {
+        console.log('');
+        console.log('⏭️  Skipped production chore creation');
+        console.log('   You can generate them later by talking to Claude Code');
+        console.log('');
+      }
+
+      resolve();
+    });
+  });
+}
+
+/**
+ * Create production chores and elevate feature to production mode (if external)
+ * @param {Object} feature - Feature object
+ * @param {Array} proposedChores - Array of chore proposals
+ */
+async function createProductionChoresAndElevate(feature, proposedChores) {
+  const { create } = require('../work-tracking');
+  const projectConfig = config.read();
+
+  // Create production chores
+  for (const chore of proposedChores) {
+    await create('chore', chore.title, chore.description, feature.id, 'production', false);
+  }
+
+  // Always elevate feature to production mode
+  // (Feature #611 controls visibility in backlog, not mode elevation)
+  const db = getDb();
+  await new Promise((resolve, reject) => {
+    db.run('UPDATE work_items SET mode = ? WHERE id = ?', ['production', feature.id], (err) => {
+      if (err) return reject(err);
+      resolve();
+    });
+  });
+}
+
 // Re-export getCurrentWork from shared module for backwards compatibility
 // (used by jettypod.js)
 

package/features/work-commands/simple-steps.js

@@ -22,19 +22,19 @@ Given('I have initialized jettypod', function () {
   execSync('git init', { stdio: 'pipe' });
   execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
   execSync('git config user.name "Test"', { stdio: 'pipe' });
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
 });
 
 Given('I create an epic with id {int}', function (id) {
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create epic "Test Epic"`, { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create epic "Test Epic"`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
 });
 
 Given('I create a feature with id {int} under epic {int}', function (featureId, epicId) {
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create feature "Test Feature" "" --parent=${epicId}`, { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create feature "Test Feature" "" --parent=${epicId}`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
 });
 
 When('I start work on item {int}', function (id) {
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} work start ${id}`, { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work start ${id}`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
 });
 
 Then('the current work file exists', function () {
@@ -51,7 +51,7 @@ Then('the current work contains item {int}', function (id) {
 Then('item {int} status is in_progress or backlog', function (id) {
   // Use CLI to check status to avoid database connection issues
   try {
-    const output = execSync(`node ${path.join(originalDir, 'jettypod.js')} work show ${id}`, { encoding: 'utf-8' });
+    const output = execSync(`node ${path.join(originalDir, 'jettypod.js')} work show ${id}`, { encoding: 'utf-8', env: { ...process.env, NODE_ENV: 'test' } });
     const statusMatch = output.match(/Status:\s+(\w+)/);
     if (!statusMatch) {
       throw new Error('Could not find status in output');

package/features/work-commands/steps.js

@@ -601,9 +601,9 @@ Given('I create a feature {string} with mode {string} and parent epic', function
   }
 });
 
-When('I view the work tree', function() {
+When('I view the backlog', function() {
   testContext.lastOutput = execSync(
-    `node ${path.join(__dirname, '../../jettypod.js')} work tree`,
+    `node ${path.join(__dirname, '../../jettypod.js')} backlog`,
     { cwd: testDir, encoding: 'utf-8' }
   );
 });