jettypod 4.1.2 → 4.1.4

package/lib/claudemd.test.js

@@ -1,195 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { createTestEnvironment } = require('./test-helpers');
-const { updateCurrentWork, getClaudeMdPath } = require('./claudemd');
-const config = require('./config');
-
-describe('CLAUDE.md Updater Module', () => {
-  let testEnv;
-
-  beforeEach(() => {
-    testEnv = createTestEnvironment();
-    process.chdir(testEnv.testDir);
-
-    // Initialize config
-    const jettypodDir = path.join(testEnv.testDir, '.jettypod');
-    fs.mkdirSync(jettypodDir);
-    config.write({ mode: 'speed', stage: 'starting' });
-  });
-
-  afterEach(() => {
-    testEnv.cleanup();
-  });
-
-  const validWorkItem = {
-    id: 1,
-    title: 'Test Feature',
-    type: 'feature',
-    status: 'in_progress',
-    epic_id: 10,
-    epic_title: 'Test Epic'
-  };
-
-  describe('getClaudeMdPath()', () => {
-    test('should return path to CLAUDE.md in current directory', () => {
-      const claudePath = getClaudeMdPath();
-      expect(claudePath).toContain('CLAUDE.md');
-      expect(claudePath).toBe(path.join(process.cwd(), 'CLAUDE.md'));
-    });
-  });
-
-  describe('updateCurrentWork()', () => {
-    const basicClaudeContent = `<claude_context project="test">
-<project_summary>Test project</project_summary>
-</claude_context>`;
-
-    test('should do nothing if CLAUDE.md does not exist', () => {
-      expect(() => updateCurrentWork(validWorkItem)).not.toThrow();
-    });
-
-    test('should add current_work section if it does not exist', () => {
-      fs.writeFileSync('CLAUDE.md', basicClaudeContent);
-
-      updateCurrentWork(validWorkItem);
-
-      const content = fs.readFileSync('CLAUDE.md', 'utf-8');
-      expect(content).toContain('<current_work>');
-      expect(content).toContain('Working on: [#1] Test Feature (feature)');
-      expect(content).toContain('Epic: [#10] Test Epic');
-      expect(content).toContain('Mode: speed');
-      expect(content).toContain('Status: in_progress');
-      expect(content).toContain('</current_work>');
-    });
-
-    test('should replace existing current_work section', () => {
-      const existingContent = `<claude_context project="test">
-<current_work>
-Working on: [#999] Old Feature (bug)
-Status: done
-</current_work>
-<project_summary>Test project</project_summary>
-</claude_context>`;
-
-      fs.writeFileSync('CLAUDE.md', existingContent);
-
-      updateCurrentWork(validWorkItem);
-
-      const content = fs.readFileSync('CLAUDE.md', 'utf-8');
-      expect(content).not.toContain('[#999] Old Feature');
-      expect(content).toContain('[#1] Test Feature');
-      expect(content).toContain('Status: in_progress');
-    });
-
-    test('should not include epic if work item is the epic itself', () => {
-      const epicWorkItem = {
-        id: 10,
-        title: 'Test Epic',
-        type: 'epic',
-        status: 'in_progress',
-        epic_id: 10,
-        epic_title: 'Test Epic'
-      };
-
-      fs.writeFileSync('CLAUDE.md', basicClaudeContent);
-
-      updateCurrentWork(epicWorkItem);
-
-      const content = fs.readFileSync('CLAUDE.md', 'utf-8');
-      expect(content).not.toContain('Epic: [#10]');
-      expect(content).toContain('[#10] Test Epic (epic)');
-    });
-
-    test('should not include epic if epic_title is missing', () => {
-      const workItemNoEpic = {
-        id: 1,
-        title: 'Test Feature',
-        type: 'feature',
-        status: 'in_progress'
-      };
-
-      fs.writeFileSync('CLAUDE.md', basicClaudeContent);
-
-      updateCurrentWork(workItemNoEpic);
-
-      const content = fs.readFileSync('CLAUDE.md', 'utf-8');
-      expect(content).not.toContain('Epic:');
-    });
-
-    test('should use mode from config', () => {
-      config.write({ mode: 'stable', stage: 'building' });
-      fs.writeFileSync('CLAUDE.md', basicClaudeContent);
-
-      updateCurrentWork(validWorkItem);
-
-      const content = fs.readFileSync('CLAUDE.md', 'utf-8');
-      expect(content).toContain('Mode: stable');
-    });
-
-    test('should use mode from config even if malformed', () => {
-      // Config module caches config, so we just verify it uses whatever mode is set
-      const currentConfig = config.read();
-      fs.writeFileSync('CLAUDE.md', basicClaudeContent);
-
-      updateCurrentWork(validWorkItem);
-
-      const content = fs.readFileSync('CLAUDE.md', 'utf-8');
-      expect(content).toContain(`Mode: ${currentConfig.mode || 'speed'}`);
-    });
-
-    test('should throw error for invalid work item - not an object', () => {
-      expect(() => updateCurrentWork(null)).toThrow('Current work must be an object');
-      expect(() => updateCurrentWork('string')).toThrow('Current work must be an object');
-    });
-
-    test('should throw error for missing id', () => {
-      const invalid = { ...validWorkItem, id: null };
-      expect(() => updateCurrentWork(invalid)).toThrow('Current work must have a numeric id');
-    });
-
-    test('should throw error for non-numeric id', () => {
-      const invalid = { ...validWorkItem, id: 'not-a-number' };
-      expect(() => updateCurrentWork(invalid)).toThrow('Current work must have a numeric id');
-    });
-
-    test('should throw error for missing title', () => {
-      const invalid = { ...validWorkItem, title: null };
-      expect(() => updateCurrentWork(invalid)).toThrow('Current work must have a string title');
-    });
-
-    test('should throw error for missing type', () => {
-      const invalid = { ...validWorkItem, type: null };
-      expect(() => updateCurrentWork(invalid)).toThrow('Current work must have a string type');
-    });
-
-    test('should throw error for missing status', () => {
-      const invalid = { ...validWorkItem, status: null };
-      expect(() => updateCurrentWork(invalid)).toThrow('Current work must have a string status');
-    });
-
-    test('should throw error if CLAUDE.md does not contain claude_context tag', () => {
-      fs.writeFileSync('CLAUDE.md', 'Just plain text, no tags');
-
-      expect(() => updateCurrentWork(validWorkItem)).toThrow('CLAUDE.md does not contain <claude_context> tag');
-    });
-
-    test('should preserve other sections in CLAUDE.md', () => {
-      const fullContent = `<claude_context project="test">
-<current_work>
-Working on: [#999] Old Feature (bug)
-</current_work>
-<project_summary>Test project</project_summary>
-<tech_stack>Node.js, Jest</tech_stack>
-<mode>speed</mode>
-</claude_context>`;
-
-      fs.writeFileSync('CLAUDE.md', fullContent);
-
-      updateCurrentWork(validWorkItem);
-
-      const content = fs.readFileSync('CLAUDE.md', 'utf-8');
-      expect(content).toContain('<project_summary>Test project</project_summary>');
-      expect(content).toContain('<tech_stack>Node.js, Jest</tech_stack>');
-      expect(content).toContain('<mode>speed</mode>');
-    });
-  });
-});

package/lib/config.test.js

@@ -1,511 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const config = require('./config');
-const { createTestEnvironment } = require('./test-helpers');
-
-describe('Config Module', () => {
-  let testEnv;
-
-  beforeEach(() => {
-    testEnv = createTestEnvironment();
-    process.chdir(testEnv.testDir);
-  });
-
-  afterEach(() => {
-    testEnv.cleanup();
-  });
-
-  describe('read()', () => {
-    test('should return default config if config file does not exist', () => {
-      const result = config.read();
-      expect(result).toEqual({
-        name: path.basename(testEnv.testDir),
-        stage: 'empty',
-        bundles: ['core'],
-        project_state: 'external',
-        project_discovery: {
-          status: 'not_started',
-          prototypes: [],
-          winner: null,
-          rationale: null,
-          started_date: null,
-          completed_date: null,
-          checkpoint: {
-            step: 1,
-            user_journey: null,
-            ux_approach: null,
-            epics_created: false
-          }
-        }
-      });
-    });
-
-    test('should read existing config file', () => {
-      const testConfig = { name: 'test-project', mode: 'speed' };
-      fs.mkdirSync('.jettypod', { recursive: true });
-      fs.writeFileSync('.jettypod/config.json', JSON.stringify(testConfig));
-
-      const result = config.read();
-      expect(result).toEqual({
-        ...testConfig,
-        project_state: 'external',
-        project_discovery: {
-          status: 'not_started',
-          prototypes: [],
-          winner: null,
-          rationale: null,
-          started_date: null,
-          completed_date: null,
-          checkpoint: {
-            step: 1,
-            user_journey: null,
-            ux_approach: null,
-            epics_created: false
-          }
-        }
-      });
-    });
-
-    test('should handle malformed JSON gracefully', () => {
-      fs.mkdirSync('.jettypod', { recursive: true });
-      fs.writeFileSync('.jettypod/config.json', 'not valid json');
-
-      const result = config.read();
-      expect(result).toEqual({
-        name: path.basename(testEnv.testDir),
-        stage: 'empty',
-        bundles: ['core'],
-        project_state: 'external',
-        project_discovery: {
-          status: 'not_started',
-          prototypes: [],
-          winner: null,
-          rationale: null,
-          started_date: null,
-          completed_date: null,
-          checkpoint: {
-            step: 1,
-            user_journey: null,
-            ux_approach: null,
-            epics_created: false
-          }
-        }
-      });
-    });
-  });
-
-  describe('write()', () => {
-    test('should create .jettypod directory if it does not exist', () => {
-      const testConfig = { name: 'test-project' };
-      
-      config.write(testConfig);
-      
-      expect(fs.existsSync('.jettypod')).toBe(true);
-      expect(fs.existsSync('.jettypod/config.json')).toBe(true);
-    });
-
-    test('should write config as formatted JSON', () => {
-      const testConfig = { name: 'test-project', mode: 'speed' };
-      
-      config.write(testConfig);
-      
-      const written = fs.readFileSync('.jettypod/config.json', 'utf-8');
-      expect(JSON.parse(written)).toEqual(testConfig);
-      // Check it's formatted (has newlines and indentation)
-      expect(written).toContain('\n');
-      expect(written).toContain('  ');
-    });
-  });
-
-  describe('update()', () => {
-    test('should merge updates with existing config', () => {
-      const initial = { name: 'test-project', mode: 'discovery' };
-      fs.mkdirSync('.jettypod', { recursive: true });
-      fs.writeFileSync('.jettypod/config.json', JSON.stringify(initial));
-
-      config.update({ mode: 'speed', stage: 'growing' });
-
-      const result = config.read();
-      expect(result).toEqual({
-        name: 'test-project',
-        mode: 'speed',
-        stage: 'growing',
-        project_state: 'external',
-        project_discovery: {
-          status: 'not_started',
-          prototypes: [],
-          winner: null,
-          rationale: null,
-          started_date: null,
-          completed_date: null,
-          checkpoint: {
-            step: 1,
-            user_journey: null,
-            ux_approach: null,
-            epics_created: false
-          }
-        }
-      });
-    });
-
-    test('should create config if it does not exist', () => {
-      config.update({ mode: 'speed' });
-
-      const result = config.read();
-      expect(result).toEqual({
-        name: path.basename(testEnv.testDir),
-        mode: 'speed',  // Updated value
-        stage: 'empty',  // Default value
-        bundles: ['core'],  // Default value
-        project_state: 'external',  // Default value
-        project_discovery: {
-          status: 'not_started',
-          prototypes: [],
-          winner: null,
-          rationale: null,
-          started_date: null,
-          completed_date: null,
-          checkpoint: {
-            step: 1,
-            user_journey: null,
-            ux_approach: null,
-            epics_created: false
-          }
-        }
-      });
-    });
-  });
-
-  describe('exists()', () => {
-    test('should return false if config does not exist', () => {
-      expect(config.exists()).toBe(false);
-    });
-
-    test('should return true if config exists', () => {
-      fs.mkdirSync('.jettypod', { recursive: true });
-      fs.writeFileSync('.jettypod/config.json', '{}');
-
-      expect(config.exists()).toBe(true);
-    });
-  });
-
-  describe('project_discovery', () => {
-    test('should include default project_discovery in new config', () => {
-      const result = config.read();
-      expect(result.project_discovery).toEqual({
-        status: 'not_started',
-        prototypes: [],
-        winner: null,
-        rationale: null,
-        started_date: null,
-        completed_date: null,
-        checkpoint: {
-          step: 1,
-          user_journey: null,
-          ux_approach: null,
-          epics_created: false
-        }
-      });
-    });
-
-    test('should add project_discovery to existing config without it', () => {
-      const testConfig = { name: 'test-project' };
-      fs.mkdirSync('.jettypod', { recursive: true });
-      fs.writeFileSync('.jettypod/config.json', JSON.stringify(testConfig));
-
-      const result = config.read();
-      expect(result.project_discovery).toBeDefined();
-      expect(result.project_discovery.status).toBe('not_started');
-    });
-
-    test('should preserve existing project_discovery data', () => {
-      const testConfig = {
-        name: 'test-project',
-        project_discovery: {
-          status: 'in_progress',
-          prototypes: ['proto1', 'proto2'],
-          winner: null,
-          rationale: null,
-          started_date: '2025-10-29',
-          completed_date: null,
-          checkpoint: {
-            step: 3,
-            user_journey: 'test journey',
-            ux_approach: 'test approach',
-            epics_created: false
-          }
-        }
-      };
-      fs.mkdirSync('.jettypod', { recursive: true });
-      fs.writeFileSync('.jettypod/config.json', JSON.stringify(testConfig));
-
-      const result = config.read();
-      expect(result.project_discovery).toEqual(testConfig.project_discovery);
-    });
-
-    test('should fix invalid discovery status', () => {
-      const testConfig = {
-        name: 'test-project',
-        project_discovery: {
-          status: 'invalid_status',
-          prototypes: [],
-          winner: null,
-          rationale: null,
-          started_date: null,
-          completed_date: null
-        }
-      };
-      fs.mkdirSync('.jettypod', { recursive: true });
-      fs.writeFileSync('.jettypod/config.json', JSON.stringify(testConfig));
-
-      const result = config.read();
-      expect(result.project_discovery.status).toBe('not_started');
-    });
-
-    test('should validate discovery status', () => {
-      expect(config.isValidDiscoveryStatus('not_started')).toBe(true);
-      expect(config.isValidDiscoveryStatus('in_progress')).toBe(true);
-      expect(config.isValidDiscoveryStatus('completed')).toBe(true);
-      expect(config.isValidDiscoveryStatus('invalid')).toBe(false);
-    });
-
-    test('should update project_discovery via update()', () => {
-      config.update({
-        project_discovery: {
-          status: 'in_progress',
-          prototypes: ['prototype1'],
-          winner: null,
-          rationale: null,
-          started_date: '2025-10-29T10:00:00Z',
-          completed_date: null
-        }
-      });
-
-      const result = config.read();
-      expect(result.project_discovery.status).toBe('in_progress');
-      expect(result.project_discovery.prototypes).toEqual(['prototype1']);
-    });
-  });
-
-  describe('project_discovery edge cases', () => {
-    test('should handle project_discovery as array (not object)', () => {
-      const testConfig = {
-        name: 'test-project',
-        project_discovery: []  // Invalid: array not object
-      };
-      fs.mkdirSync('.jettypod', { recursive: true });
-      fs.writeFileSync('.jettypod/config.json', JSON.stringify(testConfig));
-
-      const result = config.read();
-      expect(result.project_discovery).toEqual(config.getDefaultProjectDiscovery());
-    });
-
-    test('should handle project_discovery with prototypes as non-array', () => {
-      const testConfig = {
-        name: 'test-project',
-        project_discovery: {
-          status: 'in_progress',
-          prototypes: { bad: 'value' },  // Invalid: object not array
-          winner: null,
-          rationale: null
-        }
-      };
-      fs.mkdirSync('.jettypod', { recursive: true });
-      fs.writeFileSync('.jettypod/config.json', JSON.stringify(testConfig));
-
-      const result = config.read();
-      expect(Array.isArray(result.project_discovery.prototypes)).toBe(true);
-      expect(result.project_discovery.prototypes).toEqual([]);
-    });
-
-    test('should handle project_discovery with winner as number', () => {
-      const testConfig = {
-        name: 'test-project',
-        project_discovery: {
-          status: 'completed',
-          prototypes: [],
-          winner: 123,  // Invalid: number not string
-          rationale: 'test'
-        }
-      };
-      fs.mkdirSync('.jettypod', { recursive: true });
-      fs.writeFileSync('.jettypod/config.json', JSON.stringify(testConfig));
-
-      const result = config.read();
-      expect(result.project_discovery.winner).toBe(null);
-    });
-
-    test('should handle project_discovery with rationale as number', () => {
-      const testConfig = {
-        name: 'test-project',
-        project_discovery: {
-          status: 'completed',
-          prototypes: [],
-          winner: 'proto.js',
-          rationale: 456  // Invalid: number not string
-        }
-      };
-      fs.mkdirSync('.jettypod', { recursive: true });
-      fs.writeFileSync('.jettypod/config.json', JSON.stringify(testConfig));
-
-      const result = config.read();
-      expect(result.project_discovery.rationale).toBe(null);
-    });
-
-    test('should handle project_discovery with invalid date types', () => {
-      const testConfig = {
-        name: 'test-project',
-        project_discovery: {
-          status: 'in_progress',
-          prototypes: [],
-          winner: null,
-          rationale: null,
-          started_date: 12345,  // Invalid: number not string
-          completed_date: true   // Invalid: boolean not string
-        }
-      };
-      fs.mkdirSync('.jettypod', { recursive: true });
-      fs.writeFileSync('.jettypod/config.json', JSON.stringify(testConfig));
-
-      const result = config.read();
-      expect(result.project_discovery.started_date).toBe(null);
-      expect(result.project_discovery.completed_date).toBe(null);
-    });
-  });
-
-  describe('project_discovery update() validation', () => {
-    test('should reject project_discovery as non-object', () => {
-      expect(() => {
-        config.update({ project_discovery: 'not an object' });
-      }).toThrow('must be an object');
-    });
-
-    test('should reject project_discovery as array', () => {
-      expect(() => {
-        config.update({ project_discovery: [] });
-      }).toThrow('must be an object');
-    });
-
-    test('should reject invalid discovery status', () => {
-      expect(() => {
-        config.update({
-          project_discovery: {
-            status: 'invalid_status',
-            prototypes: [],
-            winner: null,
-            rationale: null
-          }
-        });
-      }).toThrow("Must be 'not_started', 'in_progress', or 'completed'");
-    });
-
-    test('should reject prototypes as non-array', () => {
-      expect(() => {
-        config.update({
-          project_discovery: {
-            status: 'in_progress',
-            prototypes: 'not an array',
-            winner: null,
-            rationale: null
-          }
-        });
-      }).toThrow('prototypes: must be an array');
-    });
-
-    test('should reject winner as non-string (when not null)', () => {
-      expect(() => {
-        config.update({
-          project_discovery: {
-            status: 'completed',
-            prototypes: [],
-            winner: 123,
-            rationale: 'test'
-          }
-        });
-      }).toThrow('winner: must be a string or null');
-    });
-
-    test('should reject rationale as non-string (when not null)', () => {
-      expect(() => {
-        config.update({
-          project_discovery: {
-            status: 'completed',
-            prototypes: [],
-            winner: 'proto.js',
-            rationale: 456
-          }
-        });
-      }).toThrow('rationale: must be a string or null');
-    });
-
-    test('should accept valid project_discovery update', () => {
-      expect(() => {
-        config.update({
-          project_discovery: {
-            status: 'in_progress',
-            prototypes: ['proto1.js', 'proto2.js'],
-            winner: null,
-            rationale: null,
-            started_date: '2025-10-29T10:00:00Z',
-            completed_date: null
-          }
-        });
-      }).not.toThrow();
-
-      const result = config.read();
-      expect(result.project_discovery.status).toBe('in_progress');
-      expect(result.project_discovery.prototypes).toHaveLength(2);
-    });
-  });
-
-  describe('project_discovery workflow', () => {
-    test('should handle complete discovery workflow', () => {
-      // Start discovery
-      config.update({
-        project_discovery: {
-          status: 'in_progress',
-          prototypes: [],
-          winner: null,
-          rationale: null,
-          started_date: '2025-10-29T10:00:00Z',
-          completed_date: null
-        }
-      });
-
-      let result = config.read();
-      expect(result.project_discovery.status).toBe('in_progress');
-
-      // Add prototypes
-      config.update({
-        project_discovery: {
-          status: 'in_progress',
-          prototypes: ['proto1.js', 'proto2.js', 'proto3.js'],
-          winner: null,
-          rationale: null,
-          started_date: '2025-10-29T10:00:00Z',
-          completed_date: null
-        }
-      });
-
-      result = config.read();
-      expect(result.project_discovery.prototypes).toHaveLength(3);
-
-      // Complete discovery
-      config.update({
-        project_discovery: {
-          status: 'completed',
-          prototypes: ['proto1.js', 'proto2.js', 'proto3.js'],
-          winner: 'proto2.js',
-          rationale: 'Balanced approach won - best mix of features and simplicity',
-          started_date: '2025-10-29T10:00:00Z',
-          completed_date: '2025-10-29T15:30:00Z'
-        }
-      });
-
-      result = config.read();
-      expect(result.project_discovery.status).toBe('completed');
-      expect(result.project_discovery.winner).toBe('proto2.js');
-      expect(result.project_discovery.rationale).toContain('Balanced approach');
-    });
-  });
-});