jettypod 4.1.2 → 4.1.4

package/lib/production-chore-generator.test.js

@@ -1,432 +0,0 @@
-const {
-  generateChoresFromStandards,
-  generateInfrastructureChores
-} = require('./production-chore-generator');
-
-describe('production-chore-generator', () => {
-  describe('generateChoresFromStandards', () => {
-    test('generates chores grouped by domain', () => {
-      const standards = {
-        preset: 'production-saas',
-        standards: [
-          {
-            id: 'tls_enforced',
-            domain: 'security',
-            acceptance: 'HSTS ≥ 6mo; TLS ≥1.2',
-            reasoning: 'External-facing app with user data'
-          },
-          {
-            id: 'rate_limiting',
-            domain: 'security',
-            acceptance: 'Per-IP 100/min, per-token 1000/min',
-            reasoning: 'Public internet exposure'
-          },
-          {
-            id: 'performance_budgets',
-            domain: 'performance',
-            acceptance: 'p95 < 2s, p50 < 500ms',
-            reasoning: '500 users expect responsive UI'
-          }
-        ]
-      };
-
-      const chores = generateChoresFromStandards(standards, 'Test Feature');
-
-      expect(chores).toHaveLength(2); // security + performance
-      expect(chores[0].title).toBe('Add security hardening to Test Feature');
-      expect(chores[1].title).toBe('Add performance hardening to Test Feature');
-    });
-
-    test('includes acceptance criteria in description', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'tls_enforced',
-            domain: 'security',
-            acceptance: 'HSTS ≥ 6mo; TLS ≥1.2'
-          }
-        ]
-      };
-
-      const chores = generateChoresFromStandards(standards, 'Test Feature');
-
-      expect(chores[0].description).toContain('Acceptance: HSTS ≥ 6mo; TLS ≥1.2');
-    });
-
-    test('includes reasoning when available', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'tls_enforced',
-            domain: 'security',
-            acceptance: 'TLS 1.2',
-            reasoning: 'External-facing app with user data'
-          }
-        ]
-      };
-
-      const chores = generateChoresFromStandards(standards, 'Test Feature');
-
-      expect(chores[0].description).toContain('Why: External-facing app with user data');
-    });
-
-    test('includes pattern when available', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'tls_enforced',
-            domain: 'security',
-            acceptance: 'TLS 1.2',
-            pattern: 'Use Let\'s Encrypt or cloud-managed certificates'
-          }
-        ]
-      };
-
-      const chores = generateChoresFromStandards(standards, 'Test Feature');
-
-      expect(chores[0].description).toContain('Pattern: Use Let\'s Encrypt or cloud-managed certificates');
-    });
-
-    test('formats standard IDs as readable text', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'performance_budgets_enforced',
-            domain: 'performance',
-            acceptance: 'test'
-          }
-        ]
-      };
-
-      const chores = generateChoresFromStandards(standards, 'Test Feature');
-
-      expect(chores[0].description).toContain('performance budgets enforced');
-    });
-
-    test('includes scenario steps in description', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'test',
-            domain: 'security',
-            acceptance: 'test'
-          }
-        ]
-      };
-
-      const chores = generateChoresFromStandards(standards, 'Test Feature');
-
-      expect(chores[0].description).toContain('Scenario steps addressed:');
-      expect(chores[0].description).toContain('Given the system is deployed to production');
-      expect(chores[0].description).toContain('When security measures are validated');
-    });
-
-    test('includes verification instructions', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'test',
-            domain: 'security',
-            acceptance: 'test'
-          }
-        ]
-      };
-
-      const chores = generateChoresFromStandards(standards, 'Test Feature');
-
-      expect(chores[0].description).toContain('Verification:');
-      expect(chores[0].description).toContain('npx cucumber-js');
-      expect(chores[0].description).toContain('All production mode scenarios should pass');
-    });
-
-    test('handles multiple standards in same domain', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'standard1',
-            domain: 'security',
-            acceptance: 'test1'
-          },
-          {
-            id: 'standard2',
-            domain: 'security',
-            acceptance: 'test2'
-          },
-          {
-            id: 'standard3',
-            domain: 'security',
-            acceptance: 'test3'
-          }
-        ]
-      };
-
-      const chores = generateChoresFromStandards(standards, 'Test Feature');
-
-      expect(chores).toHaveLength(1); // All grouped into one security chore
-      expect(chores[0].description).toContain('standard1');
-      expect(chores[0].description).toContain('standard2');
-      expect(chores[0].description).toContain('standard3');
-    });
-  });
-
-  describe('generateInfrastructureChores', () => {
-    test('filters standards by infrastructure scope', () => {
-      const standards = {
-        preset: 'production-saas',
-        standards: [
-          {
-            id: 'database_backups',
-            domain: 'infrastructure',
-            scope: 'infrastructure',
-            acceptance: 'Automated daily backups with 30-day retention'
-          },
-          {
-            id: 'tls_enforced',
-            domain: 'security',
-            scope: 'feature',
-            acceptance: 'HSTS ≥ 6mo; TLS ≥1.2'
-          },
-          {
-            id: 'monitoring_setup',
-            domain: 'infrastructure',
-            scope: 'infrastructure',
-            acceptance: 'Error tracking and APM configured'
-          }
-        ]
-      };
-
-      const chores = generateInfrastructureChores(standards);
-
-      expect(chores).toHaveLength(2); // Only infrastructure-scoped
-      expect(chores[0].title).toBe('Database Backups');
-      expect(chores[1].title).toBe('Monitoring Setup');
-    });
-
-    test('creates one chore per standard (not grouped by domain)', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'tls_enforced',
-            domain: 'security',
-            scope: 'infrastructure',
-            acceptance: 'HSTS ≥ 6mo'
-          },
-          {
-            id: 'rate_limiting',
-            domain: 'security',
-            scope: 'infrastructure',
-            acceptance: 'Per-IP 100/min'
-          },
-          {
-            id: 'monitoring_setup',
-            domain: 'infrastructure',
-            scope: 'infrastructure',
-            acceptance: 'APM configured'
-          }
-        ]
-      };
-
-      const chores = generateInfrastructureChores(standards);
-
-      expect(chores).toHaveLength(3); // One per standard, not grouped
-      expect(chores[0].title).toBe('Tls Enforced');
-      expect(chores[1].title).toBe('Rate Limiting');
-      expect(chores[2].title).toBe('Monitoring Setup');
-    });
-
-    test('includes acceptance criteria in chore description', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'database_backups',
-            domain: 'infrastructure',
-            scope: 'infrastructure',
-            acceptance: 'Automated daily backups with 30-day retention'
-          }
-        ]
-      };
-
-      const chores = generateInfrastructureChores(standards);
-
-      expect(chores[0].description).toContain('Automated daily backups with 30-day retention');
-    });
-
-    test('includes reasoning when available', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'database_backups',
-            domain: 'infrastructure',
-            scope: 'infrastructure',
-            acceptance: 'Daily backups',
-            reasoning: 'Data loss would be catastrophic'
-          }
-        ]
-      };
-
-      const chores = generateInfrastructureChores(standards);
-
-      expect(chores[0].description).toContain('Why:\nData loss would be catastrophic');
-    });
-
-    test('includes pattern guidance when available', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'database_backups',
-            domain: 'infrastructure',
-            scope: 'infrastructure',
-            acceptance: 'Daily backups',
-            pattern: 'Use pg_dump with --clean flag'
-          }
-        ]
-      };
-
-      const chores = generateInfrastructureChores(standards);
-
-      expect(chores[0].description).toContain('Pattern:\nUse pg_dump with --clean flag');
-    });
-
-    test('formats standard ID as readable title', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'automated_database_backups_configured',
-            domain: 'infrastructure',
-            scope: 'infrastructure',
-            acceptance: 'test'
-          }
-        ]
-      };
-
-      const chores = generateInfrastructureChores(standards);
-
-      expect(chores[0].title).toBe('Automated Database Backups Configured');
-    });
-
-    test('excludes feature-scoped standards', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'input_validation',
-            domain: 'security',
-            scope: 'feature',
-            acceptance: 'All inputs validated'
-          },
-          {
-            id: 'sql_injection_prevention',
-            domain: 'security',
-            scope: 'feature',
-            acceptance: 'Parameterized queries'
-          }
-        ]
-      };
-
-      const chores = generateInfrastructureChores(standards);
-
-      expect(chores).toHaveLength(0); // No infrastructure-scoped standards
-    });
-
-    test('handles standards without scope field', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'database_backups',
-            domain: 'infrastructure',
-            acceptance: 'Daily backups'
-            // Missing scope field
-          }
-        ]
-      };
-
-      const chores = generateInfrastructureChores(standards);
-
-      expect(chores).toHaveLength(0); // No scope means not infrastructure
-    });
-
-    test('validates standards object structure', () => {
-      expect(() => {
-        generateInfrastructureChores(null);
-      }).toThrow('Standards object is required');
-
-      expect(() => {
-        generateInfrastructureChores({});
-      }).toThrow('Standards object missing "standards" array');
-
-      expect(() => {
-        generateInfrastructureChores({ standards: 'not-an-array' });
-      }).toThrow('Standards "standards" field must be an array');
-    });
-
-    test('validates individual standard structure', () => {
-      const standards = {
-        standards: [
-          {
-            // Missing id
-            domain: 'infrastructure',
-            scope: 'infrastructure',
-            acceptance: 'test'
-          }
-        ]
-      };
-
-      expect(() => {
-        generateInfrastructureChores(standards);
-      }).toThrow('Standard missing required field "id"');
-    });
-
-    test('includes domain in chore description', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'monitoring_setup',
-            domain: 'infrastructure',
-            scope: 'infrastructure',
-            acceptance: 'APM configured'
-          }
-        ]
-      };
-
-      const chores = generateInfrastructureChores(standards);
-
-      expect(chores[0].domain).toBe('infrastructure');
-    });
-
-    test('handles mixed scope standards correctly', () => {
-      const standards = {
-        standards: [
-          {
-            id: 'infra1',
-            domain: 'security',
-            scope: 'infrastructure',
-            acceptance: 'test1'
-          },
-          {
-            id: 'feature1',
-            domain: 'security',
-            scope: 'feature',
-            acceptance: 'test2'
-          },
-          {
-            id: 'infra2',
-            domain: 'performance',
-            scope: 'infrastructure',
-            acceptance: 'test3'
-          },
-          {
-            id: 'feature2',
-            domain: 'performance',
-            scope: 'feature',
-            acceptance: 'test4'
-          }
-        ]
-      };
-
-      const chores = generateInfrastructureChores(standards);
-
-      expect(chores).toHaveLength(2);
-      expect(chores[0].title).toBe('Infra1');
-      expect(chores[1].title).toBe('Infra2');
-    });
-  });
-});

package/lib/production-context-detector.test.js

@@ -1,277 +0,0 @@
-const {
-  detectContext,
-  hasProductionScenarios,
-  hasProductionChores,
-  getTimeSinceStableCompletion
-} = require('./production-context-detector');
-const fs = require('fs');
-const path = require('path');
-const { getDb } = require('./database');
-
-describe('production-context-detector', () => {
-  let testDir;
-  let db;
-  let featureId;
-
-  beforeEach(() => {
-    // Create test directory
-    testDir = path.join(__dirname, '../test-tmp', `context-detector-${Date.now()}`);
-    fs.mkdirSync(testDir, { recursive: true });
-    process.chdir(testDir);
-
-    // Initialize database
-    db = getDb();
-  });
-
-  afterEach((done) => {
-    if (db) {
-      db.close(() => {
-        if (testDir && fs.existsSync(testDir)) {
-          fs.rmSync(testDir, { recursive: true, force: true });
-        }
-        done();
-      });
-    } else {
-      if (testDir && fs.existsSync(testDir)) {
-        fs.rmSync(testDir, { recursive: true, force: true });
-      }
-      done();
-    }
-  });
-
-  describe('hasProductionScenarios', () => {
-    test('returns false when no scenario file', async () => {
-      const result = await hasProductionScenarios(null);
-      expect(result).toBe(false);
-    });
-
-    test('returns false when scenario file does not exist', async () => {
-      const result = await hasProductionScenarios('nonexistent.feature');
-      expect(result).toBe(false);
-    });
-
-    test('returns true when file contains "# PRODUCTION MODE"', async () => {
-      const scenarioFile = path.join(testDir, 'test.feature');
-      fs.writeFileSync(scenarioFile, 'Feature: Test\n\n# PRODUCTION MODE\nScenario: Production test\n');
-
-      const result = await hasProductionScenarios('test.feature');
-      expect(result).toBe(true);
-    });
-
-    test('returns true when file contains "production mode"', async () => {
-      const scenarioFile = path.join(testDir, 'test.feature');
-      fs.writeFileSync(scenarioFile, 'Feature: Test\n\nScenario: Test (production mode)\n');
-
-      const result = await hasProductionScenarios('test.feature');
-      expect(result).toBe(true);
-    });
-
-    test('returns false when file has no production markers', async () => {
-      const scenarioFile = path.join(testDir, 'test.feature');
-      fs.writeFileSync(scenarioFile, 'Feature: Test\n\nScenario: Happy path\n');
-
-      const result = await hasProductionScenarios('test.feature');
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('hasProductionChores', () => {
-    beforeEach((done) => {
-      // Create a test feature
-      db.run(
-        `INSERT INTO work_items (type, title, status, mode, phase) VALUES (?, ?, ?, ?, ?)`,
-        ['feature', 'Test Feature', 'done', 'stable', 'implementation'],
-        function(err) {
-          if (err) return done(err);
-          featureId = this.lastID;
-          done();
-        }
-      );
-    });
-
-    test('returns false when no production chores exist', async () => {
-      const result = await hasProductionChores(featureId);
-      expect(result).toBe(false);
-    });
-
-    test('returns true when production chores exist', async () => {
-      // Create production chore
-      await new Promise((resolve, reject) => {
-        db.run(
-          `INSERT INTO work_items (type, title, parent_id, status, mode) VALUES (?, ?, ?, ?, ?)`,
-          ['chore', 'Production chore', featureId, 'todo', 'production'],
-          (err) => {
-            if (err) return reject(err);
-            resolve();
-          }
-        );
-      });
-
-      const result = await hasProductionChores(featureId);
-      expect(result).toBe(true);
-    });
-  });
-
-  describe('getTimeSinceStableCompletion', () => {
-    beforeEach((done) => {
-      // Create a test feature
-      db.run(
-        `INSERT INTO work_items (type, title, status, mode, phase) VALUES (?, ?, ?, ?, ?)`,
-        ['feature', 'Test Feature', 'done', 'stable', 'implementation'],
-        function(err) {
-          if (err) return done(err);
-          featureId = this.lastID;
-          done();
-        }
-      );
-    });
-
-    test('returns 0 when stable chore completed today', async () => {
-      // Create stable chore completed today
-      await new Promise((resolve, reject) => {
-        db.run(
-          `INSERT INTO work_items (type, title, parent_id, status, mode, completed_at)
-           VALUES (?, ?, ?, ?, ?, ?)`,
-          ['chore', 'Stable chore', featureId, 'done', 'stable', new Date().toISOString()],
-          (err) => {
-            if (err) return reject(err);
-            resolve();
-          }
-        );
-      });
-
-      const result = await getTimeSinceStableCompletion(featureId);
-      expect(result).toBe(0);
-    });
-
-    test('returns correct days when stable chore completed 7 days ago', async () => {
-      const sevenDaysAgo = new Date();
-      sevenDaysAgo.setDate(sevenDaysAgo.getDate() - 7);
-
-      // Create stable chore completed 7 days ago
-      await new Promise((resolve, reject) => {
-        db.run(
-          `INSERT INTO work_items (type, title, parent_id, status, mode, completed_at)
-           VALUES (?, ?, ?, ?, ?, ?)`,
-          ['chore', 'Stable chore', featureId, 'done', 'stable', sevenDaysAgo.toISOString()],
-          (err) => {
-            if (err) return reject(err);
-            resolve();
-          }
-        );
-      });
-
-      const result = await getTimeSinceStableCompletion(featureId);
-      expect(result).toBe(7);
-    });
-  });
-
-  describe('detectContext', () => {
-    beforeEach((done) => {
-      // Create a test feature
-      const yesterday = new Date();
-      yesterday.setDate(yesterday.getDate() - 1);
-
-      db.run(
-        `INSERT INTO work_items (type, title, status, mode, phase, completed_at) VALUES (?, ?, ?, ?, ?, ?)`,
-        ['feature', 'Test Feature', 'done', 'stable', 'implementation', yesterday.toISOString()],
-        function(err) {
-          if (err) return done(err);
-          featureId = this.lastID;
-          done();
-        }
-      );
-    });
-
-    test('detects SCENARIO_A when fresh from stable with production content', async () => {
-      // Create scenario file with production markers
-      const scenarioFile = path.join(testDir, 'test.feature');
-      fs.writeFileSync(scenarioFile, 'Feature: Test\n\n# PRODUCTION MODE\nScenario: Production test\n');
-
-      // Update feature with scenario file
-      await new Promise((resolve, reject) => {
-        db.run(
-          `UPDATE work_items SET scenario_file = ? WHERE id = ?`,
-          ['test.feature', featureId],
-          (err) => {
-            if (err) return reject(err);
-            resolve();
-          }
-        );
-      });
-
-      // Create production chore
-      await new Promise((resolve, reject) => {
-        db.run(
-          `INSERT INTO work_items (type, title, parent_id, status, mode) VALUES (?, ?, ?, ?, ?)`,
-          ['chore', 'Production chore', featureId, 'todo', 'production'],
-          (err) => {
-            if (err) return reject(err);
-            resolve();
-          }
-        );
-      });
-
-      const result = await detectContext(featureId);
-      expect(result).toBe('SCENARIO_A');
-    });
-
-    test('detects SCENARIO_B when gap in time', async () => {
-      // Create scenario file with production markers
-      const scenarioFile = path.join(testDir, 'test.feature');
-      fs.writeFileSync(scenarioFile, 'Feature: Test\n\n# PRODUCTION MODE\nScenario: Production test\n');
-
-      // Update feature with old date
-      const oldDate = new Date();
-      oldDate.setDate(oldDate.getDate() - 10);
-
-      await new Promise((resolve, reject) => {
-        db.run(
-          `UPDATE work_items SET scenario_file = ?, completed_at = ? WHERE id = ?`,
-          ['test.feature', oldDate.toISOString(), featureId],
-          (err) => {
-            if (err) return reject(err);
-            resolve();
-          }
-        );
-      });
-
-      // Create production chore
-      await new Promise((resolve, reject) => {
-        db.run(
-          `INSERT INTO work_items (type, title, parent_id, status, mode) VALUES (?, ?, ?, ?, ?)`,
-          ['chore', 'Production chore', featureId, 'todo', 'production'],
-          (err) => {
-            if (err) return reject(err);
-            resolve();
-          }
-        );
-      });
-
-      const result = await detectContext(featureId);
-      expect(result).toBe('SCENARIO_B');
-    });
-
-    test('detects SCENARIO_C when no production content exists', async () => {
-      // Create scenario file WITHOUT production markers
-      const scenarioFile = path.join(testDir, 'test.feature');
-      fs.writeFileSync(scenarioFile, 'Feature: Test\n\nScenario: Happy path\n');
-
-      await new Promise((resolve, reject) => {
-        db.run(
-          `UPDATE work_items SET scenario_file = ? WHERE id = ?`,
-          ['test.feature', featureId],
-          (err) => {
-            if (err) return reject(err);
-            resolve();
-          }
-        );
-      });
-
-      // No production chores created
-
-      const result = await detectContext(featureId);
-      expect(result).toBe('SCENARIO_C');
-    });
-  });
-});