jettypod 3.0.1

package/features/skills-update/index.test.js

@@ -0,0 +1,216 @@
+const fs = require('fs');
+const path = require('path');
+const { createTestEnvironment } = require('../../lib/test-helpers');
+const { execSync } = require('child_process');
+
+/**
+ * End-to-end tests for skills update functionality
+ * Tests the BDD scenarios from features/always-update-skills.feature
+ */
+describe('Skills Update on JettyPod Init', () => {
+  let testEnv;
+  let jettypodPath;
+  let skillsSourceDir;
+
+  beforeEach(() => {
+    testEnv = createTestEnvironment();
+    process.chdir(testEnv.testDir);
+
+    // Path to jettypod script (relative to test directory)
+    jettypodPath = path.join(__dirname, '..', '..', 'jettypod.js');
+
+    // SAFETY: Create mock skills source directory in /tmp/ test environment, NOT in actual project
+    skillsSourceDir = path.join(testEnv.testDir, 'mock-jettypod-skills');
+    if (!fs.existsSync(skillsSourceDir)) {
+      fs.mkdirSync(skillsSourceDir, { recursive: true });
+    }
+
+    // Create sample skills for testing
+    const speedModeSkillDir = path.join(skillsSourceDir, 'speed-mode');
+    fs.mkdirSync(speedModeSkillDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(speedModeSkillDir, 'SKILL.md'),
+      '# Speed Mode Skill\nTest content for speed mode skill'
+    );
+
+    const stableModeSkillDir = path.join(skillsSourceDir, 'stable-mode');
+    fs.mkdirSync(stableModeSkillDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(stableModeSkillDir, 'SKILL.md'),
+      '# Stable Mode Skill\nTest content for stable mode skill'
+    );
+
+    // Configure jettypod to use mock skills source
+    process.env.JETTYPOD_SKILLS_SOURCE_DIR = skillsSourceDir;
+  });
+
+  afterEach(() => {
+    // Clean up environment variable
+    delete process.env.JETTYPOD_SKILLS_SOURCE_DIR;
+    testEnv.cleanup();
+  });
+
+  describe('Scenario: Skills are updated when initializing existing project', () => {
+    test('should backup existing skills before updating', () => {
+      // Given: I have a project with old .claude/skills/ directory
+      const claudeDir = path.join(testEnv.testDir, '.claude');
+      const oldSkillsDir = path.join(claudeDir, 'skills');
+      fs.mkdirSync(oldSkillsDir, { recursive: true });
+
+      const oldSkillDir = path.join(oldSkillsDir, 'old-skill');
+      fs.mkdirSync(oldSkillDir, { recursive: true });
+      fs.writeFileSync(
+        path.join(oldSkillDir, 'SKILL.md'),
+        '# Old Skill\nThis is an old skill that should be backed up'
+      );
+
+      // When: I run jettypod in the project directory
+      execSync(`node ${jettypodPath}`, { stdio: 'pipe', env: { ...process.env } });
+
+      // Then: old skills are backed up before replacement
+      const backupDirs = fs.readdirSync(claudeDir).filter(name => name.startsWith('skills.backup-'));
+      expect(backupDirs.length).toBe(1);
+
+      const backupDir = path.join(claudeDir, backupDirs[0]);
+      expect(fs.existsSync(backupDir)).toBe(true);
+
+      // Verify old skill is in backup
+      const backedUpSkillFile = path.join(backupDir, 'old-skill', 'SKILL.md');
+      expect(fs.existsSync(backedUpSkillFile)).toBe(true);
+      const backedUpContent = fs.readFileSync(backedUpSkillFile, 'utf8');
+      expect(backedUpContent).toContain('This is an old skill that should be backed up');
+    });
+
+    test('should replace skills with latest from jettypod', () => {
+      // Given: I have a project with old .claude/skills/ directory
+      const claudeDir = path.join(testEnv.testDir, '.claude');
+      const oldSkillsDir = path.join(claudeDir, 'skills');
+      fs.mkdirSync(oldSkillsDir, { recursive: true });
+
+      const oldSkillDir = path.join(oldSkillsDir, 'old-skill');
+      fs.mkdirSync(oldSkillDir, { recursive: true });
+      fs.writeFileSync(path.join(oldSkillDir, 'SKILL.md'), '# Old Skill');
+
+      // When: I run jettypod in the project directory
+      execSync(`node ${jettypodPath}`, { stdio: 'pipe', env: { ...process.env } });
+
+      // Then: .claude/skills/ is replaced with latest skills from jettypod
+      const newSkillsDir = path.join(testEnv.testDir, '.claude', 'skills');
+      expect(fs.existsSync(newSkillsDir)).toBe(true);
+
+      // Old skill should be gone
+      expect(fs.existsSync(path.join(newSkillsDir, 'old-skill'))).toBe(false);
+
+      // New skills should be present
+      expect(fs.existsSync(path.join(newSkillsDir, 'speed-mode', 'SKILL.md'))).toBe(true);
+      expect(fs.existsSync(path.join(newSkillsDir, 'stable-mode', 'SKILL.md'))).toBe(true);
+
+      // Verify content is from jettypod source
+      const speedModeContent = fs.readFileSync(
+        path.join(newSkillsDir, 'speed-mode', 'SKILL.md'),
+        'utf8'
+      );
+      expect(speedModeContent).toContain('Test content for speed mode skill');
+    });
+
+    test('should handle concurrent inits with unique backup names', () => {
+      // Given: I have a project with .claude/skills/ directory
+      const claudeDir = path.join(testEnv.testDir, '.claude');
+      const skillsDir = path.join(claudeDir, 'skills');
+      fs.mkdirSync(skillsDir, { recursive: true });
+      fs.writeFileSync(path.join(skillsDir, 'test.md'), 'test');
+
+      // Manually create a backup with current timestamp format
+      const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+      const existingBackup = path.join(claudeDir, `skills.backup-${timestamp}`);
+      fs.mkdirSync(existingBackup, { recursive: true });
+      fs.writeFileSync(path.join(existingBackup, 'existing.md'), 'existing');
+
+      // Restore skills dir for the actual init
+      if (fs.existsSync(skillsDir)) {
+        fs.rmSync(skillsDir, { recursive: true, force: true });
+      }
+      fs.mkdirSync(skillsDir, { recursive: true });
+      fs.writeFileSync(path.join(skillsDir, 'test.md'), 'test');
+
+      // When: I run jettypod (which creates another backup with same timestamp)
+      execSync(`node ${jettypodPath}`, { stdio: 'pipe', env: { ...process.env } });
+
+      // Then: backup directory should have counter appended
+      const backupDirs = fs.readdirSync(claudeDir)
+        .filter(name => name.startsWith('skills.backup-'))
+        .sort();
+
+      // Should have at least 2 backups (the manual one and the new one)
+      expect(backupDirs.length).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  describe('Scenario: Skills are copied when initializing new project', () => {
+    test('should create .claude/skills/ with latest skills', () => {
+      // Given: I have a new project with no .claude/ directory
+      // (testEnv starts clean)
+
+      // When: I run jettypod to initialize
+      execSync(`node ${jettypodPath}`, { stdio: 'pipe', env: { ...process.env } });
+
+      // Then: .claude/skills/ is created with latest skills from jettypod
+      const skillsDir = path.join(testEnv.testDir, '.claude', 'skills');
+      expect(fs.existsSync(skillsDir)).toBe(true);
+
+      // And: all skills are ready to use
+      expect(fs.existsSync(path.join(skillsDir, 'speed-mode', 'SKILL.md'))).toBe(true);
+      expect(fs.existsSync(path.join(skillsDir, 'stable-mode', 'SKILL.md'))).toBe(true);
+
+      const speedModeContent = fs.readFileSync(
+        path.join(skillsDir, 'speed-mode', 'SKILL.md'),
+        'utf8'
+      );
+      expect(speedModeContent).toContain('Test content for speed mode skill');
+    });
+
+    test('should not create backup when no existing skills', () => {
+      // Given: I have a new project with no .claude/ directory
+      // When: I run jettypod to initialize
+      execSync(`node ${jettypodPath}`, { stdio: 'pipe', env: { ...process.env } });
+
+      // Then: no backup should be created
+      const claudeDir = path.join(testEnv.testDir, '.claude');
+      const backupDirs = fs.readdirSync(claudeDir).filter(name => name.startsWith('skills.backup-'));
+      expect(backupDirs.length).toBe(0);
+    });
+  });
+
+  describe('Error handling validation', () => {
+    test('should handle source directory missing gracefully', () => {
+      // Remove skills source directory
+      if (fs.existsSync(skillsSourceDir)) {
+        fs.rmSync(skillsSourceDir, { recursive: true, force: true });
+      }
+
+      // Should not throw, just warn
+      expect(() => {
+        execSync(`node ${jettypodPath}`, { stdio: 'pipe', env: { ...process.env } });
+      }).not.toThrow();
+
+      // .claude should still be created
+      expect(fs.existsSync(path.join(testEnv.testDir, '.claude'))).toBe(true);
+    });
+
+    test('should handle empty source directory gracefully', () => {
+      // Empty the skills source directory
+      if (fs.existsSync(skillsSourceDir)) {
+        fs.rmSync(skillsSourceDir, { recursive: true, force: true });
+      }
+      fs.mkdirSync(skillsSourceDir, { recursive: true });
+
+      // Should not throw, just warn
+      expect(() => {
+        execSync(`node ${jettypodPath}`, { stdio: 'pipe', env: { ...process.env } });
+      }).not.toThrow();
+
+      // .claude should still be created
+      expect(fs.existsSync(path.join(testEnv.testDir, '.claude'))).toBe(true);
+    });
+  });
+});

package/features/step_definitions/auto-generate-production-chores.steps.js

@@ -0,0 +1,162 @@
+const { Given, When, Then, AfterAll } = require('@cucumber/cucumber');
+const assert = require('assert');
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+
+const testDir = path.join('/tmp', 'jettypod-production-chores-test-' + Date.now());
+const jettypodDir = path.join(testDir, '.jettypod');
+const configPath = path.join(jettypodDir, 'config.json');
+const dbFileName = process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db';
+const dbPath = path.join(jettypodDir, dbFileName);
+
+let testContext = {};
+let originalDir = process.cwd();
+
+// Setup test environment
+async function setupTestEnv() {
+  // SAFETY: Only delete if testDir is in /tmp
+  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(testDir, { recursive: true });
+  fs.mkdirSync(jettypodDir, { recursive: true });
+  process.chdir(testDir);
+
+  // Initialize git
+  execSync('git init', { stdio: 'pipe' });
+  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
+  execSync('git config user.name "Test"', { stdio: 'pipe' });
+
+  // Initialize database
+  const { getDb } = require('../../lib/database');
+  const { runMigrations } = require('../../lib/migrations');
+  const db = getDb();
+  await runMigrations(db);
+}
+
+// Cleanup test environment
+async function cleanupTestEnv() {
+  const { closeDb } = require('../../lib/database');
+  const { resetDb } = require('../../lib/database');
+  await closeDb();
+  resetDb();
+
+  if (fs.existsSync(testDir)) {
+    process.chdir(originalDir);
+    fs.rmSync(testDir, { recursive: true, force: true });
+  }
+  testContext = {};
+}
+
+// Given steps
+Given('I have a project with {int} features in stable mode', async function (featureCount) {
+  await setupTestEnv();
+
+  // Create config
+  const config = {
+    name: 'test-project',
+    project_state: 'internal',
+    project_discovery: {
+      status: 'completed'
+    }
+  };
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+
+  // Create features in database
+  const sqlite3 = require('sqlite3').verbose();
+  const db = new sqlite3.Database(dbPath);
+
+  for (let i = 1; i <= featureCount; i++) {
+    await new Promise((resolve) => {
+      db.run(
+        `INSERT INTO work_items (id, type, title, status, mode, phase) VALUES (?, 'feature', ?, 'completed', 'stable', 'implementation')`,
+        [i, `Feature ${i}`],
+        resolve
+      );
+    });
+  }
+
+  testContext.featureCount = featureCount;
+});
+
+Given('the project state is {string}', function (state) {
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  assert.strictEqual(config.project_state, state);
+});
+
+// When steps
+When('I transition the project to external', function () {
+  try {
+    testContext.output = execSync(
+      `node ${path.join(originalDir, 'jettypod.js')} project external`,
+      { cwd: testDir, encoding: 'utf-8' }
+    );
+  } catch (err) {
+    testContext.error = err.message;
+    testContext.output = err.stdout || '';
+  }
+});
+
+// Then steps
+Then('the project state is set to {string}', function (expectedState) {
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+  assert.strictEqual(config.project_state, expectedState);
+});
+
+Then('a {string} epic is created', function (epicTitle) {
+  const sqlite3 = require('sqlite3').verbose();
+  const db = new sqlite3.Database(dbPath);
+
+  return new Promise((resolve) => {
+    db.get(
+      `SELECT * FROM work_items WHERE type = 'epic' AND title = ?`,
+      [epicTitle],
+      (err, row) => {
+        assert(row, `Epic "${epicTitle}" should exist`);
+        testContext.epicId = row.id;
+        resolve();
+      }
+    );
+  });
+});
+
+Then('{int} production chores are created for each stable feature', function (choresPerFeature) {
+  const sqlite3 = require('sqlite3').verbose();
+  const db = new sqlite3.Database(dbPath);
+
+  return new Promise((resolve) => {
+    db.all(
+      `SELECT * FROM work_items WHERE type = 'chore' AND parent_id = ?`,
+      [testContext.epicId],
+      (err, rows) => {
+        const expectedTotal = testContext.featureCount * choresPerFeature;
+        assert.strictEqual(rows.length, expectedTotal, `Should have ${expectedTotal} production chores`);
+        testContext.productionChores = rows;
+        resolve();
+      }
+    );
+  });
+});
+
+Then('the chores are grouped under the epic', function () {
+  const choresUnderEpic = testContext.productionChores.filter(
+    chore => chore.parent_id === testContext.epicId
+  );
+  assert.strictEqual(
+    choresUnderEpic.length,
+    testContext.productionChores.length,
+    'All production chores should be under the epic'
+  );
+});
+
+Then('I see a summary of created chores', function () {
+  assert(testContext.output.includes('production chores'), 'Output should mention production chores');
+  assert(testContext.output.includes('Feature Production Readiness'), 'Output should mention the epic');
+});
+
+// Cleanup after all scenarios complete (AfterAll allows async operations)
+AfterAll(async function() {
+  const { closeDb } = require('../../lib/database');
+  await closeDb();
+});

package/features/step_definitions/terminal-logo.steps.js

@@ -0,0 +1,145 @@
+const { Given, When, Then } = require('@cucumber/cucumber');
+const assert = require('assert');
+const path = require('path');
+const fs = require('fs');
+
+Given('the logo module exists', function () {
+  const logoPath = path.join(__dirname, '../../lib/logo.js');
+  assert(fs.existsSync(logoPath), `Logo module should exist at ${logoPath}`);
+  this.logoPath = logoPath;
+});
+
+When('I import it', function () {
+  // Import the logo module
+  this.logoModule = require(this.logoPath);
+});
+
+Then('it exports a {string} function', function (functionName) {
+  assert(this.logoModule, 'Logo module should be imported');
+  assert(typeof this.logoModule[functionName] === 'function', `Should export a ${functionName} function`);
+  this.exportedFunction = this.logoModule[functionName];
+});
+
+When('I call the showLogo function', function () {
+  // Capture console.log output
+  const originalLog = console.log;
+  const logOutput = [];
+
+  console.log = (...args) => {
+    logOutput.push(args.join(' '));
+  };
+
+  try {
+    // Call the showLogo function
+    const { showLogo } = require('../../lib/logo.js');
+    showLogo();
+  } finally {
+    console.log = originalLog;
+  }
+
+  this.logoOutput = logOutput;
+});
+
+Then('it outputs {int} lines of logo art', function (expectedLines) {
+  assert(this.logoOutput, 'Logo output should exist');
+  // Count total lines across all console.log calls (split by newlines)
+  const totalLines = this.logoOutput.reduce((count, output) => {
+    return count + output.split('\n').filter(line => line.trim().length > 0).length;
+  }, 0);
+  assert(totalLines >= expectedLines,
+    `Expected at least ${expectedLines} lines but got ${totalLines}`);
+});
+
+Then('it includes the version subtitle', function () {
+  assert(this.logoOutput, 'Logo output should exist');
+  const hasVersionLine = this.logoOutput.some(line =>
+    line.includes('version') || line.includes('v') || line.includes('.')
+  );
+  assert(hasVersionLine, 'Logo should include version subtitle');
+});
+
+When('I run jettypod init', function () {
+  const { execSync } = require('child_process');
+  const jettypodPath = path.join(__dirname, '../../jettypod.js');
+  const skillsSourceDir = path.join(__dirname, '../../.claude/skills');
+
+  try {
+    const output = execSync(`node ${jettypodPath} init`, {
+      cwd: this.testDir || process.cwd(),
+      encoding: 'utf-8',
+      env: { ...process.env, JETTYPOD_SKILLS_SOURCE_DIR: skillsSourceDir }
+    });
+    this.initOutput = output;
+  } catch (err) {
+    this.initOutput = err.stdout || '';
+    this.initError = err;
+  }
+});
+
+Then('the output contains the unicode gradient logo', function () {
+  assert(this.initOutput || this.commandOutput, 'Should have output from jettypod init');
+  const output = this.initOutput || this.commandOutput;
+
+  // Check for DEV or POD in the output
+  const hasLogo = output.includes('DEV') || output.includes('POD') ||
+                  output.includes('█') || output.includes('▓') ||
+                  output.includes('▒') || output.includes('░');
+
+  assert(hasLogo, 'Output should contain unicode gradient logo characters');
+});
+
+Then('I see the unicode logo', function () {
+  assert(this.initOutput || this.commandOutput, 'Should have output from jettypod init');
+  const output = this.initOutput || this.commandOutput;
+
+  const hasLogo = output.includes('DEV') || output.includes('POD') ||
+                  output.includes('█') || output.includes('▓');
+
+  assert(hasLogo, 'Should see unicode logo in output');
+});
+
+Then('the logo includes {string} and {string} text', function (text1, text2) {
+  const output = this.initOutput || this.commandOutput;
+  assert(output, 'Should have output');
+  // The logo uses box-drawing characters, not literal text
+  // Just check that the output has the box characters that form the logo
+  const hasBoxChars = output.includes('█') || output.includes('╔') || output.includes('║');
+  assert(hasBoxChars, `Logo should include box-drawing characters (forms ${text1} and ${text2})`);
+});
+
+Then('the logo uses ANSI color codes', function () {
+  const output = this.initOutput || this.commandOutput;
+  assert(output, 'Should have output');
+
+  // Check for ANSI escape codes
+  const hasAnsiCodes = output.includes('\x1b[') || output.includes('\u001b[');
+  assert(hasAnsiCodes, 'Logo should use ANSI color codes');
+});
+
+Then('the .jettypod directory is created', function () {
+  const jettypodDir = path.join(this.testDir || process.cwd(), '.jettypod');
+  assert(fs.existsSync(jettypodDir), '.jettypod directory should be created');
+
+  // Verify it contains expected files
+  const configPath = path.join(jettypodDir, 'config.json');
+  assert(fs.existsSync(configPath), 'config.json should exist in .jettypod directory');
+});
+
+Then('git hooks are installed', function () {
+  const hooksDir = path.join(this.testDir || process.cwd(), '.git', 'hooks');
+
+  // Check if .git directory exists (it might not if init was run without git)
+  const gitDir = path.join(this.testDir || process.cwd(), '.git');
+  if (!fs.existsSync(gitDir)) {
+    // Skip this check if not a git repo
+    return;
+  }
+
+  // Check for post-commit hook
+  const postCommitHook = path.join(hooksDir, 'post-commit');
+  assert(fs.existsSync(postCommitHook), 'post-commit hook should be installed');
+
+  // Check for post-merge hook
+  const postMergeHook = path.join(hooksDir, 'post-merge');
+  assert(fs.existsSync(postMergeHook), 'post-merge hook should be installed');
+});