jettypod 4.1.2 → 4.1.4

package/features/work-tracking/tree-view.test.js

@@ -1,310 +0,0 @@
-// Tests for tree view validation and error handling
-// These tests focus on the printTree and getTree functions' error handling
-// rather than full integration tests
-
-describe('Tree View - Error Handling', () => {
-  describe('printTree validation', () => {
-    const originalConsoleLog = console.log;
-    let logOutput = [];
-
-    beforeEach(() => {
-      logOutput = [];
-      console.log = jest.fn((...args) => {
-        logOutput.push(args.join(' '));
-      });
-    });
-
-    afterEach(() => {
-      console.log = originalConsoleLog;
-    });
-
-    function printTree(items, prefix = '') {
-      if (!Array.isArray(items)) {
-        throw new Error('Items must be an array');
-      }
-
-      items.forEach((item, index) => {
-        if (!item || typeof item !== 'object') {
-          return; // Skip invalid items
-        }
-
-        // Print item (simplified for tests)
-        console.log(`${prefix}${item.title}`);
-
-        // Print description if present
-        if (item.description) {
-          console.log(`${prefix}   "${item.description}"`);
-        }
-
-        if (item.children && item.children.length > 0) {
-          const newPrefix = prefix + '  ';
-          printTree(item.children, newPrefix);
-        }
-      });
-    }
-
-    test('should throw error for null input', () => {
-      expect(() => printTree(null)).toThrow('Items must be an array');
-    });
-
-    test('should throw error for string input', () => {
-      expect(() => printTree('not-an-array')).toThrow('Items must be an array');
-    });
-
-    test('should throw error for object input', () => {
-      expect(() => printTree({})).toThrow('Items must be an array');
-    });
-
-    test('should not throw for empty array', () => {
-      expect(() => printTree([])).not.toThrow();
-    });
-
-    test('should handle single valid item', () => {
-      const items = [{
-        id: 1,
-        title: 'Test',
-        type: 'feature',
-        status: 'backlog',
-        children: []
-      }];
-      expect(() => printTree(items)).not.toThrow();
-    });
-
-    test('should handle nested items', () => {
-      const items = [{
-        id: 1,
-        title: 'Epic',
-        type: 'epic',
-        status: 'backlog',
-        children: [{
-          id: 2,
-          title: 'Feature',
-          type: 'feature',
-          status: 'backlog',
-          children: []
-        }]
-      }];
-      expect(() => printTree(items)).not.toThrow();
-    });
-
-    test('should skip null items in array', () => {
-      const items = [
-        null,
-        {
-          id: 1,
-          title: 'Valid',
-          type: 'feature',
-          status: 'backlog',
-          children: []
-        }
-      ];
-      expect(() => printTree(items)).not.toThrow();
-    });
-
-    test('should skip undefined items in array', () => {
-      const items = [
-        undefined,
-        {
-          id: 1,
-          title: 'Valid',
-          type: 'feature',
-          status: 'backlog',
-          children: []
-        }
-      ];
-      expect(() => printTree(items)).not.toThrow();
-    });
-
-    test('should handle items without children property', () => {
-      const items = [{
-        id: 1,
-        title: 'Test',
-        type: 'feature',
-        status: 'backlog'
-        // no children property
-      }];
-      expect(() => printTree(items)).not.toThrow();
-    });
-
-    test('should handle deeply nested structures', () => {
-      const items = [{
-        id: 1,
-        title: 'Level 1',
-        children: [{
-          id: 2,
-          title: 'Level 2',
-          children: [{
-            id: 3,
-            title: 'Level 3',
-            children: []
-          }]
-        }]
-      }];
-      expect(() => printTree(items)).not.toThrow();
-    });
-
-    test('should display description when present', () => {
-      const items = [{
-        id: 1,
-        title: 'Test Item',
-        type: 'feature',
-        status: 'backlog',
-        description: 'Test description',
-        children: []
-      }];
-      printTree(items);
-      expect(logOutput).toContain('Test Item');
-      expect(logOutput).toContain('   "Test description"');
-    });
-
-    test('should not break when description is missing', () => {
-      const items = [{
-        id: 1,
-        title: 'No Description',
-        type: 'feature',
-        status: 'backlog',
-        children: []
-      }];
-      expect(() => printTree(items)).not.toThrow();
-      expect(logOutput).toContain('No Description');
-      expect(logOutput).not.toContain('""');
-    });
-
-    test('should handle empty string description', () => {
-      const items = [{
-        id: 1,
-        title: 'Empty Description',
-        type: 'feature',
-        status: 'backlog',
-        description: '',
-        children: []
-      }];
-      expect(() => printTree(items)).not.toThrow();
-      expect(logOutput).toContain('Empty Description');
-      // Empty string is falsy, so description should not display
-      expect(logOutput).not.toContain('""');
-    });
-
-    test('should display descriptions for nested items', () => {
-      const items = [{
-        id: 1,
-        title: 'Parent',
-        description: 'Parent description',
-        children: [{
-          id: 2,
-          title: 'Child',
-          description: 'Child description',
-          children: []
-        }]
-      }];
-      printTree(items);
-      expect(logOutput).toContain('Parent');
-      expect(logOutput).toContain('   "Parent description"');
-      expect(logOutput).toContain('  Child');
-      expect(logOutput).toContain('     "Child description"');
-    });
-  });
-
-  describe('getTree error handling', () => {
-    test('should build tree from flat structure', () => {
-      const rows = [
-        { id: 1, title: 'Epic', type: 'epic', status: 'backlog', parent_id: null, epic_id: 1 },
-        { id: 2, title: 'Feature', type: 'feature', status: 'backlog', parent_id: 1, epic_id: 1 }
-      ];
-
-      const itemsById = {};
-      const rootItems = [];
-
-      // Build lookup
-      rows.forEach(item => {
-        itemsById[item.id] = item;
-        item.children = [];
-      });
-
-      // Build tree
-      rows.forEach(item => {
-        if (item.parent_id && itemsById[item.parent_id]) {
-          itemsById[item.parent_id].children.push(item);
-        } else if (!item.parent_id) {
-          rootItems.push(item);
-        }
-      });
-
-      expect(rootItems).toHaveLength(1);
-      expect(rootItems[0].id).toBe(1);
-      expect(rootItems[0].children).toHaveLength(1);
-      expect(rootItems[0].children[0].id).toBe(2);
-    });
-
-    test('should handle empty rows array', () => {
-      const rows = [];
-      const itemsById = {};
-      const rootItems = [];
-
-      rows.forEach(item => {
-        itemsById[item.id] = item;
-        item.children = [];
-      });
-
-      rows.forEach(item => {
-        if (item.parent_id && itemsById[item.parent_id]) {
-          itemsById[item.parent_id].children.push(item);
-        } else if (!item.parent_id) {
-          rootItems.push(item);
-        }
-      });
-
-      expect(rootItems).toEqual([]);
-    });
-
-    test('should handle orphaned items (missing parent)', () => {
-      const rows = [
-        { id: 1, title: 'Orphan', type: 'feature', status: 'backlog', parent_id: 999, epic_id: null }
-      ];
-
-      const itemsById = {};
-      const rootItems = [];
-
-      rows.forEach(item => {
-        itemsById[item.id] = item;
-        item.children = [];
-      });
-
-      rows.forEach(item => {
-        if (item.parent_id && itemsById[item.parent_id]) {
-          itemsById[item.parent_id].children.push(item);
-        } else if (!item.parent_id) {
-          rootItems.push(item);
-        }
-      });
-
-      // Orphaned item (has parent_id but parent doesn't exist) is not added to rootItems
-      expect(rootItems).toHaveLength(0);
-    });
-
-    test('should handle multiple root items', () => {
-      const rows = [
-        { id: 1, title: 'Epic 1', type: 'epic', status: 'backlog', parent_id: null, epic_id: 1 },
-        { id: 2, title: 'Epic 2', type: 'epic', status: 'backlog', parent_id: null, epic_id: 2 }
-      ];
-
-      const itemsById = {};
-      const rootItems = [];
-
-      rows.forEach(item => {
-        itemsById[item.id] = item;
-        item.children = [];
-      });
-
-      rows.forEach(item => {
-        if (item.parent_id && itemsById[item.parent_id]) {
-          itemsById[item.parent_id].children.push(item);
-        } else if (!item.parent_id) {
-          rootItems.push(item);
-        }
-      });
-
-      expect(rootItems).toHaveLength(2);
-    });
-  });
-});

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

@@ -1,71 +0,0 @@
-Feature: Work set-mode updates CLAUDE.md if item is current
-  As a developer
-  I want to change a work item's mode with jettypod work set-mode
-  So I can adjust my approach without recreating the work item
-
-  Background:
-    Given jettypod is initialized
-    And CLAUDE.md exists
-
-  # Basic mode changes
-  Scenario: Set mode on current work item updates CLAUDE.md
-    Given I create a feature "Test Feature" with mode "speed"
-    And I start work on the feature
-    And CLAUDE.md mode is set to "speed"
-    When I set mode for current item to "stable"
-    Then the work item has mode "stable"
-    And CLAUDE.md mode is set to "stable"
-
-  Scenario: Set mode on non-current item does not update CLAUDE.md
-    Given I create a feature "Item 1" with mode "speed"
-    And I create a feature "Item 2" with mode "discovery"
-    And I start work on the feature "Item 1"
-    And CLAUDE.md mode is set to "speed"
-    When I set mode for item "Item 2" to "stable"
-    Then item "Item 2" has mode "stable"
-    But CLAUDE.md mode is set to "speed"
-
-  # Mode validation
-  Scenario: Set invalid mode shows error
-    Given I create a feature "Test Feature" with mode "speed"
-    When I try to set mode to "invalid"
-    Then I get error "Invalid mode"
-    And the work item still has mode "speed"
-
-  Scenario: Set mode is case-sensitive
-    Given I create a feature "Test Feature" with mode "speed"
-    When I try to set mode to "Speed"
-    Then I get error "Invalid mode"
-
-  # All valid modes
-  Scenario Outline: Change to all valid modes
-    Given I create a feature "Test Feature" with mode "speed"
-    And I start work on the feature
-    When I set mode for current item to "<new_mode>"
-    Then the work item has mode "<new_mode>"
-    And CLAUDE.md mode is set to "<new_mode>"
-
-    Examples:
-      | new_mode   |
-      | discovery  |
-      | stable     |
-      | production |
-
-  # Mode persistence
-  Scenario: Mode change persists across work start/stop
-    Given I create a feature "Test Feature" with mode "speed"
-    And I start work on the feature
-    When I set mode for current item to "production"
-    And I stop work
-    And I start work on the feature
-    Then CLAUDE.md mode is set to "production"
-
-  # Multiple mode changes
-  Scenario: Change mode multiple times
-    Given I create a feature "Test Feature" with mode "speed"
-    And I start work on the feature
-    When I set mode for current item to "discovery"
-    And I set mode for current item to "stable"
-    And I set mode for current item to "production"
-    Then the work item has mode "production"
-    And CLAUDE.md mode is set to "production"

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

@@ -1,88 +0,0 @@
-Feature: Work start sets CLAUDE.md mode from work item
-  As a developer
-  I want jettypod work start to set the CLAUDE.md mode from the work item's mode
-  So I automatically work in the correct mode for each work item
-
-  Background:
-    Given jettypod is initialized
-    And CLAUDE.md exists
-
-  # Basic mode inheritance
-  Scenario: Start work on feature in speed mode
-    Given I create a feature "Speed Feature" with mode "speed"
-    When I start work on the feature
-    Then CLAUDE.md mode is set to "speed"
-
-  Scenario: Start work on bug in stable mode
-    Given I create a bug "Stable Bug" with mode "stable"
-    When I start work on the bug
-    Then CLAUDE.md mode is set to "stable"
-
-  Scenario: Start work on chore inherits parent feature mode
-    Given I create a feature "Discovery Feature" with mode "discovery"
-    And I create a chore "Child Chore" without mode and parent feature
-    When I start work on the chore
-    Then CLAUDE.md mode is set to "discovery"
-
-  Scenario: Start work on feature in production mode
-    Given I create a feature "Production Feature" with mode "production"
-    When I start work on the feature
-    Then CLAUDE.md mode is set to "production"
-
-  # Mode switching between work items
-  Scenario: Switch from speed mode item to stable mode item
-    Given I create a feature "Speed Feature" with mode "speed"
-    And I create a bug "Stable Bug" with mode "stable"
-    And I start work on the feature
-    And CLAUDE.md mode is set to "speed"
-    When I stop work
-    And I start work on the bug
-    Then CLAUDE.md mode is set to "stable"
-
-  Scenario: Start work updates mode even if item already in progress
-    Given I create a feature "Test Feature" with mode "discovery"
-    And the feature status is "in_progress"
-    And CLAUDE.md has mode "speed"
-    When I start work on the feature
-    Then CLAUDE.md mode is set to "discovery"
-
-  # Epic handling - epics don't have modes
-  Scenario: Start work on epic (NULL mode)
-    Given I create an epic "Test Epic" without mode
-    When I start work on the epic
-    Then CLAUDE.md has no mode line
-    And the current work section exists
-
-  # Default mode from work item creation
-  Scenario: Start work on feature with default discovery mode
-    Given I create a feature "Default Feature" without mode
-    And the work item has mode "discovery"
-    When I start work on the feature
-    Then CLAUDE.md mode is set to "discovery"
-
-  # Hierarchical structure
-  Scenario: Start work on child features use their own mode, not parent's
-    Given 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 feature "Stable Feature" with mode "stable" and parent epic
-    When I start work on the speed feature
-    Then CLAUDE.md mode is set to "speed"
-    When I stop work
-    And I start work on the stable feature
-    Then CLAUDE.md mode is set to "stable"
-
-  # Mode persistence
-  Scenario: Work item mode persists in database after start
-    Given I create a feature "Test Feature" with mode "stable"
-    When I start work on the feature
-    And I stop work
-    Then the work item still has mode "stable"
-
-  # Edge cases
-  Scenario: Starting work multiple times preserves mode
-    Given I create a feature "Test Feature" with mode "production"
-    When I start work on the feature
-    And I stop work
-    And I start work on the feature
-    Then CLAUDE.md mode is set to "production"
-    And the work item still has mode "production"

package/lib/bug-workflow.test.js

@@ -1,177 +0,0 @@
-const {
-  BUG_WORKFLOW_STEPS,
-  BUG_WORKFLOW_TECHNIQUES,
-  BUG_WORKFLOW_RED_FLAGS,
-  getBugWorkflowForClaudeMd,
-  getBugWorkflowForTerminal
-} = require('./bug-workflow');
-
-describe('Bug Workflow Module', () => {
-  describe('Constants', () => {
-    test('BUG_WORKFLOW_STEPS contains all 6 steps', () => {
-      expect(BUG_WORKFLOW_STEPS).toContain('1. REPRODUCE');
-      expect(BUG_WORKFLOW_STEPS).toContain('2. INVESTIGATE');
-      expect(BUG_WORKFLOW_STEPS).toContain('3. ISOLATE');
-      expect(BUG_WORKFLOW_STEPS).toContain('4. FIX');
-      expect(BUG_WORKFLOW_STEPS).toContain('5. VERIFY');
-      expect(BUG_WORKFLOW_STEPS).toContain('6. COMMIT');
-    });
-
-    test('BUG_WORKFLOW_STEPS contains critical checklist items', () => {
-      // REPRODUCE checklist
-      expect(BUG_WORKFLOW_STEPS).toContain('Create minimal reproduction case');
-      expect(BUG_WORKFLOW_STEPS).toContain('Write down exact steps to trigger');
-
-      // INVESTIGATE checklist
-      expect(BUG_WORKFLOW_STEPS).toContain('Read error messages/stack traces completely');
-      expect(BUG_WORKFLOW_STEPS).toContain('Look for recent changes (git log/blame)');
-
-      // ISOLATE checklist
-      expect(BUG_WORKFLOW_STEPS).toContain('Identify root cause, not just symptoms');
-      expect(BUG_WORKFLOW_STEPS).toContain('Understand why the bug occurs');
-
-      // FIX checklist
-      expect(BUG_WORKFLOW_STEPS).toContain('Make the minimal change that fixes root cause');
-      expect(BUG_WORKFLOW_STEPS).toContain('Avoid "while I\'m here" refactoring');
-
-      // VERIFY checklist
-      expect(BUG_WORKFLOW_STEPS).toContain('Add regression test for this specific bug');
-      expect(BUG_WORKFLOW_STEPS).toContain('Run existing tests - ensure nothing broke');
-
-      // COMMIT checklist
-      expect(BUG_WORKFLOW_STEPS).toContain('Clear commit message: "fix: [brief description]"');
-      expect(BUG_WORKFLOW_STEPS).toContain('Reference issue number if applicable');
-    });
-
-    test('BUG_WORKFLOW_TECHNIQUES contains debugging tips', () => {
-      expect(BUG_WORKFLOW_TECHNIQUES).toContain('DEBUGGING TECHNIQUES:');
-      expect(BUG_WORKFLOW_TECHNIQUES).toContain('git bisect');
-      expect(BUG_WORKFLOW_TECHNIQUES).toContain('Rubber duck');
-      expect(BUG_WORKFLOW_TECHNIQUES).toContain('Take breaks');
-    });
-
-    test('BUG_WORKFLOW_RED_FLAGS contains anti-patterns', () => {
-      expect(BUG_WORKFLOW_RED_FLAGS).toContain('RED FLAGS:');
-      expect(BUG_WORKFLOW_RED_FLAGS).toContain('"It works on my machine"');
-      expect(BUG_WORKFLOW_RED_FLAGS).toContain('Fixing symptoms without understanding cause');
-      expect(BUG_WORKFLOW_RED_FLAGS).toContain('Adding try/catch to hide errors');
-      expect(BUG_WORKFLOW_RED_FLAGS).toContain('Skipping reproduction');
-    });
-  });
-
-  describe('getBugWorkflowForClaudeMd()', () => {
-    test('returns string with all workflow sections', () => {
-      const result = getBugWorkflowForClaudeMd();
-
-      expect(typeof result).toBe('string');
-      expect(result).toContain('SYSTEMATIC BUG FIXING WORKFLOW:');
-      expect(result).toContain(BUG_WORKFLOW_STEPS);
-      expect(result).toContain(BUG_WORKFLOW_TECHNIQUES);
-      expect(result).toContain(BUG_WORKFLOW_RED_FLAGS);
-    });
-
-    test('does not contain terminal formatting characters', () => {
-      const result = getBugWorkflowForClaudeMd();
-
-      // Should not have Unicode box-drawing characters
-      expect(result).not.toContain('━');
-      // Should not have emojis
-      expect(result).not.toContain('🐛');
-    });
-
-    test('has plain text header for markdown compatibility', () => {
-      const result = getBugWorkflowForClaudeMd();
-
-      expect(result).toContain('SYSTEMATIC BUG FIXING WORKFLOW:');
-    });
-  });
-
-  describe('getBugWorkflowForTerminal()', () => {
-    test('returns string with all workflow sections', () => {
-      const result = getBugWorkflowForTerminal();
-
-      expect(typeof result).toBe('string');
-      expect(result).toContain(BUG_WORKFLOW_STEPS);
-      expect(result).toContain(BUG_WORKFLOW_TECHNIQUES);
-      expect(result).toContain(BUG_WORKFLOW_RED_FLAGS);
-    });
-
-    test('contains terminal formatting characters', () => {
-      const result = getBugWorkflowForTerminal();
-
-      // Should have Unicode box-drawing characters for borders
-      expect(result).toContain('━');
-      // Should have bug emoji
-      expect(result).toContain('🐛');
-    });
-
-    test('has formatted header with emoji', () => {
-      const result = getBugWorkflowForTerminal();
-
-      expect(result).toContain('🐛  BUG FIXING WORKFLOW');
-    });
-
-    test('has top and bottom borders', () => {
-      const result = getBugWorkflowForTerminal();
-
-      // Count border lines
-      const borderCount = (result.match(/━━━━━━━/g) || []).length;
-      expect(borderCount).toBeGreaterThanOrEqual(2); // Top and bottom borders
-    });
-  });
-
-  describe('Content Consistency', () => {
-    test('both formats contain the same workflow steps', () => {
-      const claudeMd = getBugWorkflowForClaudeMd();
-      const terminal = getBugWorkflowForTerminal();
-
-      // Both should contain the exact same steps content
-      expect(claudeMd).toContain(BUG_WORKFLOW_STEPS);
-      expect(terminal).toContain(BUG_WORKFLOW_STEPS);
-    });
-
-    test('both formats contain the same techniques', () => {
-      const claudeMd = getBugWorkflowForClaudeMd();
-      const terminal = getBugWorkflowForTerminal();
-
-      expect(claudeMd).toContain(BUG_WORKFLOW_TECHNIQUES);
-      expect(terminal).toContain(BUG_WORKFLOW_TECHNIQUES);
-    });
-
-    test('both formats contain the same red flags', () => {
-      const claudeMd = getBugWorkflowForClaudeMd();
-      const terminal = getBugWorkflowForTerminal();
-
-      expect(claudeMd).toContain(BUG_WORKFLOW_RED_FLAGS);
-      expect(terminal).toContain(BUG_WORKFLOW_RED_FLAGS);
-    });
-  });
-
-  describe('Edge Cases', () => {
-    test('functions return non-empty strings', () => {
-      expect(getBugWorkflowForClaudeMd().length).toBeGreaterThan(0);
-      expect(getBugWorkflowForTerminal().length).toBeGreaterThan(0);
-    });
-
-    test('functions are deterministic (same output on multiple calls)', () => {
-      const claudeMd1 = getBugWorkflowForClaudeMd();
-      const claudeMd2 = getBugWorkflowForClaudeMd();
-      expect(claudeMd1).toBe(claudeMd2);
-
-      const terminal1 = getBugWorkflowForTerminal();
-      const terminal2 = getBugWorkflowForTerminal();
-      expect(terminal1).toBe(terminal2);
-    });
-
-    test('constants are immutable strings', () => {
-      expect(typeof BUG_WORKFLOW_STEPS).toBe('string');
-      expect(typeof BUG_WORKFLOW_TECHNIQUES).toBe('string');
-      expect(typeof BUG_WORKFLOW_RED_FLAGS).toBe('string');
-
-      // Verify they're not empty
-      expect(BUG_WORKFLOW_STEPS.length).toBeGreaterThan(0);
-      expect(BUG_WORKFLOW_TECHNIQUES.length).toBeGreaterThan(0);
-      expect(BUG_WORKFLOW_RED_FLAGS.length).toBeGreaterThan(0);
-    });
-  });
-});