jettypod 3.0.1

package/features/work-tracking/mode-required.feature

@@ -0,0 +1,112 @@
+Feature: Mode defaults to discovery on work item creation
+  As a developer
+  I want new work items to default to discovery mode
+  So I can start exploring without specifying mode every time
+
+  # Epic scenarios - epics don't have mode
+  Scenario: Create epic without mode
+    Given jettypod is initialized
+    When I create an epic "Test Epic" without mode
+    Then the work item is created successfully
+    And the work item has NULL mode
+
+  Scenario: Create epic with mode (optional)
+    Given jettypod is initialized
+    When I create an epic "Test Epic" with mode "stable"
+    Then the work item is created successfully
+    And the work item has mode "stable"
+
+  # Feature scenarios - defaults to discovery
+  Scenario: Create feature with explicit mode
+    Given jettypod is initialized
+    When I create a feature "Test Feature" with mode "speed"
+    Then the work item is created successfully
+    And the work item has mode "speed"
+
+  Scenario: Create feature without mode defaults to discovery
+    Given jettypod is initialized
+    When I create a feature "Test Feature" without mode
+    Then the work item is created successfully
+    And the work item has mode "discovery"
+
+  Scenario: Create feature with invalid mode
+    Given jettypod is initialized
+    When I try to create a feature "Test Feature" with mode "invalid"
+    Then I get an error "Invalid mode"
+    And no work item is created
+
+  # Bug scenarios - defaults to discovery
+  Scenario: Create bug with explicit mode
+    Given jettypod is initialized
+    When I create a bug "Test Bug" with mode "stable"
+    Then the work item is created successfully
+    And the work item has mode "stable"
+
+  Scenario: Create bug without mode defaults to discovery
+    Given jettypod is initialized
+    When I create a bug "Test Bug" without mode
+    Then the work item is created successfully
+    And the work item has mode "discovery"
+
+  # Chore scenarios - chores don't have modes
+  Scenario: Create chore with mode fails
+    Given jettypod is initialized
+    When I try to create a chore "Test Chore" with mode "production"
+    Then I get an error "Chores do not have modes"
+    And no work item is created
+
+  Scenario: Create chore without mode succeeds with NULL
+    Given jettypod is initialized
+    When I create a chore "Test Chore" without mode
+    Then the work item is created successfully
+    And the work item has NULL mode
+
+  # All valid modes
+  Scenario Outline: Create feature with all valid modes
+    Given jettypod is initialized
+    When I create a feature "Test Feature" with mode "<mode>"
+    Then the work item is created successfully
+    And the work item has mode "<mode>"
+
+    Examples:
+      | mode       |
+      | speed      |
+      | discovery  |
+      | stable     |
+      | production |
+
+  # Integration - hierarchical structure
+  Scenario: Epic with children in different modes
+    Given jettypod is initialized
+    And I create an epic "Test Epic" without mode
+    And I create a feature "Speed Feature" with mode "speed" and parent epic
+    And I create a bug "Stable Bug" with mode "stable" and parent epic
+    And I create a chore "Test Chore" without mode and parent epic
+    When I view the work tree
+    Then I see the epic without mode indicator
+    And I see the feature with mode "speed"
+    And I see the bug with mode "stable"
+    And I see the chore without mode indicator
+
+  # Edge cases
+  Scenario: Create multiple items with same title but different modes
+    Given jettypod is initialized
+    When I create a feature "Duplicate" with mode "speed"
+    And I create a feature "Duplicate" with mode "stable"
+    Then both work items are created successfully
+    And they have different modes
+
+  Scenario: Mode is case-sensitive
+    Given jettypod is initialized
+    When I try to create a feature "Test" with mode "Speed"
+    Then I get an error "Invalid mode"
+
+  Scenario: Mode with whitespace is invalid
+    Given jettypod is initialized
+    When I try to create a feature "Test" with mode " speed "
+    Then I get an error "Invalid mode"
+
+  Scenario: Empty string mode is treated as NULL
+    Given jettypod is initialized
+    When I try to create a feature "Test" with mode ""
+    Then I get an error "Invalid mode"

package/features/work-tracking/phase-tracking.test.js

@@ -0,0 +1,482 @@
+const { createTestEnvironment } = require('../../lib/test-helpers');
+const { getDb, closeDb, resetDb } = require('../../lib/database');
+
+describe('Feature Phase Tracking', () => {
+  let testEnv;
+  let db;
+
+  beforeEach(() => {
+    resetDb();
+    testEnv = createTestEnvironment();
+    process.chdir(testEnv.testDir);
+    db = getDb();
+  });
+
+  afterEach(async () => {
+    
+    
+    await closeDb();
+    testEnv.cleanup();
+    resetDb();
+  });
+
+  describe('Database Schema', () => {
+    test('phase column exists in work_items table', async () => {
+      await new Promise((resolve) => {
+        db.get('SELECT sql FROM sqlite_master WHERE type="table" AND name="work_items"', [], (err, row) => {
+          expect(err).toBeNull();
+          expect(row.sql).toContain('phase');
+          resolve();
+        });
+      });
+    });
+
+    test('phase column allows NULL values', async () => {
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, phase) VALUES (?, ?, ?)', ['epic', 'Test Epic', null], function(err) {
+          expect(err).toBeNull();
+          resolve();
+        });
+      });
+    });
+
+    test('phase column accepts discovery value', async () => {
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, phase) VALUES (?, ?, ?)', ['feature', 'Test Feature', 'discovery'], function(err) {
+          expect(err).toBeNull();
+          resolve();
+        });
+      });
+    });
+
+    test('phase column accepts implementation value', async () => {
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, phase) VALUES (?, ?, ?)', ['feature', 'Test Feature', 'implementation'], function(err) {
+          expect(err).toBeNull();
+          resolve();
+        });
+      });
+    });
+  });
+
+  describe('Feature Creation with Default Phase', () => {
+    test('new features default to discovery phase', async () => {
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, description, parent_id, mode, needs_discovery, phase) VALUES (?, ?, ?, ?, ?, ?, ?)',
+          ['feature', 'Test Feature', 'Description', null, 'discovery', 0, 'discovery'],
+          function(err) {
+            expect(err).toBeNull();
+            const featureId = this.lastID;
+
+            db.get('SELECT phase FROM work_items WHERE id = ?', [featureId], (err, row) => {
+              expect(err).toBeNull();
+              expect(row.phase).toBe('discovery');
+              resolve();
+            });
+          }
+        );
+      });
+    });
+
+    test('epics have NULL phase', async () => {
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, description, parent_id, mode, needs_discovery, phase) VALUES (?, ?, ?, ?, ?, ?, ?)',
+          ['epic', 'Test Epic', 'Description', null, null, 0, null],
+          function(err) {
+            expect(err).toBeNull();
+            const epicId = this.lastID;
+
+            db.get('SELECT phase FROM work_items WHERE id = ?', [epicId], (err, row) => {
+              expect(err).toBeNull();
+              expect(row.phase).toBeNull();
+              resolve();
+            });
+          }
+        );
+      });
+    });
+
+    test('chores have NULL phase', async () => {
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, description, parent_id, mode, needs_discovery, phase) VALUES (?, ?, ?, ?, ?, ?, ?)',
+          ['chore', 'Test Chore', 'Description', null, 'discovery', 0, null],
+          function(err) {
+            expect(err).toBeNull();
+            const choreId = this.lastID;
+
+            db.get('SELECT phase FROM work_items WHERE id = ?', [choreId], (err, row) => {
+              expect(err).toBeNull();
+              expect(row.phase).toBeNull();
+              resolve();
+            });
+          }
+        );
+      });
+    });
+
+    test('bugs have NULL phase', async () => {
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, description, parent_id, mode, needs_discovery, phase) VALUES (?, ?, ?, ?, ?, ?, ?)',
+          ['bug', 'Test Bug', 'Description', null, 'stable', 0, null],
+          function(err) {
+            expect(err).toBeNull();
+            const bugId = this.lastID;
+
+            db.get('SELECT phase FROM work_items WHERE id = ?', [bugId], (err, row) => {
+              expect(err).toBeNull();
+              expect(row.phase).toBeNull();
+              resolve();
+            });
+          }
+        );
+      });
+    });
+  });
+
+  describe('Phase Transition (Discovery → Implementation)', () => {
+    test('can transition feature from discovery to implementation', async () => {
+      // Create feature in discovery phase
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, phase, mode) VALUES (?, ?, ?, ?)',
+          ['feature', 'Test Feature', 'discovery', 'discovery'],
+          resolve
+        );
+      });
+
+      // Transition to implementation
+      await new Promise((resolve) => {
+        db.run('UPDATE work_items SET phase = ?, mode = ? WHERE id = ?',
+          ['implementation', 'speed', 1],
+          resolve
+        );
+      });
+
+      // Verify phase and mode
+      await new Promise((resolve) => {
+        db.get('SELECT phase, mode FROM work_items WHERE id = ?', [1], (err, row) => {
+          expect(err).toBeNull();
+          expect(row.phase).toBe('implementation');
+          expect(row.mode).toBe('speed');
+          resolve();
+        });
+      });
+    });
+
+    test('implementation phase sets mode to speed', async () => {
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, phase, mode) VALUES (?, ?, ?, ?)',
+          ['feature', 'Test Feature', 'discovery', 'discovery'],
+          function(err) {
+            const featureId = this.lastID;
+
+            db.run('UPDATE work_items SET phase = ?, mode = ? WHERE id = ?',
+              ['implementation', 'speed', featureId],
+              () => {
+                db.get('SELECT mode FROM work_items WHERE id = ?', [featureId], (err, row) => {
+                  expect(row.mode).toBe('speed');
+                  resolve();
+                });
+              }
+            );
+          }
+        );
+      });
+    });
+
+    test('cannot transition epic (has NULL phase)', async () => {
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, phase) VALUES (?, ?, ?)',
+          ['epic', 'Test Epic', null],
+          function(err) {
+            const epicId = this.lastID;
+
+            db.get('SELECT phase, type FROM work_items WHERE id = ?', [epicId], (err, row) => {
+              expect(row.phase).toBeNull();
+              expect(row.type).toBe('epic');
+              resolve();
+            });
+          }
+        );
+      });
+    });
+
+    test('cannot transition chore (has NULL phase)', async () => {
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, phase, mode) VALUES (?, ?, ?, ?)',
+          ['chore', 'Test Chore', null, 'discovery'],
+          function(err) {
+            const choreId = this.lastID;
+
+            db.get('SELECT phase, type FROM work_items WHERE id = ?', [choreId], (err, row) => {
+              expect(row.phase).toBeNull();
+              expect(row.type).toBe('chore');
+              resolve();
+            });
+          }
+        );
+      });
+    });
+  });
+
+  describe('Phase Display Logic', () => {
+    test('discovery phase shows with 🔍 icon', () => {
+      const item = { type: 'feature', phase: 'discovery', mode: 'discovery' };
+
+      let modeIndicator = '';
+      if (item.type === 'feature') {
+        if (item.phase === 'discovery') {
+          modeIndicator = ' [🔍 discovery]';
+        } else if (item.mode) {
+          modeIndicator = ` [${item.mode}]`;
+        }
+      }
+
+      expect(modeIndicator).toBe(' [🔍 discovery]');
+    });
+
+    test('implementation phase shows mode', () => {
+      const item = { type: 'feature', phase: 'implementation', mode: 'speed' };
+
+      let modeIndicator = '';
+      if (item.type === 'feature') {
+        if (item.phase === 'discovery') {
+          modeIndicator = ' [🔍 discovery]';
+        } else if (item.mode) {
+          modeIndicator = ` [${item.mode}]`;
+        }
+      }
+
+      expect(modeIndicator).toBe(' [speed]');
+    });
+
+    test('implementation phase with stable mode', () => {
+      const item = { type: 'feature', phase: 'implementation', mode: 'stable' };
+
+      let modeIndicator = '';
+      if (item.type === 'feature') {
+        if (item.phase === 'discovery') {
+          modeIndicator = ' [🔍 discovery]';
+        } else if (item.mode) {
+          modeIndicator = ` [${item.mode}]`;
+        }
+      }
+
+      expect(modeIndicator).toBe(' [stable]');
+    });
+
+    test('implementation phase with production mode', () => {
+      const item = { type: 'feature', phase: 'implementation', mode: 'production' };
+
+      let modeIndicator = '';
+      if (item.type === 'feature') {
+        if (item.phase === 'discovery') {
+          modeIndicator = ' [🔍 discovery]';
+        } else if (item.mode) {
+          modeIndicator = ` [${item.mode}]`;
+        }
+      }
+
+      expect(modeIndicator).toBe(' [production]');
+    });
+
+    test('epic shows no phase indicator', () => {
+      const item = { type: 'epic', phase: null, mode: null };
+
+      let modeIndicator = '';
+      if (item.type === 'feature') {
+        if (item.phase === 'discovery') {
+          modeIndicator = ' [🔍 discovery]';
+        } else if (item.mode) {
+          modeIndicator = ` [${item.mode}]`;
+        }
+      } else if (item.type !== 'epic' && item.mode) {
+        modeIndicator = ` [${item.mode}]`;
+      }
+
+      expect(modeIndicator).toBe('');
+    });
+
+    test('chore shows mode indicator', () => {
+      const item = { type: 'chore', phase: null, mode: 'discovery' };
+
+      let modeIndicator = '';
+      if (item.type === 'feature') {
+        if (item.phase === 'discovery') {
+          modeIndicator = ' [🔍 discovery]';
+        } else if (item.mode) {
+          modeIndicator = ` [${item.mode}]`;
+        }
+      } else if (item.type !== 'epic' && item.mode) {
+        modeIndicator = ` [${item.mode}]`;
+      }
+
+      expect(modeIndicator).toBe(' [discovery]');
+    });
+
+    test('bug shows mode indicator', () => {
+      const item = { type: 'bug', phase: null, mode: 'stable' };
+
+      let modeIndicator = '';
+      if (item.type === 'feature') {
+        if (item.phase === 'discovery') {
+          modeIndicator = ' [🔍 discovery]';
+        } else if (item.mode) {
+          modeIndicator = ` [${item.mode}]`;
+        }
+      } else if (item.type !== 'epic' && item.mode) {
+        modeIndicator = ` [${item.mode}]`;
+      }
+
+      expect(modeIndicator).toBe(' [stable]');
+    });
+  });
+
+  describe('Edge Cases', () => {
+    test('feature with NULL phase treated as implementation', async () => {
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, phase, mode) VALUES (?, ?, ?, ?)',
+          ['feature', 'Legacy Feature', null, 'stable'],
+          function(err) {
+            const featureId = this.lastID;
+
+            db.get('SELECT phase, mode FROM work_items WHERE id = ?', [featureId], (err, row) => {
+              expect(row.phase).toBeNull();
+              expect(row.mode).toBe('stable');
+              resolve();
+            });
+          }
+        );
+      });
+    });
+
+    test('feature in discovery with NULL mode', async () => {
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, phase, mode) VALUES (?, ?, ?, ?)',
+          ['feature', 'Test Feature', 'discovery', null],
+          function(err) {
+            const featureId = this.lastID;
+
+            db.get('SELECT phase, mode FROM work_items WHERE id = ?', [featureId], (err, row) => {
+              expect(row.phase).toBe('discovery');
+              expect(row.mode).toBeNull();
+              resolve();
+            });
+          }
+        );
+      });
+    });
+
+    test('feature in implementation with NULL mode defaults to speed', async () => {
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, phase, mode) VALUES (?, ?, ?, ?)',
+          ['feature', 'Test Feature', 'implementation', null],
+          function(err) {
+            const featureId = this.lastID;
+
+            // Simulate what implement command would do
+            db.run('UPDATE work_items SET mode = ? WHERE id = ? AND mode IS NULL',
+              ['speed', featureId],
+              () => {
+                db.get('SELECT phase, mode FROM work_items WHERE id = ?', [featureId], (err, row) => {
+                  expect(row.phase).toBe('implementation');
+                  expect(row.mode).toBe('speed');
+                  resolve();
+                });
+              }
+            );
+          }
+        );
+      });
+    });
+
+    test('handles empty phase value', async () => {
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, phase, mode) VALUES (?, ?, ?, ?)',
+          ['feature', 'Test Feature', '', 'discovery'],
+          function(err) {
+            const featureId = this.lastID;
+
+            db.get('SELECT phase FROM work_items WHERE id = ?', [featureId], (err, row) => {
+              // Empty string is stored as is
+              expect(row.phase).toBe('');
+              resolve();
+            });
+          }
+        );
+      });
+    });
+
+    test('multiple features can be in discovery simultaneously', async () => {
+      await new Promise((resolve) => {
+        db.serialize(() => {
+          db.run('INSERT INTO work_items (type, title, phase) VALUES (?, ?, ?)', ['feature', 'Feature 1', 'discovery']);
+          db.run('INSERT INTO work_items (type, title, phase) VALUES (?, ?, ?)', ['feature', 'Feature 2', 'discovery']);
+          db.run('INSERT INTO work_items (type, title, phase) VALUES (?, ?, ?)', ['feature', 'Feature 3', 'discovery'], () => {
+            db.all('SELECT COUNT(*) as count FROM work_items WHERE phase = ?', ['discovery'], (err, rows) => {
+              expect(rows[0].count).toBe(3);
+              resolve();
+            });
+          });
+        });
+      });
+    });
+
+    test('multiple features can be in implementation simultaneously', async () => {
+      await new Promise((resolve) => {
+        db.serialize(() => {
+          db.run('INSERT INTO work_items (type, title, phase, mode) VALUES (?, ?, ?, ?)', ['feature', 'Feature 1', 'implementation', 'speed']);
+          db.run('INSERT INTO work_items (type, title, phase, mode) VALUES (?, ?, ?, ?)', ['feature', 'Feature 2', 'implementation', 'stable']);
+          db.run('INSERT INTO work_items (type, title, phase, mode) VALUES (?, ?, ?, ?)', ['feature', 'Feature 3', 'implementation', 'production'], () => {
+            db.all('SELECT COUNT(*) as count FROM work_items WHERE phase = ?', ['implementation'], (err, rows) => {
+              expect(rows[0].count).toBe(3);
+              resolve();
+            });
+          });
+        });
+      });
+    });
+  });
+
+  describe('Backwards Compatibility', () => {
+    test('existing features without phase field work correctly', async () => {
+      // Simulate old feature (before migration)
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, mode) VALUES (?, ?, ?)',
+          ['feature', 'Legacy Feature', 'stable'],
+          function(err) {
+            const featureId = this.lastID;
+
+            db.get('SELECT phase, mode FROM work_items WHERE id = ?', [featureId], (err, row) => {
+              // Phase will be NULL or default value from schema
+              expect(row.mode).toBe('stable');
+              resolve();
+            });
+          }
+        );
+      });
+    });
+
+    test('migration sets existing features to implementation phase', async () => {
+      // Create feature without phase
+      await new Promise((resolve) => {
+        db.run('INSERT INTO work_items (type, title, mode, phase) VALUES (?, ?, ?, ?)',
+          ['feature', 'Old Feature', 'stable', null],
+          function(err) {
+            const featureId = this.lastID;
+
+            // Simulate migration
+            db.run('UPDATE work_items SET phase = ? WHERE type = ? AND phase IS NULL',
+              ['implementation', 'feature'],
+              () => {
+                db.get('SELECT phase FROM work_items WHERE id = ?', [featureId], (err, row) => {
+                  expect(row.phase).toBe('implementation');
+                  resolve();
+                });
+              }
+            );
+          }
+        );
+      });
+    });
+  });
+});