jettypod 3.0.1

package/features/work-commands/index.js

@@ -0,0 +1,311 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const { getDb, getDbPath, getJettypodDir } = require('../../lib/database');
+const { getCurrentWork, setCurrentWork, clearCurrentWork, getCurrentWorkPath } = require('../../lib/current-work');
+const { VALID_STATUSES } = require('../../lib/constants');
+const { updateCurrentWork } = require('../../lib/claudemd');
+const { createFeatureBranchName, createOrCheckoutBranch } = require('../../lib/git');
+const config = require('../../lib/config');
+const { getBugWorkflowForTerminal } = require('../../lib/bug-workflow');
+
+/**
+ * Get paths to JettyPod files and directories
+ * @returns {Object} Paths object with jettypodDir, currentWorkPath, dbPath, claudePath
+ */
+function getPaths() {
+  return {
+    jettypodDir: getJettypodDir(),
+    currentWorkPath: getCurrentWorkPath(),
+    dbPath: getDbPath(),
+    claudePath: path.join(process.cwd(), 'CLAUDE.md')
+  };
+}
+
+/**
+ * Start work on a work item
+ * @param {number} id - Work item ID to start
+ * @returns {Promise<Object>} Work item, current work, and branch name
+ * @throws {Error} If ID is invalid, JettyPod not initialized, database missing, or work item not found
+ */
+function startWork(id) {
+  // Input validation
+  if (!id || isNaN(id) || id < 1) {
+    return Promise.reject(new Error('Invalid work item ID'));
+  }
+
+  const paths = getPaths();
+
+  // Check jettypod directory exists
+  if (!fs.existsSync(paths.jettypodDir)) {
+    return Promise.reject(new Error('JettyPod not initialized. Run: jettypod init'));
+  }
+
+  // Check database exists
+  if (!fs.existsSync(paths.dbPath)) {
+    return Promise.reject(new Error('Work database not found. Run: jettypod init'));
+  }
+
+  const db = getDb();
+
+  return new Promise((resolve, reject) => {
+    // Get work item
+    db.get(`
+      SELECT w.*,
+             p.title as parent_title, p.id as parent_id, p.scenario_file as parent_scenario_file, p.mode as parent_mode,
+             e.title as epic_title, e.id as epic_id
+      FROM work_items w
+      LEFT JOIN work_items p ON w.parent_id = p.id
+      LEFT JOIN work_items e ON w.epic_id = e.id AND w.epic_id != w.id
+      WHERE w.id = ?
+    `, [id], (err, workItem) => {
+      if (err) {
+        return reject(new Error(`Database error: ${err.message}`));
+      }
+
+      if (!workItem) {
+        return reject(new Error(`Work item #${id} not found`));
+      }
+
+      // Update status to in_progress if currently todo
+      const finalStatus = workItem.status === 'todo' ? 'in_progress' : workItem.status;
+
+      const updateAndContinue = () => {
+        // Create current work file
+        const currentWork = {
+          id: workItem.id,
+          title: workItem.title,
+          type: workItem.type,
+          status: finalStatus,
+          parent_id: workItem.parent_id,
+          parent_title: workItem.parent_title,
+          epic_id: workItem.epic_id,
+          epic_title: workItem.epic_title
+        };
+
+        try {
+          setCurrentWork(currentWork);
+        } catch (err) {
+          return reject(new Error(`Failed to write current work file: ${err.message}`));
+        }
+
+      // Create feature branch
+      let branchName = null;
+      try {
+        branchName = createFeatureBranchName(id, workItem.title);
+        createOrCheckoutBranch(branchName);
+      } catch (gitError) {
+        // Git operations failed, but continue - work tracking still works
+        console.warn(`Warning: ${gitError.message}`);
+      }
+
+      // Update CLAUDE.md with work item's mode
+      // For chores, inherit the parent feature's mode
+      const modeToUse = (workItem.type === 'chore' && workItem.parent_mode)
+        ? workItem.parent_mode
+        : workItem.mode;
+      updateCurrentWork(currentWork, modeToUse);
+
+      // Display output
+      let output = `Working on: [#${workItem.id}] ${workItem.title} (${workItem.type})`;
+      if (workItem.parent_title) {
+        output = `Working on: [#${workItem.id}] ${workItem.title} (${workItem.type} of #${workItem.parent_id} ${workItem.parent_title})`;
+      }
+      console.log(output);
+
+      // Display bug workflow guidance for bugs
+      // Only display if workItem has a type (defensive check)
+      if (workItem && workItem.type === 'bug') {
+        try {
+          console.log(getBugWorkflowForTerminal());
+        } catch (err) {
+          // Silently fail if workflow display fails - don't block work start
+          // This is a non-critical feature
+        }
+      }
+
+      // Display epic discovery guidance for epics with needs_discovery
+      if (workItem && workItem.type === 'epic' && workItem.needs_discovery) {
+        // Check if decisions have been recorded
+        db.all(
+          `SELECT * FROM discovery_decisions WHERE work_item_id = ?`,
+          [workItem.id],
+          (err, decisions) => {
+            if (err || !decisions || decisions.length === 0) {
+              console.log('');
+              console.log('⚠️  This epic needs architectural discovery before building features.');
+              console.log('');
+              console.log('💬 Recommended: Talk to Claude Code');
+              console.log(`   Say: "Let's do epic discovery for #${workItem.id}"`);
+              console.log('');
+              console.log('   Claude Code will guide you through:');
+              console.log('   • Suggesting 3 architectural options');
+              console.log('   • Building prototypes');
+              console.log('   • Recording your decisions');
+              console.log('');
+            }
+          }
+        );
+      }
+
+      // Auto-trigger feature discovery for features in discovery phase
+      if (workItem && workItem.type === 'feature' && workItem.phase === 'discovery') {
+        console.log('');
+        console.log('✨ Feature Discovery Mode');
+        console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+        console.log('');
+        console.log('This feature is in discovery phase. Claude Code will help you:');
+        console.log('  1. Explore 3 different UX approaches');
+        console.log('  2. (Optional) Build throwaway prototypes');
+        console.log('  3. Choose the winning approach');
+        console.log('  4. Generate BDD scenarios for the happy path');
+        console.log('  5. Transition to implementation (speed mode)');
+        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('');
+      }
+
+      // Auto-trigger mode skills for chores in speed or stable mode
+      if (workItem && workItem.type === 'chore' && workItem.parent_id) {
+        // Validate parent feature exists
+        if (!workItem.parent_title) {
+          console.log('');
+          console.log('⚠️  Warning: Parent feature not found');
+          console.log('');
+          console.log(`This chore references parent feature #${workItem.parent_id}, but that feature`);
+          console.log('does not exist in the database.');
+          console.log('');
+          console.log('Suggestion: Check the parent_id or create the missing feature.');
+          console.log('');
+        }
+        // Validate scenario file exists
+        else if (!workItem.parent_scenario_file) {
+          console.log('');
+          console.log('⚠️  Warning: Parent feature has no scenario file');
+          console.log('');
+          console.log(`Parent feature #${workItem.parent_id} "${workItem.parent_title}" does not have`);
+          console.log('a scenario file set.');
+          console.log('');
+          console.log('Suggestion: Create a BDD scenario file for the feature and update scenario_file.');
+          console.log('');
+        }
+        else if (!fs.existsSync(path.join(process.cwd(), workItem.parent_scenario_file))) {
+          console.log('');
+          console.log('⚠️  Warning: Scenario file not found');
+          console.log('');
+          console.log(`Parent feature references scenario file: ${workItem.parent_scenario_file}`);
+          console.log('but the file does not exist on disk.');
+          console.log('');
+          console.log('Suggestion: Create the scenario file or update the feature.scenario_file path.');
+          console.log('');
+        }
+        else if (workItem.mode === 'speed') {
+          console.log('');
+          console.log('🚀 Speed Mode Skill Activated');
+          console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          console.log('');
+          console.log('Claude Code will autonomously:');
+          console.log('  1. Analyze the BDD scenario for this feature');
+          console.log('  2. Analyze the codebase to understand patterns');
+          console.log('  3. Propose an implementation approach');
+          console.log('  4. Implement until the happy path scenario passes');
+          console.log('  5. Generate stable mode chores for comprehensive testing');
+          console.log('');
+          console.log('💬 The speed-mode skill is now active.');
+          console.log('   Claude Code will guide you through implementation.');
+          console.log('');
+        } else if (workItem.mode === 'stable') {
+          console.log('');
+          console.log('🧪 Stable Mode Skill Activated');
+          console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
+          console.log('');
+          console.log('Claude Code will autonomously:');
+          console.log('  1. Analyze the BDD scenario to implement');
+          console.log('  2. Review the existing speed mode implementation');
+          console.log('  3. Propose comprehensive error handling approach');
+          console.log('  4. Implement with proper validation and edge case coverage');
+          console.log('  5. Ensure all BDD scenarios pass');
+          console.log('');
+          console.log('💬 The stable-mode skill is now active.');
+          console.log('   Claude Code will guide you through comprehensive testing.');
+          console.log('');
+        }
+      }
+
+        resolve({ workItem, currentWork, branchName });
+      };
+
+      // Update status to in_progress if currently todo
+      if (workItem.status === 'todo') {
+        db.run(`UPDATE work_items SET status = 'in_progress' WHERE id = ?`, [id], updateAndContinue);
+      } else {
+        updateAndContinue();
+      }
+    });
+  });
+}
+
+/**
+ * Stop work on current work item
+ * @param {string|null} newStatus - Optional status to set (e.g., 'done', 'blocked')
+ * @returns {Promise<Object|null>} Work item ID and status, or null if no active work
+ * @throws {Error} If status is invalid, database missing, or file operations fail
+ */
+function stopWork(newStatus = null) {
+  const paths = getPaths();
+
+  const currentWork = getCurrentWork();
+  if (!currentWork) {
+    console.log('No active work item');
+    return Promise.resolve(null);
+  }
+
+  // Validate status if provided
+  if (newStatus && !VALID_STATUSES.includes(newStatus)) {
+    return Promise.reject(new Error(`Invalid status: ${newStatus}`));
+  }
+
+  return new Promise((resolve, reject) => {
+    if (newStatus) {
+      if (!fs.existsSync(paths.dbPath)) {
+        return reject(new Error('Work database not found'));
+      }
+
+      const db = getDb();
+      db.run(`UPDATE work_items SET status = ? WHERE id = ?`, [newStatus, currentWork.id], (err) => {
+        if (err) {
+          return reject(new Error(`Database error: ${err.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 });
+      });
+    } else {
+      try {
+        clearCurrentWork();
+      } catch (err) {
+        return reject(new Error(`Failed to remove current work file: ${err.message}`));
+      }
+
+      console.log(`Stopped work on #${currentWork.id}`);
+      resolve({ id: currentWork.id });
+    }
+  });
+}
+
+// Re-export getCurrentWork from shared module for backwards compatibility
+// (used by jettypod.js)
+
+module.exports = {
+  startWork,
+  stopWork,
+  getCurrentWork
+};

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

@@ -0,0 +1,69 @@
+const { Given, When, Then } = require('@cucumber/cucumber');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { resetDb } = require('../../lib/database');
+
+const testDir = path.join('/tmp', 'jettypod-test-' + Date.now());
+let originalDir;
+
+Given('I have initialized jettypod', function () {
+  resetDb(); // Clear singleton db to avoid stale connections
+
+  originalDir = process.cwd();
+  // SAFETY: Only delete if testDir is in /tmp
+  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+  process.chdir(testDir);
+
+  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' });
+});
+
+Given('I create an epic with id {int}', function (id) {
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create epic "Test Epic"`, { stdio: 'pipe' });
+});
+
+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' });
+});
+
+When('I start work on item {int}', function (id) {
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work start ${id}`, { stdio: 'pipe' });
+});
+
+Then('the current work file exists', function () {
+  const currentWorkPath = path.join(testDir, '.jettypod', 'current-work.json');
+  assert(fs.existsSync(currentWorkPath), 'Current work file does not exist');
+});
+
+Then('the current work contains item {int}', function (id) {
+  const currentWorkPath = path.join(testDir, '.jettypod', 'current-work.json');
+  const currentWork = JSON.parse(fs.readFileSync(currentWorkPath, 'utf-8'));
+  assert.strictEqual(currentWork.id, 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 statusMatch = output.match(/Status:\s+(\w+)/);
+    if (!statusMatch) {
+      throw new Error('Could not find status in output');
+    }
+    const status = statusMatch[1];
+    assert(status === 'in_progress' || status === 'backlog', `Status is ${status}`);
+  } finally {
+    // SAFETY: Only delete if testDir is in /tmp
+    if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+      process.chdir(originalDir);
+      fs.rmSync(testDir, { recursive: true, force: true });
+    }
+    resetDb(); // Clear singleton after cleanup
+  }
+});

package/features/work-commands/stable-tests.feature

@@ -0,0 +1,57 @@
+Feature: Work Commands - Stable Mode
+  Edge cases and error handling for work commands
+
+  Scenario: Start work with invalid ID
+    Given jettypod is initialized
+    When I try to start work with ID "invalid"
+    Then I get an error "Invalid work item ID"
+
+  Scenario: Start work with negative ID
+    Given jettypod is initialized
+    When I try to start work with ID "-1"
+    Then I get an error "Invalid work item ID"
+
+  Scenario: Start work when not initialized
+    Given jettypod is not initialized
+    When I try to start work with ID "1"
+    Then I get an error "JettyPod not initialized"
+
+  Scenario: Start work on non-existent item
+    Given jettypod is initialized
+    When I try to start work with ID "999"
+    Then I get an error "Work item #999 not found"
+
+  Scenario: Stop work with invalid status
+    Given I have current work
+    When I try to stop work with status "invalid"
+    Then I get an error "Invalid status"
+
+  Scenario: Stop work when no current work
+    Given jettypod is initialized
+    And no work is active
+    When I try to stop work
+    Then operation succeeds with no changes
+
+  Scenario: Get current work with corrupted file
+    Given jettypod is initialized
+    And current work file is corrupted
+    When I get current work
+    Then it returns null
+
+  Scenario: Start work without git repo
+    Given jettypod is initialized without git
+    And I have a work item
+    When I start work on the item
+    Then it succeeds without creating branch
+
+  Scenario: Multiple start work calls
+    Given I have a work item
+    And I start work on it
+    When I start work on a different item
+    Then the first item stops being current
+    And the second item becomes current
+
+  Scenario: Start work preserves existing status
+    Given I have a work item with status "in_progress"
+    When I start work on it
+    Then the status remains "in_progress"