jettypod 3.0.1

package/lib/production-helpers.js

@@ -0,0 +1,69 @@
+// Production readiness helpers
+const { getDb } = require('./database');
+
+/**
+ * Get all features that are in stable mode and ready for production elevation
+ * @returns {Promise<Array>} Array of feature objects with id, title, description, etc.
+ */
+function getStableFeatures() {
+  const db = getDb();
+
+  return new Promise((resolve, reject) => {
+    db.all(`
+      SELECT *
+      FROM work_items
+      WHERE type = 'feature'
+        AND mode = 'stable'
+        AND phase = 'implementation'
+      ORDER BY id ASC
+    `, [], (err, rows) => {
+      if (err) {
+        return reject(new Error(`Failed to fetch stable features: ${err.message}`));
+      }
+      resolve(rows || []);
+    });
+  });
+}
+
+/**
+ * Create production chores for a given feature
+ * @param {Object} feature - Feature object with id and title
+ * @param {number} epicId - Epic ID to group chores under
+ * @returns {Promise<Array>} Array of created chore IDs
+ */
+async function createProductionChoresForFeature(feature, epicId) {
+  const { create } = require('../features/work-tracking');
+
+  const chores = [
+    {
+      title: `Add security hardening to ${feature.title}`,
+      description: `Add authentication/authorization checks, input sanitization, encryption, and attack protection (XSS, CSRF, injection) for ${feature.title}`
+    },
+    {
+      title: `Add scale testing to ${feature.title}`,
+      description: `Add performance optimization, load testing (100+ concurrent users), caching strategy, and monitoring for ${feature.title}`
+    },
+    {
+      title: `Add compliance requirements to ${feature.title}`,
+      description: `Add GDPR/HIPAA/SOC2 compliance, audit trails, data retention policies, and regulatory requirements for ${feature.title}`
+    }
+  ];
+
+  // Create all chores (chores don't have modes - they inherit context from parent)
+  const choreIds = [];
+  for (const chore of chores) {
+    try {
+      const choreId = await create('chore', chore.title, chore.description, epicId, null, false);
+      choreIds.push(choreId);
+    } catch (err) {
+      throw new Error(`Failed to create production chore: ${err.message}`);
+    }
+  }
+
+  return choreIds;
+}
+
+module.exports = {
+  getStableFeatures,
+  createProductionChoresForFeature
+};

package/lib/project-state.test.js

@@ -0,0 +1,92 @@
+const config = require('./config');
+const fs = require('fs');
+const path = require('path');
+
+describe('Project State', () => {
+  const testDir = path.join('/tmp', 'jettypod-project-state-test-' + Date.now());
+  const testConfigPath = path.join(testDir, 'config.json');
+  const originalPath = config.path;
+
+  beforeEach(() => {
+    config.path = testConfigPath;
+    // SAFETY: Only delete if testDir is in /tmp
+    if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+      fs.rmSync(testDir, { recursive: true });
+    }
+    fs.mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    config.path = originalPath;
+    // SAFETY: Only delete if testDir is in /tmp
+    if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+      fs.rmSync(testDir, { recursive: true });
+    }
+  });
+
+  describe('isValidProjectState', () => {
+    it('should accept "internal" as valid', () => {
+      expect(config.isValidProjectState('internal')).toBe(true);
+    });
+
+    it('should accept "external" as valid', () => {
+      expect(config.isValidProjectState('external')).toBe(true);
+    });
+
+    it('should reject invalid values', () => {
+      expect(config.isValidProjectState('production')).toBe(false);
+      expect(config.isValidProjectState('invalid')).toBe(false);
+      expect(config.isValidProjectState('')).toBe(false);
+    });
+  });
+
+  describe('read', () => {
+    it('should default project_state to "internal" if not exists', () => {
+      const data = config.read();
+      expect(data.project_state).toBe('internal');
+    });
+
+    it('should default project_state to "internal" if invalid value in file', () => {
+      fs.mkdirSync(testDir, { recursive: true });
+      fs.writeFileSync(testConfigPath, JSON.stringify({ name: 'test', project_state: 'invalid' }));
+
+      const data = config.read();
+      expect(data.project_state).toBe('internal');
+    });
+
+    it('should preserve valid project_state from file', () => {
+      fs.mkdirSync(testDir, { recursive: true });
+      fs.writeFileSync(testConfigPath, JSON.stringify({ name: 'test', project_state: 'external' }));
+
+      const data = config.read();
+      expect(data.project_state).toBe('external');
+    });
+  });
+
+  describe('update', () => {
+    it('should update project_state to external', () => {
+      config.write({ name: 'test', project_state: 'internal' });
+      config.update({ project_state: 'external' });
+
+      const data = config.read();
+      expect(data.project_state).toBe('external');
+    });
+
+    it('should reject invalid project_state', () => {
+      config.write({ name: 'test', project_state: 'internal' });
+
+      expect(() => {
+        config.update({ project_state: 'invalid' });
+      }).toThrow('Invalid project_state: invalid');
+    });
+
+    it('should allow updating other fields without affecting project_state', () => {
+      config.write({ name: 'test', project_state: 'internal' });
+      config.update({ description: 'Test project' });
+
+      const data = config.read();
+      expect(data.project_state).toBe('internal');
+      expect(data.description).toBe('Test project');
+    });
+  });
+});

package/lib/test-helpers.js

@@ -0,0 +1,184 @@
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Creates an isolated test directory for testing
+ * @returns {Object} Test context with testDir and originalCwd
+ * @throws {Error} If temporary directory cannot be created
+ */
+function createTestEnvironment() {
+  const originalCwd = process.cwd();
+
+  let testDir;
+  try {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'jettypod-test-'));
+  } catch (err) {
+    throw new Error(`Failed to create test directory: ${err.message}`);
+  }
+
+  return {
+    originalCwd,
+    testDir,
+    cleanup: () => {
+      try {
+        process.chdir(originalCwd);
+      } catch (err) {
+        // Directory may have been deleted, ignore
+      }
+      if (fs.existsSync(testDir)) {
+        try {
+          fs.rmSync(testDir, { recursive: true, force: true });
+        } catch (err) {
+          console.warn(`Warning: Failed to cleanup test directory: ${err.message}`);
+        }
+      }
+    }
+  };
+}
+
+/**
+ * Copies directory recursively, excluding test files
+ * @param {string} src - Source directory
+ * @param {string} dest - Destination directory
+ * @throws {Error} If src doesn't exist, is not a directory, or copy fails
+ */
+function copyDirRecursive(src, dest) {
+  if (!src || typeof src !== 'string') {
+    throw new Error('Source path must be a non-empty string');
+  }
+  if (!dest || typeof dest !== 'string') {
+    throw new Error('Destination path must be a non-empty string');
+  }
+
+  if (!fs.existsSync(src)) {
+    throw new Error(`Source directory does not exist: ${src}`);
+  }
+
+  const srcStat = fs.statSync(src);
+  if (!srcStat.isDirectory()) {
+    throw new Error(`Source is not a directory: ${src}`);
+  }
+
+  try {
+    if (!fs.existsSync(dest)) {
+      fs.mkdirSync(dest, { recursive: true });
+    }
+
+    fs.readdirSync(src).forEach(item => {
+      const srcPath = path.join(src, item);
+      const destPath = path.join(dest, item);
+
+      if (fs.statSync(srcPath).isDirectory()) {
+        copyDirRecursive(srcPath, destPath);
+      } else {
+        // Skip test files when copying
+        if (!item.endsWith('.test.js')) {
+          fs.copyFileSync(srcPath, destPath);
+        }
+      }
+    });
+  } catch (err) {
+    throw new Error(`Failed to copy directory from ${src} to ${dest}: ${err.message}`);
+  }
+}
+
+/**
+ * Runs a JettyPod command in test environment
+ * @param {string} cmd - Command to run (e.g., 'jettypod init')
+ * @param {Object} context - Test context with originalCwd
+ * @returns {string} Command output
+ * @throws {Error} If cmd is invalid or context is missing
+ */
+function runCommand(cmd, context) {
+  if (!cmd || typeof cmd !== 'string') {
+    throw new Error('Command must be a non-empty string');
+  }
+  if (!context || typeof context !== 'object') {
+    throw new Error('Context must be an object');
+  }
+
+  try {
+    const productionJettypodPath = context.originalCwd ?
+      path.join(context.originalCwd, 'jettypod.js') :
+      path.join(process.cwd(), '..', '..', 'jettypod.js');
+
+    if (!fs.existsSync(productionJettypodPath)) {
+      throw new Error(`JettyPod script not found at: ${productionJettypodPath}`);
+    }
+
+    const fullCmd = cmd.replace(/^jettypod/, `node ${productionJettypodPath}`);
+    return execSync(fullCmd, {
+      encoding: 'utf-8',
+      stdio: 'pipe'
+    });
+  } catch (error) {
+    return error.stdout || error.message;
+  }
+}
+
+/**
+ * Reads config.json from .jettypod directory
+ * @returns {Object|null} Config object or null if not found
+ * @throws {Error} If JSON is corrupted or file cannot be read
+ */
+function readConfig() {
+  const configPath = '.jettypod/config.json';
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  try {
+    const content = fs.readFileSync(configPath, 'utf-8');
+    return JSON.parse(content);
+  } catch (err) {
+    if (err instanceof SyntaxError) {
+      throw new Error(`Config file contains invalid JSON: ${err.message}`);
+    }
+    throw new Error(`Failed to read config file: ${err.message}`);
+  }
+}
+
+/**
+ * Reads CLAUDE.md from current directory
+ * @returns {string} CLAUDE.md content or empty string
+ * @throws {Error} If file exists but cannot be read
+ */
+function readClaude() {
+  if (!fs.existsSync('CLAUDE.md')) {
+    return '';
+  }
+
+  try {
+    return fs.readFileSync('CLAUDE.md', 'utf-8');
+  } catch (err) {
+    throw new Error(`Failed to read CLAUDE.md: ${err.message}`);
+  }
+}
+
+/**
+ * Initializes tracking for created files/directories
+ * @param {Object} context - Test context to initialize
+ * @throws {Error} If context is invalid
+ */
+function initializeTracking(context) {
+  if (!context || typeof context !== 'object') {
+    throw new Error('Context must be an object');
+  }
+
+  context.createdFiles = [];
+  context.createdDirs = [];
+  context.modifiedFiles = new Map();
+  context.createdTestDirs = [];
+}
+
+module.exports = {
+  createTestEnvironment,
+  copyDirRecursive,
+  runCommand,
+  readConfig,
+  readClaude,
+  initializeTracking
+};

package/lib/test-helpers.test.js

@@ -0,0 +1,255 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const {
+  createTestEnvironment,
+  copyDirRecursive,
+  runCommand,
+  readConfig,
+  readClaude,
+  initializeTracking
+} = require('./test-helpers');
+
+describe('Test Helpers Module', () => {
+  describe('createTestEnvironment()', () => {
+    test('should create isolated test directory', () => {
+      const env = createTestEnvironment();
+
+      expect(env.testDir).toBeTruthy();
+      expect(fs.existsSync(env.testDir)).toBe(true);
+      expect(env.testDir).toContain('jettypod-test-');
+      expect(env.originalCwd).toBeTruthy();
+
+      env.cleanup();
+    });
+
+    test('should provide cleanup function', () => {
+      const env = createTestEnvironment();
+      const testDir = env.testDir;
+
+      expect(fs.existsSync(testDir)).toBe(true);
+      env.cleanup();
+      expect(fs.existsSync(testDir)).toBe(false);
+    });
+
+    test('should handle cleanup when directory already deleted', () => {
+      const env = createTestEnvironment();
+      fs.rmSync(env.testDir, { recursive: true });
+
+      expect(() => env.cleanup()).not.toThrow();
+    });
+
+    test('should restore original working directory on cleanup', () => {
+      const originalCwd = process.cwd();
+      const env = createTestEnvironment();
+
+      process.chdir(env.testDir);
+      env.cleanup();
+
+      expect(process.cwd()).toBe(originalCwd);
+    });
+  });
+
+  describe('copyDirRecursive()', () => {
+    let testEnv;
+
+    beforeEach(() => {
+      testEnv = createTestEnvironment();
+      process.chdir(testEnv.testDir);
+    });
+
+    afterEach(() => {
+      testEnv.cleanup();
+    });
+
+    test('should copy directory recursively', () => {
+      const srcDir = path.join(testEnv.testDir, 'src');
+      const destDir = path.join(testEnv.testDir, 'dest');
+
+      fs.mkdirSync(srcDir);
+      fs.writeFileSync(path.join(srcDir, 'file1.js'), 'content1');
+      fs.writeFileSync(path.join(srcDir, 'file2.js'), 'content2');
+
+      copyDirRecursive(srcDir, destDir);
+
+      expect(fs.existsSync(path.join(destDir, 'file1.js'))).toBe(true);
+      expect(fs.existsSync(path.join(destDir, 'file2.js'))).toBe(true);
+      expect(fs.readFileSync(path.join(destDir, 'file1.js'), 'utf-8')).toBe('content1');
+    });
+
+    test('should skip .test.js files when copying', () => {
+      const srcDir = path.join(testEnv.testDir, 'src');
+      const destDir = path.join(testEnv.testDir, 'dest');
+
+      fs.mkdirSync(srcDir);
+      fs.writeFileSync(path.join(srcDir, 'file.js'), 'content');
+      fs.writeFileSync(path.join(srcDir, 'file.test.js'), 'test content');
+
+      copyDirRecursive(srcDir, destDir);
+
+      expect(fs.existsSync(path.join(destDir, 'file.js'))).toBe(true);
+      expect(fs.existsSync(path.join(destDir, 'file.test.js'))).toBe(false);
+    });
+
+    test('should copy nested directories', () => {
+      const srcDir = path.join(testEnv.testDir, 'src');
+      const destDir = path.join(testEnv.testDir, 'dest');
+      const nestedDir = path.join(srcDir, 'nested');
+
+      fs.mkdirSync(srcDir);
+      fs.mkdirSync(nestedDir);
+      fs.writeFileSync(path.join(nestedDir, 'file.js'), 'nested content');
+
+      copyDirRecursive(srcDir, destDir);
+
+      expect(fs.existsSync(path.join(destDir, 'nested', 'file.js'))).toBe(true);
+      expect(fs.readFileSync(path.join(destDir, 'nested', 'file.js'), 'utf-8')).toBe('nested content');
+    });
+
+    test('should create destination directory if it does not exist', () => {
+      const srcDir = path.join(testEnv.testDir, 'src');
+      const destDir = path.join(testEnv.testDir, 'dest');
+
+      fs.mkdirSync(srcDir);
+      fs.writeFileSync(path.join(srcDir, 'file.js'), 'content');
+
+      expect(fs.existsSync(destDir)).toBe(false);
+      copyDirRecursive(srcDir, destDir);
+      expect(fs.existsSync(destDir)).toBe(true);
+    });
+
+    test('should throw error for non-existent source directory', () => {
+      const srcDir = path.join(testEnv.testDir, 'nonexistent');
+      const destDir = path.join(testEnv.testDir, 'dest');
+
+      expect(() => copyDirRecursive(srcDir, destDir)).toThrow('Source directory does not exist');
+    });
+
+    test('should throw error for invalid source path', () => {
+      expect(() => copyDirRecursive(null, 'dest')).toThrow('Source path must be a non-empty string');
+      expect(() => copyDirRecursive('', 'dest')).toThrow('Source path must be a non-empty string');
+    });
+
+    test('should throw error for invalid destination path', () => {
+      const srcDir = path.join(testEnv.testDir, 'src');
+      fs.mkdirSync(srcDir);
+
+      expect(() => copyDirRecursive(srcDir, null)).toThrow('Destination path must be a non-empty string');
+      expect(() => copyDirRecursive(srcDir, '')).toThrow('Destination path must be a non-empty string');
+    });
+
+    test('should throw error if source is not a directory', () => {
+      const srcFile = path.join(testEnv.testDir, 'file.js');
+      fs.writeFileSync(srcFile, 'content');
+
+      expect(() => copyDirRecursive(srcFile, 'dest')).toThrow('Source is not a directory');
+    });
+  });
+
+  describe('runCommand()', () => {
+    let testEnv;
+
+    beforeEach(() => {
+      testEnv = createTestEnvironment();
+    });
+
+    afterEach(() => {
+      testEnv.cleanup();
+    });
+
+    test('should throw error for invalid command', () => {
+      expect(() => runCommand(null, testEnv)).toThrow('Command must be a non-empty string');
+      expect(() => runCommand('', testEnv)).toThrow('Command must be a non-empty string');
+    });
+
+    test('should throw error for invalid context', () => {
+      expect(() => runCommand('jettypod --version', null)).toThrow('Context must be an object');
+      expect(() => runCommand('jettypod --version', 'string')).toThrow('Context must be an object');
+    });
+
+    test('should return error message if jettypod.js not found', () => {
+      const invalidContext = { originalCwd: '/nonexistent/path' };
+      const result = runCommand('jettypod --version', invalidContext);
+      expect(result).toContain('JettyPod script not found');
+    });
+  });
+
+  describe('readConfig()', () => {
+    let testEnv;
+
+    beforeEach(() => {
+      testEnv = createTestEnvironment();
+      process.chdir(testEnv.testDir);
+    });
+
+    afterEach(() => {
+      testEnv.cleanup();
+    });
+
+    test('should return null if config file does not exist', () => {
+      expect(readConfig()).toBeNull();
+    });
+
+    test('should read config.json successfully', () => {
+      const jettypodDir = path.join(testEnv.testDir, '.jettypod');
+      fs.mkdirSync(jettypodDir);
+      fs.writeFileSync(
+        path.join(jettypodDir, 'config.json'),
+        JSON.stringify({ mode: 'speed', stage: 'starting' })
+      );
+
+      const config = readConfig();
+      expect(config).toEqual({ mode: 'speed', stage: 'starting' });
+    });
+
+    test('should throw error for corrupted JSON', () => {
+      const jettypodDir = path.join(testEnv.testDir, '.jettypod');
+      fs.mkdirSync(jettypodDir);
+      fs.writeFileSync(path.join(jettypodDir, 'config.json'), 'not valid json');
+
+      expect(() => readConfig()).toThrow('Config file contains invalid JSON');
+    });
+  });
+
+  describe('readClaude()', () => {
+    let testEnv;
+
+    beforeEach(() => {
+      testEnv = createTestEnvironment();
+      process.chdir(testEnv.testDir);
+    });
+
+    afterEach(() => {
+      testEnv.cleanup();
+    });
+
+    test('should return empty string if CLAUDE.md does not exist', () => {
+      expect(readClaude()).toBe('');
+    });
+
+    test('should read CLAUDE.md successfully', () => {
+      fs.writeFileSync('CLAUDE.md', '# Test CLAUDE.md');
+
+      const content = readClaude();
+      expect(content).toBe('# Test CLAUDE.md');
+    });
+  });
+
+  describe('initializeTracking()', () => {
+    test('should initialize tracking properties on context', () => {
+      const context = {};
+      initializeTracking(context);
+
+      expect(context.createdFiles).toEqual([]);
+      expect(context.createdDirs).toEqual([]);
+      expect(context.modifiedFiles).toBeInstanceOf(Map);
+      expect(context.createdTestDirs).toEqual([]);
+    });
+
+    test('should throw error for invalid context', () => {
+      expect(() => initializeTracking(null)).toThrow('Context must be an object');
+      expect(() => initializeTracking('string')).toThrow('Context must be an object');
+      expect(() => initializeTracking(undefined)).toThrow('Context must be an object');
+    });
+  });
+});

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "jettypod",
+  "version": "3.0.1",
+  "description": "Simplified development mode manager",
+  "main": "jettypod.js",
+  "bin": {
+    "jettypod": "./jettypod.js"
+  },
+  "scripts": {
+    "test": "npm run test:unit && npm run test:bdd && npm run test:cleanup",
+    "test:bdd": "NODE_ENV=test cucumber-js",
+    "test:unit": "NODE_ENV=test jest",
+    "test:unit:watch": "NODE_ENV=test jest --watch",
+    "test:cleanup": "node -e \"const fs = require('fs'); const path = require('path'); const testDb = path.join(process.cwd(), '.jettypod', 'test-work.db'); if (fs.existsSync(testDb)) { fs.unlinkSync(testDb); console.log('✅ Cleaned up test database'); }\""
+  },
+  "devDependencies": {
+    "@cucumber/cucumber": "^10.0.1",
+    "chai": "^6.0.1",
+    "jest": "^30.1.3"
+  },
+  "jest": {
+    "testEnvironment": "node",
+    "testMatch": [
+      "**/__tests__/**/*.js",
+      "**/*.test.js"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "collectCoverage": false,
+    "coverageDirectory": "coverage"
+  },
+  "dependencies": {
+    "sqlite3": "^5.1.7"
+  }
+}

package/prototypes/test/index.html

@@ -0,0 +1 @@
+test