jettypod 3.0.1

package/lib/config.js

@@ -0,0 +1,181 @@
+const fs = require('fs');
+const path = require('path');
+
+const VALID_PROJECT_STATES = ['internal', 'external'];
+const VALID_DISCOVERY_STATUSES = ['not_started', 'in_progress', 'completed'];
+
+const config = {
+  path: '.jettypod/config.json',
+
+  /**
+   * Validate project_state value
+   * @param {string} state - Project state to validate
+   * @returns {boolean} True if valid
+   */
+  isValidProjectState(state) {
+    return VALID_PROJECT_STATES.includes(state);
+  },
+
+  /**
+   * Validate project_discovery status
+   * @param {string} status - Discovery status to validate
+   * @returns {boolean} True if valid
+   */
+  isValidDiscoveryStatus(status) {
+    return VALID_DISCOVERY_STATUSES.includes(status);
+  },
+
+  /**
+   * Get default project_discovery object
+   * @returns {object} Default project discovery object
+   */
+  getDefaultProjectDiscovery() {
+    return {
+      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
+      }
+    };
+  },
+
+  read() {
+    const configPath = this.path;
+    if (!fs.existsSync(configPath)) {
+      return {
+        name: path.basename(process.cwd()),
+        stage: 'empty',
+        bundles: ['core'],
+        project_state: 'internal',
+        project_discovery: this.getDefaultProjectDiscovery()
+      };
+    }
+    try {
+      const data = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+      // Default project_state to 'internal' if not set or invalid
+      if (!data.project_state || !this.isValidProjectState(data.project_state)) {
+        data.project_state = 'internal';
+      }
+      // Default project_discovery if not set or invalid type
+      if (!data.project_discovery || typeof data.project_discovery !== 'object' || Array.isArray(data.project_discovery)) {
+        data.project_discovery = this.getDefaultProjectDiscovery();
+      } else {
+        // Validate and fix individual fields within project_discovery
+        const defaults = this.getDefaultProjectDiscovery();
+
+        // Fix status if invalid
+        if (!this.isValidDiscoveryStatus(data.project_discovery.status)) {
+          data.project_discovery.status = defaults.status;
+        }
+
+        // Fix prototypes if not an array
+        if (!Array.isArray(data.project_discovery.prototypes)) {
+          data.project_discovery.prototypes = defaults.prototypes;
+        }
+
+        // Ensure other fields have correct types
+        if (data.project_discovery.winner !== null && typeof data.project_discovery.winner !== 'string') {
+          data.project_discovery.winner = defaults.winner;
+        }
+        if (data.project_discovery.rationale !== null && typeof data.project_discovery.rationale !== 'string') {
+          data.project_discovery.rationale = defaults.rationale;
+        }
+        if (data.project_discovery.started_date !== null && typeof data.project_discovery.started_date !== 'string') {
+          data.project_discovery.started_date = defaults.started_date;
+        }
+        if (data.project_discovery.completed_date !== null && typeof data.project_discovery.completed_date !== 'string') {
+          data.project_discovery.completed_date = defaults.completed_date;
+        }
+
+        // Ensure checkpoint exists and has correct structure
+        if (!data.project_discovery.checkpoint || typeof data.project_discovery.checkpoint !== 'object' || Array.isArray(data.project_discovery.checkpoint)) {
+          data.project_discovery.checkpoint = defaults.checkpoint;
+        } else {
+          // Validate checkpoint fields
+          if (typeof data.project_discovery.checkpoint.step !== 'number') {
+            data.project_discovery.checkpoint.step = defaults.checkpoint.step;
+          }
+          if (data.project_discovery.checkpoint.user_journey !== null && typeof data.project_discovery.checkpoint.user_journey !== 'string') {
+            data.project_discovery.checkpoint.user_journey = defaults.checkpoint.user_journey;
+          }
+          if (data.project_discovery.checkpoint.ux_approach !== null && typeof data.project_discovery.checkpoint.ux_approach !== 'string') {
+            data.project_discovery.checkpoint.ux_approach = defaults.checkpoint.ux_approach;
+          }
+          if (typeof data.project_discovery.checkpoint.epics_created !== 'boolean') {
+            data.project_discovery.checkpoint.epics_created = defaults.checkpoint.epics_created;
+          }
+        }
+      }
+      return data;
+    } catch (e) {
+      // Return default object if JSON is malformed
+      return {
+        name: path.basename(process.cwd()),
+        stage: 'empty',
+        bundles: ['core'],
+        project_state: 'internal',
+        project_discovery: this.getDefaultProjectDiscovery()
+      };
+    }
+  },
+
+  write(data) {
+    const dir = path.dirname(this.path);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(this.path, JSON.stringify(data, null, 2));
+  },
+
+  update(updates) {
+    // Validate project_state if provided
+    if (updates.project_state && !this.isValidProjectState(updates.project_state)) {
+      throw new Error(`Invalid project_state: ${updates.project_state}. Must be 'internal' or 'external'.`);
+    }
+
+    // Validate project_discovery if provided
+    if (updates.project_discovery) {
+      if (typeof updates.project_discovery !== 'object' || Array.isArray(updates.project_discovery)) {
+        throw new Error('Invalid project_discovery: must be an object');
+      }
+
+      // Validate status
+      if (updates.project_discovery.status && !this.isValidDiscoveryStatus(updates.project_discovery.status)) {
+        throw new Error(`Invalid discovery status: ${updates.project_discovery.status}. Must be 'not_started', 'in_progress', or 'completed'.`);
+      }
+
+      // Validate prototypes is array if provided
+      if (updates.project_discovery.prototypes !== undefined && !Array.isArray(updates.project_discovery.prototypes)) {
+        throw new Error('Invalid project_discovery.prototypes: must be an array');
+      }
+
+      // Validate types of other fields if provided
+      const stringFields = ['winner', 'rationale', 'started_date', 'completed_date'];
+      stringFields.forEach(field => {
+        if (updates.project_discovery[field] !== undefined &&
+            updates.project_discovery[field] !== null &&
+            typeof updates.project_discovery[field] !== 'string') {
+          throw new Error(`Invalid project_discovery.${field}: must be a string or null`);
+        }
+      });
+    }
+
+    const current = this.read();
+    const updated = { ...current, ...updates };
+    this.write(updated);
+    return updated;
+  },
+
+  exists() {
+    return fs.existsSync(this.path);
+  }
+};
+
+module.exports = config;

package/lib/config.test.js

@@ -0,0 +1,511 @@
+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: 'internal',
+        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: 'internal',
+        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: 'internal',
+        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: 'internal',
+        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: 'internal',  // 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');
+    });
+  });
+});