jettypod 4.1.2 → 4.1.4

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

@@ -1,112 +0,0 @@
-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 - bugs don't have modes
-  Scenario: Create bug with mode fails
-    Given jettypod is initialized
-    When I try to create a bug "Test Bug" with mode "stable"
-    Then I get an error "Bugs cannot have modes"
-    And no work item is created
-
-  Scenario: Create bug without mode succeeds with NULL
-    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 no mode
-
-  # 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 "Test Bug" with parent epic
-    And I create a chore "Test Chore" without mode and parent epic
-    When I view the backlog
-    Then I see the epic without mode indicator
-    And I see the feature with mode "speed"
-    And I see the bug without mode indicator
-    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

@@ -1,482 +0,0 @@
-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, null, 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, null, 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', null],
-          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', null],
-          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, null],
-          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: null };
-
-      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: 'speed' };
-
-      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(' [speed]');
-    });
-
-    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', '', null],
-          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();
-                });
-              }
-            );
-          }
-        );
-      });
-    });
-  });
-});