jettypod 4.1.1 → 4.1.3

package/test-tmp/external-transition-1762983160548/.claude/skills/production-mode/SKILL.md

@@ -0,0 +1,369 @@
+---
+name: production-mode
+description: Guide implementation of production mode chores with production standards validation. Use when user starts work on a production mode chore. Detects context (Scenario A/B/C), validates/generates scenarios, and implements production hardening comprehensively.
+---
+
+# Production Mode Skill
+
+Guides Claude Code through production mode implementation with focus on security, scale, and compliance. Autonomous execution - Claude Code writes the code.
+
+## Instructions
+
+When this skill is activated, you are helping implement a production mode chore to add production hardening. Follow this structured approach:
+
+### Overview
+
+**Production Mode Goal:** Harden features for production deployment with security, performance, and compliance standards.
+
+**CRITICAL CONTEXT DETECTION:**
+- Production mode has **3 different starting scenarios** (A/B/C)
+- **Must detect context first** before proceeding
+- Different workflows for each scenario
+
+**Key Principles:**
+- **Context-aware execution** - adapt to Scenario A/B/C
+- **Standards-driven** - use production standards from external-transition
+- **Autonomous execution** - Claude Code writes code, user confirms approach
+- **Comprehensive hardening** - security, performance, compliance, infrastructure
+
+**User Profile:** May not know how to code - Claude Code does the implementation autonomously.
+
+---
+
+## Implementation Steps
+
+### Step 0: Detect Production Context (CRITICAL FIRST STEP)
+
+**MUST RUN FIRST:** Detect which scenario applies to this feature.
+
+**Code to detect context:**
+
+```javascript
+const { detectContext } = require('../../lib/production-context-detector');
+const { getCurrentWork } = require('../../lib/current-work');
+const { getDb } = require('../../lib/database');
+
+try {
+  const currentWork = getCurrentWork();
+
+  if (!currentWork) {
+    console.error('❌ No current work found. Run: jettypod work start <chore-id>');
+    return;
+  }
+
+  if (!currentWork.parent_id) {
+    console.error('❌ Current work has no parent feature.');
+    return;
+  }
+
+  const featureId = currentWork.parent_id;
+  const scenario = await detectContext(featureId);
+
+  console.log(`📋 Detected: ${scenario}`);
+
+  // Proceed with appropriate workflow
+  if (scenario === 'SCENARIO_A') {
+    // Fresh from stable mode - quick validation
+  } else if (scenario === 'SCENARIO_B') {
+    // Gap in time - re-validation
+  } else {
+    // Scenario C - generate from standards
+  }
+} catch (err) {
+  console.error('❌ Context detection failed:', err.message);
+  return;
+}
+```
+
+**Three Scenarios:**
+
+**Scenario A: Fresh from Stable (Hot Context)**
+- Production scenarios exist
+- Production chores exist
+- Completed stable ≤ 1 day ago
+- **Workflow:** Quick validation → fill gaps → implement
+
+**Scenario B: Gap in Time (Cold Context)**
+- Production scenarios exist
+- Production chores exist
+- Completed stable > 1 day ago OR project state changed
+- **Workflow:** Re-validate → update scenarios → implement
+
+**Scenario C: Post External-Transition (New Infrastructure)**
+- NO production scenarios exist
+- NO production chores exist
+- **Workflow:** Generate scenarios → create chores → implement
+
+---
+
+### Step 1: Read Production Standards
+
+**For all scenarios:** Read production standards file.
+
+```javascript
+const { readStandards, standardsFileExists } = require('../../lib/production-standards-reader');
+
+try {
+  if (!standardsFileExists()) {
+    console.error('❌ Production standards file not found.');
+    console.log('Run external-transition first to generate production standards.');
+    return;
+  }
+
+  const standards = await readStandards();
+  console.log(`📋 Loaded ${standards.standards.length} production standards`);
+  console.log(`Preset: ${standards.preset}`);
+
+  // Show domains
+  const domains = await getDomains();
+  console.log(`Domains: ${domains.join(', ')}`);
+} catch (err) {
+  console.error('❌ Failed to read production standards:', err.message);
+  return;
+}
+```
+
+---
+
+### Step 2A: Validate Scenarios (Scenario A - Hot Context)
+
+**For Scenario A only:** Quick validation of existing scenarios.
+
+```javascript
+const { validateScenarios } = require('../../lib/production-scenario-validator');
+const { getDb } = require('../../lib/database');
+
+try {
+  // Get feature scenario file
+  const db = getDb();
+  const feature = await new Promise((resolve, reject) => {
+    db.get('SELECT * FROM work_items WHERE id = ?', [featureId], (err, row) => {
+      if (err) reject(err);
+      resolve(row);
+    });
+  });
+
+  if (!feature.scenario_file) {
+    console.error('❌ Feature has no scenario file.');
+    return;
+  }
+
+  // Validate scenarios against standards
+  const validation = await validateScenarios(feature.scenario_file, standards);
+
+  console.log(`✅ Validation complete:`);
+  console.log(`  - Covered: ${validation.covered}/${validation.total} standards`);
+  console.log(`  - Gaps: ${validation.gaps.length}`);
+
+  if (validation.hasGaps) {
+    console.log('\n⚠️  Missing scenarios for:');
+    validation.gaps.forEach(gap => {
+      console.log(`  - ${gap.domain}: ${gap.standardId}`);
+      console.log(`    ${gap.reasoning}`);
+    });
+
+    // Generate and append missing scenarios
+    const { generateScenariosFromStandards } = require('../../lib/production-scenario-generator');
+    const { appendScenarios } = require('../../lib/production-scenario-appender');
+
+    const missingStandards = { standards: validation.gaps };
+    const newScenarios = await generateScenariosFromStandards(missingStandards);
+
+    await appendScenarios(feature.scenario_file, newScenarios);
+    console.log(`✅ Added ${newScenarios.length} missing scenarios`);
+  } else {
+    console.log('✅ All standards are covered by existing scenarios');
+  }
+} catch (err) {
+  console.error('❌ Validation failed:', err.message);
+  return;
+}
+```
+
+---
+
+### Step 2B: Re-Validate Scenarios (Scenario B - Cold Context)
+
+**For Scenario B only:** Re-validate with current standards.
+
+```javascript
+const { validateScenarios } = require('../../lib/production-scenario-validator');
+const config = require('../../lib/config');
+
+try {
+  console.log('🔄 Re-validating scenarios against current standards...');
+
+  // Check if project state changed
+  const projectConfig = config.read();
+  console.log(`Project state: ${projectConfig.project_state}`);
+
+  // Get feature scenario file
+  const db = getDb();
+  const feature = await new Promise((resolve, reject) => {
+    db.get('SELECT * FROM work_items WHERE id = ?', [featureId], (err, row) => {
+      if (err) reject(err);
+      resolve(row);
+    });
+  });
+
+  // Validate scenarios
+  const validation = await validateScenarios(feature.scenario_file, standards);
+
+  console.log(`✅ Re-validation complete:`);
+  console.log(`  - Covered: ${validation.covered}/${validation.total} standards`);
+  console.log(`  - New gaps: ${validation.gaps.length}`);
+
+  if (validation.hasGaps) {
+    console.log('\n⚠️  Standards added/changed since last run:');
+    validation.gaps.forEach(gap => {
+      console.log(`  - ${gap.domain}: ${gap.standardId}`);
+    });
+
+    // Generate and append missing scenarios
+    const { generateScenariosFromStandards } = require('../../lib/production-scenario-generator');
+    const { appendScenarios } = require('../../lib/production-scenario-appender');
+
+    const missingStandards = { standards: validation.gaps };
+    const newScenarios = await generateScenariosFromStandards(missingStandards);
+
+    await appendScenarios(feature.scenario_file, newScenarios);
+    console.log(`✅ Updated with ${newScenarios.length} new scenarios`);
+  }
+} catch (err) {
+  console.error('❌ Re-validation failed:', err.message);
+  return;
+}
+```
+
+---
+
+### Step 2C: Generate Scenarios (Scenario C - Post-Transition)
+
+**For Scenario C only:** Generate production scenarios from standards.
+
+```javascript
+const { generateScenariosFromStandards } = require('../../lib/production-scenario-generator');
+const { appendScenarios } = require('../../lib/production-scenario-appender');
+const { getDb } = require('../../lib/database');
+
+try {
+  console.log('✨ Generating production scenarios from standards...');
+
+  // Get feature
+  const db = getDb();
+  const feature = await new Promise((resolve, reject) => {
+    db.get('SELECT * FROM work_items WHERE id = ?', [featureId], (err, row) => {
+      if (err) reject(err);
+      resolve(row);
+    });
+  });
+
+  if (!feature.scenario_file) {
+    console.error('❌ Feature has no scenario file.');
+    return;
+  }
+
+  // Generate scenarios
+  const scenarios = await generateScenariosFromStandards(standards);
+
+  console.log(`✅ Generated ${scenarios.length} production scenarios`);
+  console.log('Domains covered:', [...new Set(standards.standards.map(s => s.domain))].join(', '));
+
+  // Append to feature file
+  await appendScenarios(feature.scenario_file, scenarios);
+  console.log(`✅ Appended scenarios to ${feature.scenario_file}`);
+
+  // Create production chores if none exist
+  const { generateChoresFromStandards } = require('../../lib/production-chore-generator');
+  const chores = generateChoresFromStandards(standards, feature.title);
+
+  console.log(`\n📋 Proposed ${chores.length} production chores:`);
+  chores.forEach((chore, i) => {
+    console.log(`\n${i + 1}. ${chore.title}`);
+    console.log(`   ${chore.description.split('\n')[0]}`);
+  });
+
+  console.log('\n✅ Production scenarios ready. Create chores to implement them.');
+} catch (err) {
+  console.error('❌ Scenario generation failed:', err.message);
+  return;
+}
+```
+
+---
+
+### Step 3: Implement Production Chore
+
+**For all scenarios:** Implement the current production chore.
+
+```javascript
+const { getCurrentWork } = require('../../lib/current-work');
+const fs = require('fs');
+
+try {
+  const currentWork = getCurrentWork();
+
+  console.log(`\n🚀 Implementing: ${currentWork.title}`);
+  console.log(`Description: ${currentWork.description}`);
+
+  // Parse chore to understand which standard to implement
+  // Implementation follows the acceptance criteria from the standard
+
+  // Example: If chore is about TLS enforcement
+  // 1. Read the standard's acceptance criteria
+  // 2. Implement code that satisfies the criteria
+  // 3. Add tests based on scenario steps
+
+  console.log('\n✅ Implementation complete');
+  console.log('Run: npx cucumber-js to verify scenarios pass');
+} catch (err) {
+  console.error('❌ Implementation failed:', err.message);
+  return;
+}
+```
+
+---
+
+## Key Differences from Stable Mode
+
+**Stable Mode:**
+- Adds error handling to speed code
+- Validates inputs, handles edge cases
+- Makes existing features robust
+
+**Production Mode:**
+- Hardens features for production deployment
+- Implements security, scale, compliance standards
+- Adds monitoring, backup, failover capabilities
+- Standards-driven (not just adding error handling)
+
+**Example:**
+
+**Stable Mode Chore:** "Add error handling to login feature"
+→ Validates email format, handles network errors, shows error messages
+
+**Production Mode Chore:** "Add security hardening to login feature"
+→ Rate limiting, brute force protection, MFA support, audit logging
+
+---
+
+## Validation
+
+Before completing production mode, ensure:
+- [ ] Context detected correctly (A/B/C)
+- [ ] Production standards read successfully
+- [ ] All production scenarios pass
+- [ ] Security measures implemented per standards
+- [ ] Performance targets met per standards
+- [ ] Compliance requirements satisfied
+- [ ] Monitoring and observability added
+- [ ] Documentation updated
+
+---
+
+## Next Steps After Production Mode
+
+Once all production chores complete:
+1. Feature is production-ready
+2. Can be deployed to external environment
+3. Meets all standards for scale, security, compliance