jettypod 3.0.1

package/features/jettypod-update-command.feature

@@ -0,0 +1,46 @@
+Feature: JettyPod update command
+  Self-updating jettypod and skills refresh with a single command
+
+  Epic: JettyPod and Skills Auto-Update
+  Approach: Full self-update - Check npm, update jettypod, refresh skills
+
+Scenario: User runs jettypod update when new version is available
+  Given jettypod version 3.0.0 is installed
+  And npm registry has version 3.1.0 available
+  When I run update command "jettypod update"
+  Then jettypod checks npm registry for latest version
+  And jettypod shows "New version available: 3.1.0 (current: 3.0.0)"
+  And jettypod downloads and installs version 3.1.0
+  And skills are refreshed in current project
+  And jettypod shows "✅ JettyPod updated to 3.1.0"
+
+Scenario: User runs jettypod update when already on latest version
+  Given jettypod version 3.1.0 is installed
+  And npm registry has version 3.1.0 available
+  When I run update command "jettypod update"
+  Then jettypod checks npm registry for latest version
+  And jettypod shows "Already on latest version: 3.1.0"
+  And skills are refreshed in current project
+
+Scenario: User runs jettypod update without internet connection
+  Given jettypod is installed
+  And there is no internet connection
+  When I run update command "jettypod update"
+  Then jettypod shows "Cannot check for updates: network error"
+  And skills are still refreshed in current project using existing jettypod
+
+Scenario: Command rename - jettypod without init creates new project
+  Given I am in a directory without .claude/
+  When I run update command "jettypod"
+  Then jettypod initializes the project
+  And .claude/ directory is created
+  And CLAUDE.md is created
+  And skills are installed
+
+Scenario: Backwards compatibility - jettypod init still works
+  Given I am in a directory without .claude/
+  When I run update command "jettypod init"
+  Then jettypod initializes the project
+  And .claude/ directory is created
+  And CLAUDE.md is created
+  And skills are installed

package/features/mode-prompts/index.js

@@ -0,0 +1,95 @@
+const readline = require('readline');
+const fs = require('fs');
+const path = require('path');
+const sqlite3 = require('sqlite3').verbose();
+
+/**
+ * Prompt user for work item status update
+ * @param {Object} currentWork - Current work item with id, title, and status
+ * @returns {Promise<string|null>} New status or null if skipped
+ * @throws {Error} If currentWork is invalid or missing required fields
+ */
+function promptForStatusUpdate(currentWork) {
+  // Validate input
+  if (!currentWork || typeof currentWork !== 'object') {
+    return Promise.reject(new Error('Invalid currentWork: must be an object'));
+  }
+
+  if (!currentWork.id || !currentWork.title || !currentWork.status) {
+    return Promise.reject(new Error('Invalid currentWork: missing id, title, or status'));
+  }
+
+  return new Promise((resolve, reject) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    console.log(`\nCurrent work: [#${currentWork.id}] ${currentWork.title} (${currentWork.status})`);
+    rl.question('Update status? [in_progress/blocked/done/skip]: ', (answer) => {
+      rl.close();
+
+      const status = answer.trim();
+      if (status === 'skip' || status === '') {
+        resolve(null);
+      } else if (['in_progress', 'blocked', 'done', 'todo', 'backlog'].includes(status)) {
+        resolve(status);
+      } else {
+        console.log('Invalid status, skipping update');
+        resolve(null);
+      }
+    });
+  });
+}
+
+/**
+ * Update work item status in database and current work file
+ * Uses shared updateStatus from work-tracking for consistency and epic auto-close logic
+ * @param {number} workItemId - ID of work item to update
+ * @param {string} newStatus - New status value
+ * @returns {Promise<void>}
+ * @throws {Error} If workItemId is invalid, newStatus is invalid, database not found, or file operations fail
+ */
+async function updateWorkItemStatus(workItemId, newStatus) {
+  // Validate inputs
+  if (!workItemId || isNaN(workItemId) || workItemId < 1) {
+    return Promise.reject(new Error('Invalid work item ID'));
+  }
+
+  const validStatuses = ['in_progress', 'blocked', 'done', 'todo', 'backlog', 'cancelled'];
+  if (!newStatus || !validStatuses.includes(newStatus)) {
+    return Promise.reject(new Error(`Invalid status: ${newStatus}`));
+  }
+
+  const jettypodDir = path.join(process.cwd(), '.jettypod');
+  const { getDbPath } = require('../../lib/database');
+  const dbPath = getDbPath();
+  const currentWorkPath = path.join(jettypodDir, 'current-work.json');
+
+  // Check database exists
+  if (!fs.existsSync(dbPath)) {
+    return Promise.reject(new Error('Work database not found. Run: jettypod init'));
+  }
+
+  // Use shared updateStatus from work-tracking (includes epic auto-close logic)
+  const { updateStatus } = require('../work-tracking');
+  await updateStatus(workItemId, newStatus);
+
+  // Update current work file if it exists
+  if (fs.existsSync(currentWorkPath)) {
+    try {
+      const currentWork = JSON.parse(fs.readFileSync(currentWorkPath, 'utf-8'));
+      currentWork.status = newStatus;
+      fs.writeFileSync(currentWorkPath, JSON.stringify(currentWork, null, 2));
+    } catch (fileErr) {
+      return Promise.reject(new Error(`Failed to update current work file: ${fileErr.message}`));
+    }
+  }
+
+  console.log(`✓ Work item #${workItemId} status updated to ${newStatus}`);
+}
+
+module.exports = {
+  promptForStatusUpdate,
+  updateWorkItemStatus
+};

package/features/mode-prompts/simple-steps.js

@@ -0,0 +1,44 @@
+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 testDir = path.join('/tmp', 'mode-prompts-' + Date.now());
+let originalDir;
+
+Given('I have jettypod with a work item in progress', function () {
+  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' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create feature "Test"`, { stdio: 'pipe' });
+  execSync(`node ${path.join(originalDir, 'jettypod.js')} work start 1`, { stdio: 'pipe' });
+});
+
+When('I check current work exists', function () {
+  const currentWorkPath = path.join(testDir, '.jettypod', 'current-work.json');
+  this.currentWorkExists = fs.existsSync(currentWorkPath);
+  if (this.currentWorkExists) {
+    this.currentWork = JSON.parse(fs.readFileSync(currentWorkPath, 'utf-8'));
+  }
+});
+
+Then('the work item has a status', function () {
+  assert(this.currentWorkExists, 'Current work file should exist');
+  assert(this.currentWork.status, 'Work item should have a status');
+
+  // Cleanup
+  if (fs.existsSync(testDir)) {
+    process.chdir(originalDir);
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+});

package/features/mode-prompts/simple-test.feature

@@ -0,0 +1,9 @@
+Feature: Mode Change Prompts
+  As a developer
+  I want to update work status when switching modes
+  So my work state stays current
+
+  Scenario: Integration - mode change with work item present
+    Given I have jettypod with a work item in progress
+    When I check current work exists
+    Then the work item has a status

package/features/mode-prompts/validation.test.js

@@ -0,0 +1,120 @@
+// Unit tests for mode-prompts validation logic
+// These test the error handling and validation without user interaction
+
+const { VALID_STATUSES } = require('../../lib/constants');
+
+describe('Mode Prompts - Validation', () => {
+  describe('promptForStatusUpdate validation', () => {
+    test('should validate currentWork is an object', () => {
+      const invalidInputs = [null, undefined, 'string', 123, [], true];
+      invalidInputs.forEach(input => {
+        const isValid = !!(input && typeof input === 'object' && !Array.isArray(input));
+        expect(isValid).toBe(false);
+      });
+    });
+
+    test('should validate currentWork has required fields', () => {
+      const invalidObjects = [
+        {},
+        { id: 1 },
+        { id: 1, title: 'Test' },
+        { title: 'Test', status: 'todo' },
+        { id: 1, status: 'todo' }
+      ];
+
+      invalidObjects.forEach(obj => {
+        const hasRequired = !!(obj.id && obj.title && obj.status);
+        expect(hasRequired).toBe(false);
+      });
+    });
+
+    test('should accept valid currentWork objects', () => {
+      const validObjects = [
+        { id: 1, title: 'Test', status: 'todo' },
+        { id: 2, title: 'Feature', status: 'in_progress', type: 'feature' }
+      ];
+
+      validObjects.forEach(obj => {
+        const hasRequired = !!(obj.id && obj.title && obj.status);
+        expect(hasRequired).toBe(true);
+      });
+    });
+
+    test('should validate status values', () => {
+      const validStatuses = ['in_progress', 'blocked', 'done', 'todo', 'backlog'];
+      const invalidStatuses = ['invalid', 'foo', '', null, undefined];
+
+      validStatuses.forEach(status => {
+        expect(validStatuses.includes(status)).toBe(true);
+      });
+
+      invalidStatuses.forEach(status => {
+        const isValid = !!(status && validStatuses.includes(status));
+        expect(isValid).toBe(false);
+      });
+    });
+
+    test('should accept skip or empty as null', () => {
+      const nullInputs = ['skip', ''];
+      nullInputs.forEach(input => {
+        const shouldBeNull = input === 'skip' || input === '';
+        expect(shouldBeNull).toBe(true);
+      });
+    });
+  });
+
+  describe('updateWorkItemStatus validation', () => {
+    test('should validate work item ID is numeric', () => {
+      const invalidIds = [null, undefined, 'abc', '', {}, []];
+      invalidIds.forEach(id => {
+        const isValid = !!(id && !isNaN(id) && id >= 1);
+        expect(isValid).toBe(false);
+      });
+    });
+
+    test('should validate work item ID is positive', () => {
+      expect(!!(0 && !isNaN(0) && 0 >= 1)).toBe(false);
+      expect(!!(-1 && !isNaN(-1) && -1 >= 1)).toBe(false);
+    });
+
+    test('should accept valid work item IDs', () => {
+      const validIds = [1, 2, 100, 999];
+      validIds.forEach(id => {
+        const isValid = id && !isNaN(id) && id >= 1;
+        expect(isValid).toBe(true);
+      });
+    });
+
+    test('should validate status is in valid statuses', () => {
+      const validStatuses = ['in_progress', 'blocked', 'done', 'todo', 'backlog', 'cancelled'];
+      const invalidStatuses = ['invalid', 'foo', '', null, undefined];
+
+      validStatuses.forEach(status => {
+        expect(validStatuses.includes(status)).toBe(true);
+      });
+
+      invalidStatuses.forEach(status => {
+        const isValid = !!(status && validStatuses.includes(status));
+        expect(isValid).toBe(false);
+      });
+    });
+  });
+
+  describe('Database path validation', () => {
+    test('should check jettypod directory exists', () => {
+      const fs = require('fs');
+      const path = require('path');
+
+      const nonExistentPath = '/nonexistent/path/.jettypod';
+      expect(fs.existsSync(nonExistentPath)).toBe(false);
+    });
+
+    test('should check database file exists', () => {
+      const fs = require('fs');
+      const path = require('path');
+
+      const nonExistentDb = '/nonexistent/path/.jettypod/work.db';
+      expect(fs.existsSync(nonExistentDb)).toBe(false);
+    });
+  });
+});

package/features/refactor-mode/steps.js

@@ -0,0 +1,217 @@
+const { Given, When, Then } = require('@cucumber/cucumber');
+const assert = require('assert');
+
+// State for scenarios
+let auditResults = null;
+let selectedCategory = null;
+let detailedBreakdown = null;
+let createdEpic = null;
+let createdChores = [];
+
+Given('I have existing work items in the system', function () {
+  // For integration test - work items exist in test DB
+  this.existingWorkItems = true;
+});
+
+Given("I'm in a project with technical debt", function () {
+  // Mock project with technical debt
+  this.projectHasDebt = true;
+});
+
+Given('I see the audit menu', function () {
+  // Previous step set auditResults
+  assert(auditResults, 'Audit results should be available');
+});
+
+Given('I see the detailed breakdown for {string}', function (category) {
+  // Previous step set detailedBreakdown
+  assert(detailedBreakdown, 'Detailed breakdown should be available');
+  assert.strictEqual(detailedBreakdown.category, category);
+});
+
+Given('I see recommendations for Storage Pattern', function () {
+  // Recommendations were shown in previous step
+  this.hasRecommendations = true;
+});
+
+When('I enter refactor mode and audit the codebase', function () {
+  // Simulate entering refactor mode with audit
+  auditResults = {
+    codeSmells: { count: 5, summary: 'Long functions, duplicated code' },
+    featureSpecific: { count: 3, summary: 'features/auth/ has patterns' },
+    architectural: { count: 15, summary: 'Storage patterns duplicated' },
+    performance: { count: 4, summary: 'Unnecessary re-renders' }
+  };
+});
+
+When('I enter refactor mode', function () {
+  // Simulate entering refactor mode
+  auditResults = {
+    codeSmells: { count: 5, summary: 'Long functions' },
+    featureSpecific: { count: 3, summary: 'features/auth/' },
+    architectural: { count: 15, summary: 'Storage patterns' },
+    performance: { count: 4, summary: 'Re-renders' }
+  };
+});
+
+When('I select {string} category', function (category) {
+  selectedCategory = category;
+});
+
+When('I pick {string} category', function (category) {
+  selectedCategory = category;
+  // Generate detailed breakdown
+  detailedBreakdown = {
+    category,
+    items: [
+      {
+        name: 'Storage Pattern',
+        count: 15,
+        type: '🟠 Cross-Cutting',
+        impact: 'High - affects all features',
+        time: '2 hours',
+        files: ['auth.js', 'expenses.js', '+13 more'],
+        example: 'localStorage.getItem() duplicated'
+      }
+    ]
+  };
+});
+
+When('I approve creating chores for storage pattern', function () {
+  // User approved - create chores
+  createdEpic = {
+    id: 999,
+    title: 'Refactor: Architectural patterns',
+    type: 'epic'
+  };
+
+  createdChores = [
+    {
+      id: 1000,
+      title: 'Create shared storage util',
+      epicId: 999,
+      type: 'chore'
+    },
+    {
+      id: 1001,
+      title: 'Migrate auth to storage util',
+      epicId: 999,
+      type: 'chore'
+    }
+  ];
+});
+
+When('Claude analyzes impact vs time', function () {
+  // Claude analyzes and generates recommendations
+  this.recommendations = {
+    quickWin: 'Storage Pattern (quick win, high impact)',
+    warning: 'State Management (needs Discovery Mode first)'
+  };
+});
+
+When('I say {string}', function (userInput) {
+  if (userInput === 'create chores') {
+    // User approved - create chores
+    createdEpic = {
+      id: 999,
+      title: 'Refactor: Architectural patterns',
+      type: 'epic'
+    };
+
+    createdChores = [
+      {
+        id: 1000,
+        title: 'Create shared storage util',
+        epicId: 999,
+        type: 'chore'
+      },
+      {
+        id: 1001,
+        title: 'Migrate auth to storage util',
+        epicId: 999,
+        type: 'chore'
+      }
+    ];
+  }
+});
+
+Then('Claude audits the codebase', function () {
+  assert(auditResults, 'Audit should have run');
+});
+
+Then('I see categorized menu with counts:', function (dataTable) {
+  const expectedCategories = dataTable.hashes();
+
+  // Verify we have results for each category
+  assert(auditResults.codeSmells, 'Should have code smells results');
+  assert(auditResults.featureSpecific, 'Should have feature-specific results');
+  assert(auditResults.architectural, 'Should have architectural results');
+  assert(auditResults.performance, 'Should have performance results');
+
+  // Verify counts are present
+  assert(auditResults.codeSmells.count > 0, 'Code smells count should be > 0');
+  assert(auditResults.architectural.count > 0, 'Architectural count should be > 0');
+});
+
+Then('I see detailed items with:', function (dataTable) {
+  const expectedFields = dataTable.hashes();
+
+  assert(detailedBreakdown, 'Should have detailed breakdown');
+  assert(detailedBreakdown.items.length > 0, 'Should have at least one item');
+
+  const item = detailedBreakdown.items[0];
+  assert(item.type, 'Item should have type');
+  assert(item.impact, 'Item should have impact');
+  assert(item.time, 'Item should have time estimate');
+  assert(item.files, 'Item should have files list');
+  assert(item.example, 'Item should have example');
+});
+
+Then('I see recommendation: {string}', function (recommendation) {
+  assert(this.recommendations, 'Should have recommendations');
+  assert(this.recommendations.quickWin.includes('Storage Pattern'), 'Should recommend Storage Pattern');
+  assert(this.recommendations.quickWin.includes('quick win'), 'Should mention quick win');
+});
+
+Then('I see warning: {string}', function (warning) {
+  assert(this.recommendations, 'Should have recommendations');
+  assert(this.recommendations.warning.includes('State Management'), 'Should warn about State Management');
+  assert(this.recommendations.warning.includes('Discovery Mode'), 'Should mention Discovery Mode');
+});
+
+Then('epic {string} is created', function (epicTitle) {
+  assert(createdEpic, 'Epic should be created');
+  assert.strictEqual(createdEpic.title, epicTitle);
+  assert.strictEqual(createdEpic.type, 'epic');
+});
+
+Then('chore {string} is created', function (choreTitle) {
+  const chore = createdChores.find(c => c.title === choreTitle);
+  assert(chore, `Chore "${choreTitle}" should be created`);
+  assert.strictEqual(chore.type, 'chore');
+});
+
+Then('refactor chores are created under an epic', function () {
+  assert(createdEpic, 'Epic should be created');
+  assert(createdChores.length > 0, 'Chores should be created');
+
+  // Verify chores are linked to epic
+  createdChores.forEach(chore => {
+    assert.strictEqual(chore.epicId, createdEpic.id, 'Chore should be linked to epic');
+  });
+});
+
+Then('the epic is linked to the refactor mode work item', function () {
+  // Epic is created as part of refactor mode workflow
+  assert(createdEpic, 'Epic should exist');
+  assert(this.existingWorkItems, 'Work items should exist');
+});
+
+Then('all chores are linked to the epic', function () {
+  assert(createdEpic, 'Epic should be created');
+  assert(createdChores.length > 0, 'Chores should be created');
+
+  createdChores.forEach(chore => {
+    assert.strictEqual(chore.epicId, createdEpic.id, 'All chores should be linked to epic');
+  });
+});

package/features/refactor-mode.feature

@@ -0,0 +1,49 @@
+Feature: Refactor Mode
+  As a developer
+  I want an interactive audit menu for refactoring
+  So that I can systematically clean up technical debt
+
+  # INTEGRATION TEST - Must work with existing work tracking
+  Scenario: Refactor mode integrates with work tracking
+    Given I have existing work items in the system
+    When I enter refactor mode and audit the codebase
+    And I select "Architectural" category
+    And I approve creating chores for storage pattern
+    Then refactor chores are created under an epic
+    And the epic is linked to the refactor mode work item
+
+  Scenario: User enters refactor mode and sees audit menu
+    Given I'm in a project with technical debt
+    When I enter refactor mode
+    Then Claude audits the codebase
+    And I see categorized menu with counts:
+      | Category            | Example                    |
+      | Code Smells         | Long functions (5 found)   |
+      | Feature-Specific    | features/auth/ (3 files)   |
+      | Architectural       | Storage patterns (15 uses) |
+      | Performance         | Re-renders (4 components)  |
+
+  Scenario: User picks category and sees detailed breakdown
+    Given I see the audit menu
+    When I pick "Architectural" category
+    Then I see detailed items with:
+      | Field   | Example                              |
+      | Type    | 🟠 Cross-Cutting                     |
+      | Impact  | High - affects all features          |
+      | Time    | 2 hours                              |
+      | Files   | auth.js, expenses.js, +13 more       |
+      | Example | localStorage.getItem() duplicated    |
+
+  Scenario: Claude recommends quick wins
+    Given I see the detailed breakdown for "Architectural"
+    When Claude analyzes impact vs time
+    Then I see recommendation: "Start with Storage Pattern (quick win, high impact)"
+    And I see warning: "Skip State Management (needs Discovery Mode first)"
+
+  Scenario: User approves and chores are created
+    Given I see recommendations for Storage Pattern
+    When I say "create chores"
+    Then epic "Refactor: Architectural patterns" is created
+    And chore "Create shared storage util" is created
+    And chore "Migrate auth to storage util" is created
+    And all chores are linked to the epic