jettypod 4.1.2 → 4.1.4

package/features/work-commands/steps.js

@@ -1,1174 +0,0 @@
-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 sqlite3 = require('sqlite3').verbose();
-const workCommands = require('./index');
-const { resetDb } = require('../../lib/database');
-const { runMigrations } = require('../../lib/migrations');
-
-const testDir = path.join('/tmp', 'jettypod-work-commands-test-' + Date.now());
-
-// Dynamic getters for paths that update when directory changes
-function getJettypodDir() {
-  return path.join(process.cwd(), '.jettypod');
-}
-
-function getDbPath() {
-  const dbFileName = process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db';
-  return path.join(getJettypodDir(), dbFileName);
-}
-
-function getCurrentWorkPath() {
-  return path.join(getJettypodDir(), 'current-work.json');
-}
-
-// Helper to get database connection (always use singleton)
-function getTestDb() {
-  const { getDb } = require('../../lib/database');
-  return getDb();
-}
-
-// Keep these for backward compatibility in some steps that use testDir
-const jettypodDir = path.join(testDir, '.jettypod');
-const dbFileName = process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db';
-const dbPath = path.join(jettypodDir, dbFileName);
-const currentWorkPath = path.join(jettypodDir, 'current-work.json');
-const claudePath = path.join(testDir, 'CLAUDE.md');
-
-// Test state
-let testContext = {};
-let originalDir = process.cwd(); // Store original directory for CLI tests
-
-// Helper to ensure NODE_ENV=test is always set for test execSync calls
-function testExecSync(command, options = {}) {
-  const env = { ...process.env, NODE_ENV: 'test', ...options.env };
-  return execSync(command, { ...options, env });
-}
-
-// Setup test environment
-async function setupTestEnv() {
-  // Reset singleton db connection to avoid stale connections
-  const { closeDb } = require('../../lib/database');
-  await closeDb();
-  resetDb();
-
-  // 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(getJettypodDir(), { recursive: true });
-
-  // Change to test directory
-  process.chdir(testDir);
-
-  // Initialize git
-  try {
-    execSync('git init', { stdio: 'pipe' });
-    execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
-    execSync('git config user.name "Test"', { stdio: 'pipe' });
-    execSync('git checkout -b main', { stdio: 'pipe' });
-  } catch (e) {
-    // Git already initialized
-  }
-
-  // Use singleton getDb() to initialize database
-  const { getDb } = require('../../lib/database');
-  const db = getDb();
-
-  // Run all migrations to ensure schema is up to date
-  await runMigrations(db);
-
-  // Don't close - let singleton manage it
-}
-
-// Cleanup test environment
-async function cleanupTestEnv() {
-  const { closeDb } = require('../../lib/database');
-  await closeDb();
-  resetDb();
-
-  // SAFETY: Only delete if testDir is in /tmp
-  if (fs.existsSync(testDir) && testDir.startsWith('/tmp/')) {
-    process.chdir(originalDir);
-    fs.rmSync(testDir, { recursive: true, force: true });
-  }
-  testContext = {};
-}
-
-// Before each scenario
-Given('a work item exists with id {string} and title {string}', async function (id, title) {
-  await setupTestEnv();
-  return new Promise((resolve) => {
-    const db = getTestDb();
-    db.run(`INSERT INTO work_items (id, type, title, status) VALUES (?, 'feature', ?, 'todo')`, [parseInt(id), title], () => {
-      // Removed db.close() - let Node.js handle cleanup
-      resolve();
-    });
-  });
-});
-
-Given('a work item exists with id {string} title {string} parent {string} and type {string}', async function (id, title, parentId, type) {
-  if (!fs.existsSync(testDir)) await setupTestEnv();
-  return new Promise((resolve) => {
-    const db = getTestDb();
-    db.run(`INSERT INTO work_items (id, type, title, status, parent_id) VALUES (?, ?, ?, 'todo', ?)`,
-      [parseInt(id), type, title, parseInt(parentId)], () => {
-        // Removed db.close() - let Node.js handle cleanup
-        resolve();
-      });
-  });
-});
-
-Given('a work item exists with id {string} title {string} and type {string}', async function (id, title, type) {
-  if (!fs.existsSync(testDir)) await setupTestEnv();
-  return new Promise((resolve) => {
-    const db = getTestDb();
-    const idInt = parseInt(id);
-    db.run(`INSERT INTO work_items (id, type, title, status) VALUES (?, ?, ?, 'todo')`,
-      [idInt, type, title], () => {
-      // Removed db.close() - let Node.js handle cleanup
-      resolve();
-    });
-  });
-});
-
-Given('a work item exists with id {string} title {string} and status {string}', async function (id, title, status) {
-  if (!fs.existsSync(testDir)) await setupTestEnv();
-  return new Promise((resolve) => {
-    const db = getTestDb();
-    db.run(`INSERT INTO work_items (id, type, title, status) VALUES (?, 'feature', ?, ?)`, [parseInt(id), title, status], () => {
-      // Removed db.close() - let Node.js handle cleanup
-      resolve();
-    });
-  });
-});
-
-Given('work item {string} is currently active with status {string}', async function (id, status) {
-  await setupTestEnv();
-  return new Promise((resolve) => {
-    const db = getTestDb();
-    db.run(`INSERT INTO work_items (id, type, title, status) VALUES (?, 'feature', 'Test Item', ?)`, [parseInt(id), status], () => {
-      // Removed db.close() - let Node.js handle cleanup
-      const currentWork = {
-        id: parseInt(id),
-        title: 'Test Item',
-        type: 'feature',
-        status: status
-      };
-      fs.writeFileSync(getCurrentWorkPath(), JSON.stringify(currentWork, null, 2));
-      resolve();
-    });
-  });
-});
-
-Given('CLAUDE.md exists with mode {string}', async function (mode) {
-  if (!fs.existsSync(testDir)) await setupTestEnv();
-  const content = `<claude_context project="test">
-<project_summary>
-Test project
-</project_summary>
-<mode>${mode}</mode>
-</claude_context>`;
-  fs.writeFileSync(claudePath, content);
-});
-
-Given('I am on branch {string}', function (branch) {
-  try {
-    execSync(`git checkout -b ${branch}`, { stdio: 'pipe' });
-  } catch (e) {
-    execSync(`git checkout ${branch}`, { stdio: 'pipe' });
-  }
-});
-
-When('I run {string}', async function (command) {
-  const parts = command.split(' ');
-  if (parts[0] === 'jettypod' && parts[1] === 'work' && parts[2] === 'start') {
-    const id = parseInt(parts[3]);
-    const result = await workCommands.startWork(id);
-    testContext.output = `Working on: [#${result.workItem.id}] ${result.workItem.title} (${result.workItem.type})`;
-    if (result.workItem.parent_title) {
-      testContext.output = `Working on: [#${result.workItem.id}] ${result.workItem.title} (${result.workItem.type} of #${result.workItem.parent_id} ${result.workItem.parent_title})`;
-    }
-  } else if (parts[0] === 'jettypod' && (parts[1] === 'init' || parts.length === 1)) {
-    // Capture output for jettypod init
-    const originalLog = console.log;
-    let capturedOutput = '';
-    console.log = (...args) => {
-      capturedOutput += args.join(' ') + '\n';
-      originalLog(...args);
-    };
-
-    // Ensure testDir exists or use current directory
-    const workDir = (testDir && fs.existsSync(testDir)) ? testDir : process.cwd();
-
-    try {
-      const output = execSync(
-        `node ${path.join(__dirname, '../../jettypod.js')} ${parts.slice(1).join(' ')}`,
-        { cwd: workDir, encoding: 'utf-8' }
-      );
-      capturedOutput += output;
-    } catch (err) {
-      capturedOutput += err.stdout || '';
-    } finally {
-      console.log = originalLog;
-    }
-
-    testContext.commandOutput = capturedOutput;
-    testContext.initOutput = capturedOutput;
-    // Also set on 'this' for other step files (e.g., terminal-logo tests)
-    this.commandOutput = capturedOutput;
-    this.initOutput = capturedOutput;
-  } else if (parts[0] === 'jettypod') {
-    // Handle other jettypod commands (backlog, etc.)
-    const workDir = (testDir && fs.existsSync(testDir)) ? testDir : process.cwd();
-
-    try {
-      const output = execSync(
-        `node ${path.join(__dirname, '../../jettypod.js')} ${parts.slice(1).join(' ')}`,
-        { cwd: workDir, encoding: 'utf-8' }
-      );
-      testContext.commandOutput = output;
-      this.commandOutput = output;
-    } catch (err) {
-      testContext.commandOutput = err.stdout || '';
-      this.commandOutput = err.stdout || '';
-    }
-  }
-});
-
-When('I run {string} and enter status {string}', async function (command, status) {
-  await workCommands.stopWork(status);
-});
-
-Then('the current work file should contain work item {string}', function (id) {
-  assert(fs.existsSync(getCurrentWorkPath()), 'Current work file does not exist');
-  const currentWork = JSON.parse(fs.readFileSync(getCurrentWorkPath(), 'utf-8'));
-  assert.strictEqual(currentWork.id, parseInt(id));
-});
-
-Then('the work item {string} status should be {string}', function (id, status) {
-  const db = getTestDb();
-  return new Promise((resolve) => {
-    db.get(`SELECT status FROM work_items WHERE id = ?`, [parseInt(id)], (err, row) => {
-      // Removed db.close() - let Node.js handle cleanup
-      assert.strictEqual(row.status, status);
-      resolve();
-    });
-  });
-});
-
-Then('a feature branch {string} should be created', function (branchName) {
-  const branches = execSync('git branch', { encoding: 'utf-8' });
-  assert(branches.includes(branchName), `Branch ${branchName} not found`);
-});
-
-Then('CLAUDE.md current_work should show {string}', function (text) {
-  const content = fs.readFileSync(claudePath, 'utf-8');
-  assert(content.includes(text), `CLAUDE.md does not contain: ${text}`);
-});
-
-Then('the current work file should be empty', function () {
-  assert(!fs.existsSync(getCurrentWorkPath()), 'Current work file still exists');
-});
-
-Then('the output should contain {string}', function (text) {
-  assert(testContext.output && testContext.output.includes(text), `Output does not contain: ${text}`);
-});
-
-Then('CLAUDE.md mode should still be {string}', function (mode) {
-  const content = fs.readFileSync(claudePath, 'utf-8');
-  const modeMatch = content.match(/<mode>(.*?)<\/mode>/);
-  assert(modeMatch && modeMatch[1] === mode, `Mode is not ${mode}`);
-});
-
-Then('I should be on branch {string}', function (branchName) {
-  const currentBranch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
-  assert.strictEqual(currentBranch, branchName);
-});
-
-// Stable tests steps
-
-Given('jettypod is initialized', async function () {
-  await setupTestEnv();
-});
-
-Given('jettypod is not initialized', function () {
-  // 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 });
-  process.chdir(testDir);
-  // Don't create .jettypod directory
-});
-
-Given('I have current work', async function () {
-  await setupTestEnv();
-  return new Promise((resolve) => {
-    const db = getTestDb();
-    db.run(`INSERT INTO work_items (id, type, title, status) VALUES (1, 'feature', 'Test Work', 'in_progress')`, () => {
-      // Removed db.close() - let Node.js handle cleanup
-      const currentWork = {
-        id: 1,
-        title: 'Test Work',
-        type: 'feature',
-        status: 'in_progress'
-      };
-      fs.writeFileSync(getCurrentWorkPath(), JSON.stringify(currentWork, null, 2));
-      resolve();
-    });
-  });
-});
-
-Given('no work is active', function () {
-  if (fs.existsSync(getCurrentWorkPath())) {
-    fs.unlinkSync(getCurrentWorkPath());
-  }
-});
-
-Given('current work file is corrupted', async function () {
-  await setupTestEnv();
-  fs.writeFileSync(getCurrentWorkPath(), 'invalid json {{{');
-});
-
-Given('jettypod is initialized without git', function (done) {
-  // Reset database singleton to avoid issues with previous tests
-  resetDb();
-
-  // 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 });
-  process.chdir(testDir);  // Change directory BEFORE creating .jettypod
-  fs.mkdirSync(getJettypodDir(), { recursive: true });
-
-  // Initialize database but no git - use proper migrations
-  const db = getTestDb();
-  runMigrations(db).then(() => done()).catch(done);
-});
-
-Given('I have a work item', async function () {
-  // Check if we need full setup (including git) or just database
-  const dbPath = path.join(getJettypodDir(), process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db');
-  const needsSetup = !fs.existsSync(dbPath);
-
-  if (needsSetup) {
-    // Check if we're in a git-free test (testDir exists but no .git)
-    const isWithoutGit = fs.existsSync(testDir) && !fs.existsSync(path.join(testDir, '.git'));
-    if (!isWithoutGit) {
-      await setupTestEnv();
-    }
-  }
-
-  return new Promise((resolve) => {
-    const db = getTestDb();
-    db.run(`INSERT INTO work_items (id, type, title, status) VALUES (1, 'feature', 'Test Item', 'todo')`, () => {
-      testContext.workItemId = 1;
-      this.workItemId = 1; // Also set on this for git-hooks steps compatibility
-      resolve();
-    });
-  });
-});
-
-Given('I start work on it', function () {
-  // Check if workItemId is in testContext or this (from other step files)
-  const workItemId = testContext.workItemId || this.workItemId;
-
-  // Use CLI to avoid database singleton issues across test contexts
-  try {
-    testExecSync(`node ${path.join(__dirname, '../../jettypod.js')} work start ${workItemId}`, { cwd: testDir, stdio: 'pipe' });
-    testContext.firstWorkItemId = workItemId;
-  } catch (err) {
-    // If CLI fails, try direct module call
-    return workCommands.startWork(workItemId).then(result => {
-      testContext.firstWorkItemId = result.workItem.id;
-    });
-  }
-});
-
-When('I try to start work with ID {string}', async function (id) {
-  try {
-    await workCommands.startWork(id);
-    testContext.error = null;
-  } catch (err) {
-    testContext.error = err.message;
-  }
-});
-
-When('I try to stop work with status {string}', async function (status) {
-  try {
-    await workCommands.stopWork(status);
-    testContext.error = null;
-  } catch (err) {
-    testContext.error = err.message;
-  }
-});
-
-When('I try to stop work', async function () {
-  try {
-    await workCommands.stopWork();
-    testContext.error = null;
-  } catch (err) {
-    testContext.error = err.message;
-  }
-});
-
-When('I get current work', async function () {
-  try {
-    testContext.currentWork = await workCommands.getCurrentWork();
-  } catch (err) {
-    testContext.currentWork = null;
-  }
-});
-
-// Note: "I start work on the item" is defined in git-hooks/steps.js
-
-When('I start work on a different item', async function () {
-  // Create a second work item
-  return new Promise((resolve) => {
-    const db = getTestDb();
-    db.run(`INSERT INTO work_items (id, type, title, status) VALUES (2, 'feature', 'Second Item', 'todo')`, async () => {
-      // Removed db.close() - let Node.js handle cleanup
-      testContext.secondWorkItemId = 2;
-      await workCommands.startWork(testContext.secondWorkItemId);
-      resolve();
-    });
-  });
-});
-
-Then('I get an error {string}', function (expectedError) {
-  assert(testContext.error, 'No error was thrown');
-  assert(testContext.error.includes(expectedError), `Expected error "${expectedError}" but got "${testContext.error}"`);
-});
-
-Then('operation succeeds with no changes', function () {
-  assert.strictEqual(testContext.error, null, 'Operation should not error');
-});
-
-Then('it returns null', function () {
-  assert.strictEqual(testContext.currentWork, null);
-});
-
-Then('it succeeds without creating branch', function () {
-  assert(!fs.existsSync(path.join(testDir, '.git')), 'Git directory should not exist');
-  assert(fs.existsSync(getCurrentWorkPath()), 'Current work file should exist');
-});
-
-Then('the first item stops being current', function () {
-  const currentWork = JSON.parse(fs.readFileSync(getCurrentWorkPath(), 'utf-8'));
-  assert.notStrictEqual(currentWork.id, testContext.firstWorkItemId);
-});
-
-Then('the second item becomes current', function () {
-  const currentWork = JSON.parse(fs.readFileSync(getCurrentWorkPath(), 'utf-8'));
-  assert.strictEqual(currentWork.id, testContext.secondWorkItemId);
-});
-
-Then('the status remains {string}', function (expectedStatus) {
-  const db = getTestDb();
-  return new Promise((resolve) => {
-    db.get(`SELECT status FROM work_items WHERE id = ?`, [testContext.workItemId], (err, row) => {
-      // Removed db.close() - let Node.js handle cleanup
-      assert.strictEqual(row.status, expectedStatus);
-      resolve();
-    });
-  });
-});
-
-// Mode-required steps - Epic
-When('I create an epic {string} without mode', function(title) {
-  try {
-    const output = execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work create epic "${title}"`,
-      { cwd: testDir, encoding: 'utf-8' }
-    );
-    testContext.lastOutput = output;
-
-    const match = output.match(/Created \w+ #(\d+):/);
-    if (match) {
-      testContext.createdItemId = parseInt(match[1]);
-      testContext.epicId = parseInt(match[1]);  // Also set epicId for parent references
-      testContext.lastCreatedId = parseInt(match[1]);  // For start work steps
-    }
-  } catch (err) {
-    testContext.error = err.stderr || err.message;
-  }
-});
-
-// Removed duplicate: When('I create an epic {string} with mode {string}')
-// Using the Given version at line 538 instead
-
-// Mode-required steps - Feature
-When('I create a feature {string} with mode {string}', function(title, mode) {
-  try {
-    const output = execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work create feature "${title}" "" --mode=${mode}`,
-      { cwd: testDir, encoding: 'utf-8' }
-    );
-    testContext.lastOutput = output;
-
-    const match = output.match(/Created \w+ #(\d+):/);
-    if (match) {
-      testContext.createdItemId = parseInt(match[1]);
-      testContext.lastCreatedId = parseInt(match[1]);  // For start work steps
-      testContext.lastFeatureId = parseInt(match[1]);  // For type-specific start work steps
-      if (!testContext.createdItemIds) testContext.createdItemIds = [];
-      testContext.createdItemIds.push(testContext.createdItemId);
-    }
-  } catch (err) {
-    testContext.error = err.stderr || err.message;
-  }
-});
-
-When('I create a feature {string} without mode', function(title) {
-  try {
-    const output = execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work create feature "${title}"`,
-      { cwd: testDir, encoding: 'utf-8' }
-    );
-    testContext.lastOutput = output;
-
-    const match = output.match(/Created \w+ #(\d+):/);
-    if (match) {
-      testContext.createdItemId = parseInt(match[1]);
-    }
-  } catch (err) {
-    testContext.error = err.stderr || err.message;
-  }
-});
-
-When('I try to create a feature {string} without mode', function(title) {
-  try {
-    const output = execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work create feature "${title}"`,
-      { cwd: testDir, encoding: 'utf-8', stderr: 'pipe' }
-    );
-    testContext.lastOutput = output;
-  } catch (err) {
-    testContext.error = err.stderr || err.message;
-  }
-});
-
-When('I try to create a feature {string} with mode {string}', function(title, mode) {
-  try {
-    const output = execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work create feature "${title}" "" --mode=${mode}`,
-      { cwd: testDir, encoding: 'utf-8', stderr: 'pipe' }
-    );
-    testContext.lastOutput = output;
-  } catch (err) {
-    testContext.error = err.stderr || err.message;
-  }
-});
-
-Then('the work item is created successfully', function() {
-  assert(testContext.lastOutput.includes('Created'));
-  assert(typeof testContext.createdItemId === 'number');
-});
-
-Then('the work item has mode {string}', function(mode) {
-  const db = getTestDb();
-  return new Promise((resolve) => {
-    db.get('SELECT mode FROM work_items WHERE id = ?', [testContext.createdItemId], (err, row) => {
-      // Removed db.close() - let Node.js handle cleanup
-      assert.strictEqual(row.mode, mode);
-      resolve();
-    });
-  });
-});
-
-Then('the work item has no mode', function() {
-  const db = getTestDb();
-  return new Promise((resolve) => {
-    db.get('SELECT mode FROM work_items WHERE id = ?', [testContext.createdItemId], (err, row) => {
-      // Removed db.close() - let Node.js handle cleanup
-      assert.strictEqual(row.mode, null);
-      resolve();
-    });
-  });
-});
-
-Then('no work item is created', function() {
-  const db = getTestDb();
-  return new Promise((resolve) => {
-    db.get('SELECT COUNT(*) as count FROM work_items', [], (err, row) => {
-      // Removed db.close() - let Node.js handle cleanup
-      assert.strictEqual(row.count, 0);
-      resolve();
-    });
-  });
-});
-
-Given('I create an epic {string} with mode {string}', function(title, mode) {
-  const output = execSync(
-    `node ${path.join(__dirname, '../../jettypod.js')} work create epic "${title}" "" --mode=${mode}`,
-    { cwd: testDir, encoding: 'utf-8' }
-  );
-
-  const match = output.match(/Created \w+ #(\d+):/);
-  if (match) {
-    testContext.epicId = parseInt(match[1]);
-  }
-});
-
-Given('I create a feature {string} with mode {string} and parent epic', function(title, mode) {
-  const output = execSync(
-    `node ${path.join(__dirname, '../../jettypod.js')} work create feature "${title}" "" --mode=${mode} --parent=${testContext.epicId}`,
-    { cwd: testDir, encoding: 'utf-8' }
-  );
-
-  const match = output.match(/Created \w+ #(\d+):/);
-  if (match) {
-    testContext.lastCreatedSpeedFeatureId = parseInt(match[1]);  // For hierarchical scenarios
-  }
-});
-
-When('I view the backlog', function() {
-  testContext.lastOutput = execSync(
-    `node ${path.join(__dirname, '../../jettypod.js')} backlog`,
-    { cwd: testDir, encoding: 'utf-8' }
-  );
-});
-
-Then('I see the epic with mode {string}', function(mode) {
-  assert(testContext.lastOutput.includes('Test Epic'));
-});
-
-Then('I see the child feature with mode {string}', function(mode) {
-  assert(testContext.lastOutput.includes('Child Feature'));
-  assert(testContext.lastOutput.includes(`[${mode}]`));
-});
-
-// Bug steps
-When('I create a bug {string} with mode {string}', function(title, mode) {
-  try {
-    const output = execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work create bug "${title}" "" --mode=${mode}`,
-      { cwd: testDir, encoding: 'utf-8' }
-    );
-    testContext.lastOutput = output;
-
-    const match = output.match(/Created \w+ #(\d+):/);
-    if (match) {
-      testContext.createdItemId = parseInt(match[1]);
-      testContext.lastCreatedId = parseInt(match[1]);  // For start work steps
-      testContext.lastBugId = parseInt(match[1]);  // For type-specific start work steps
-    }
-  } catch (err) {
-    testContext.error = err.stderr || err.message;
-  }
-});
-
-When('I create a bug {string} without mode', function(title) {
-  try {
-    const output = execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work create bug "${title}"`,
-      { cwd: testDir, encoding: 'utf-8' }
-    );
-    testContext.lastOutput = output;
-
-    const match = output.match(/Created \w+ #(\d+):/);
-    if (match) {
-      testContext.createdItemId = parseInt(match[1]);
-    }
-  } catch (err) {
-    testContext.error = err.stderr || err.message;
-  }
-});
-
-When('I try to create a bug {string} without mode', function(title) {
-  try {
-    const output = execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work create bug "${title}"`,
-      { cwd: testDir, encoding: 'utf-8', stderr: 'pipe' }
-    );
-    testContext.lastOutput = output;
-  } catch (err) {
-    testContext.error = err.stderr || err.message;
-  }
-});
-
-When('I try to create a bug {string} with mode {string}', function(title, mode) {
-  try {
-    const output = execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work create bug "${title}" "" --mode=${mode}`,
-      { cwd: testDir, encoding: 'utf-8', stderr: 'pipe' }
-    );
-    testContext.lastOutput = output;
-  } catch (err) {
-    testContext.error = err.stderr || err.message;
-  }
-});
-
-// Chore steps
-When('I try to create a chore {string} with mode {string}', function(title, mode) {
-  try {
-    execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work create chore "${title}" "" --mode=${mode}`,
-      { cwd: testDir, encoding: 'utf-8', stdio: 'pipe' }
-    );
-    testContext.error = null;
-  } catch (err) {
-    testContext.error = err.stderr || err.message;
-  }
-});
-
-When('I create a chore {string} without mode', function(title) {
-  try {
-    const output = execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work create chore "${title}"`,
-      { cwd: testDir, encoding: 'utf-8' }
-    );
-    testContext.lastOutput = output;
-
-    const match = output.match(/Created \w+ #(\d+):/);
-    if (match) {
-      testContext.createdItemId = parseInt(match[1]);
-    }
-  } catch (err) {
-    testContext.error = err.stderr || err.message;
-  }
-});
-
-When('I try to create a chore {string} without mode', function(title) {
-  try {
-    const output = execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work create chore "${title}"`,
-      { cwd: testDir, encoding: 'utf-8', stderr: 'pipe' }
-    );
-    testContext.lastOutput = output;
-  } catch (err) {
-    testContext.error = err.stderr || err.message;
-  }
-});
-
-// Additional assertions
-Then('the work item has NULL mode', function() {
-  const db = getTestDb();
-  return new Promise((resolve) => {
-    db.get('SELECT mode FROM work_items WHERE id = ?', [testContext.createdItemId], (err, row) => {
-      // Removed db.close() - let Node.js handle cleanup
-      assert.strictEqual(row.mode, null);
-      resolve();
-    });
-  });
-});
-
-Given('I create a bug {string} with parent epic', function(title) {
-  const output = execSync(
-    `node ${path.join(__dirname, '../../jettypod.js')} work create bug "${title}" "" --parent=${testContext.epicId}`,
-    { cwd: testDir, encoding: 'utf-8' }
-  );
-
-  const match = output.match(/Created \w+ #(\d+):/);
-  if (match) {
-    testContext.lastCreatedStableBugId = parseInt(match[1]);  // For hierarchical scenarios
-  }
-});
-
-Given('I create a chore {string} without mode and parent epic', function(title) {
-  const output = execSync(
-    `node ${path.join(__dirname, '../../jettypod.js')} work create chore "${title}" "" --parent=${testContext.epicId}`,
-    { cwd: testDir, encoding: 'utf-8' }
-  );
-
-  const match = output.match(/Created \w+ #(\d+):/);
-  if (match) {
-    testContext.lastChoreId = parseInt(match[1]);
-  }
-});
-
-Given('I create a chore {string} without mode and parent feature', function(title) {
-  const output = execSync(
-    `node ${path.join(__dirname, '../../jettypod.js')} work create chore "${title}" "" --parent=${testContext.lastFeatureId}`,
-    { cwd: testDir, encoding: 'utf-8' }
-  );
-
-  const match = output.match(/Created \w+ #(\d+):/);
-  if (match) {
-    testContext.lastChoreId = parseInt(match[1]);
-  }
-});
-
-Then('I see the feature with mode {string}', function(mode) {
-  assert(testContext.lastOutput.includes('Speed Feature'));
-  assert(testContext.lastOutput.includes(`[${mode}]`));
-});
-
-Then('I see the bug with mode {string}', function(mode) {
-  assert(testContext.lastOutput.includes('Stable Bug'));
-  assert(testContext.lastOutput.includes(`[${mode}]`));
-});
-
-Then('I see the chore with mode {string}', function(mode) {
-  assert(testContext.lastOutput.includes('Production Chore'));
-  assert(testContext.lastOutput.includes(`[${mode}]`));
-});
-
-Then('I see the epic without mode indicator', function() {
-  assert(testContext.lastOutput.includes('Test Epic'));
-  // Epic should NOT have a mode indicator
-  const epicLine = testContext.lastOutput.split('\n').find(line => line.includes('Test Epic'));
-  assert(!epicLine.match(/\[(speed|discovery|stable|production)\]/), 'Epic should not have a mode indicator');
-});
-
-Then('I see the chore without mode indicator', function() {
-  assert(testContext.lastOutput.includes('Test Chore'));
-  // Chore should NOT have a mode indicator
-  const choreLine = testContext.lastOutput.split('\n').find(line => line.includes('Test Chore'));
-  assert(!choreLine.match(/\[(speed|discovery|stable|production)\]/), 'Chore should not have a mode indicator');
-});
-
-Then('both work items are created successfully', function() {
-  assert(testContext.createdItemIds);
-  assert(testContext.createdItemIds.length >= 2);
-});
-
-Then('they have different modes', function() {
-  const db = getTestDb();
-  const placeholders = testContext.createdItemIds.map(() => '?').join(',');
-  return new Promise((resolve, reject) => {
-    db.all(`SELECT mode FROM work_items WHERE id IN (${placeholders})`, ...testContext.createdItemIds, (err, rows) => {
-      if (err) {
-        return reject(err);
-      }
-      assert.strictEqual(rows.length, 2);
-      assert.notStrictEqual(rows[0].mode, rows[1].mode);
-      resolve();
-    });
-  });
-});
-
-// Steps for work-start-mode.feature
-Given('CLAUDE.md exists', function() {
-  const claudePath = path.join(testDir, 'CLAUDE.md');
-  const content = `<claude_context project="test">
-<current_work>
-Working on: [#1] Test Item (feature)
-Mode: speed
-Status: in_progress
-</current_work>
-<mode>speed</mode>
-</claude_context>`;
-  fs.writeFileSync(claudePath, content);
-});
-
-Given('the feature status is {string}', function(status) {
-  const db = getTestDb();
-  return new Promise((resolve, reject) => {
-    db.run('UPDATE work_items SET status = ? WHERE id = ?', [status, testContext.lastCreatedId], (err) => {
-      // Removed db.close() - let Node.js handle cleanup
-      if (err) reject(err);
-      else resolve();
-    });
-  });
-});
-
-Given('CLAUDE.md has mode {string}', function(mode) {
-  const claudePath = path.join(testDir, 'CLAUDE.md');
-  const content = `<claude_context project="test">
-<current_work>
-Working on: [#1] Test Item (feature)
-Mode: ${mode}
-Status: in_progress
-</current_work>
-<mode>${mode}</mode>
-</claude_context>`;
-  fs.writeFileSync(claudePath, content);
-});
-
-When('I start work on the feature', async function() {
-  const { startWork } = require('../../features/work-commands');
-  // Capture console.log output
-  const originalLog = console.log;
-  let capturedOutput = '';
-  console.log = (...args) => {
-    capturedOutput += args.join(' ') + '\n';
-    originalLog(...args);
-  };
-  testContext.result = await startWork(testContext.lastFeatureId);
-  console.log = originalLog;
-  testContext.output = capturedOutput;
-});
-
-When('I start work on the bug', async function() {
-  const { startWork } = require('../../features/work-commands');
-  // Capture console.log output
-  const originalLog = console.log;
-  let capturedOutput = '';
-  console.log = (...args) => {
-    capturedOutput += args.join(' ') + '\n';
-    originalLog(...args);
-  };
-  testContext.result = await startWork(testContext.lastBugId);
-  console.log = originalLog;
-  testContext.output = capturedOutput;
-});
-
-When('I start work on the chore', async function() {
-  const { startWork } = require('../../features/work-commands');
-  testContext.result = await startWork(testContext.lastChoreId);
-});
-
-When('I start work on the epic', async function() {
-  const { startWork } = require('../../features/work-commands');
-  testContext.result = await startWork(testContext.lastCreatedId);
-});
-
-When('I start work on the speed feature', async function() {
-  const { startWork } = require('../../features/work-commands');
-  testContext.result = await startWork(testContext.lastCreatedSpeedFeatureId);
-});
-
-When('I start work on the stable bug', async function() {
-  const { startWork } = require('../../features/work-commands');
-  testContext.result = await startWork(testContext.lastCreatedStableBugId);
-});
-
-When('I start work on the stable feature', async function() {
-  const { startWork } = require('../../features/work-commands');
-  // Find the stable feature ID from the last created items
-  const { getDb } = require('../../lib/database');
-  const db = getDb();
-  return new Promise((resolve) => {
-    db.get('SELECT id FROM work_items WHERE title = ? AND mode = ?', ['Stable Feature', 'stable'], (err, row) => {
-      if (row) {
-        startWork(row.id).then(() => resolve());
-      } else {
-        resolve();
-      }
-    });
-  });
-});
-
-When('I stop work', async function() {
-  const { stopWork } = require('../../features/work-commands');
-  await stopWork();
-});
-
-Then('CLAUDE.md mode is set to {string}', function(expectedMode) {
-  const claudePath = path.join(testDir, 'CLAUDE.md');
-  const content = fs.readFileSync(claudePath, 'utf-8');
-  const modeMatch = content.match(/^Mode: (.+)$/m);
-  assert(modeMatch, 'CLAUDE.md should have a Mode line');
-  assert.strictEqual(modeMatch[1], expectedMode);
-});
-
-Then('CLAUDE.md has no mode line', function() {
-  const claudePath = path.join(testDir, 'CLAUDE.md');
-  const content = fs.readFileSync(claudePath, 'utf-8');
-  const modeMatch = content.match(/^Mode: (.+)$/m);
-  assert(!modeMatch, 'CLAUDE.md should not have a Mode line for epics');
-});
-
-Then('the current work section exists', function() {
-  const claudePath = path.join(testDir, 'CLAUDE.md');
-  const content = fs.readFileSync(claudePath, 'utf-8');
-  assert(content.includes('<current_work>'), 'CLAUDE.md should have current_work section');
-});
-
-Then('the work item still has mode {string}', function(expectedMode) {
-  const db = getTestDb();
-  return new Promise((resolve, reject) => {
-    db.get('SELECT mode FROM work_items WHERE id = ?', [testContext.lastCreatedId], (err, row) => {
-      // Removed db.close() - let Node.js handle cleanup
-      if (err) {
-        reject(err);
-      } else {
-        assert.strictEqual(row.mode, expectedMode);
-        resolve();
-      }
-    });
-  });
-});
-
-// Steps for work-set-mode.feature
-When('I set mode for current item to {string}', function(mode) {
-  try {
-    // Get current work item ID from current-work.json
-    const currentWork = JSON.parse(fs.readFileSync(getCurrentWorkPath(), 'utf-8'));
-    execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work set-mode ${currentWork.id} ${mode}`,
-      { cwd: testDir, encoding: 'utf-8', stdio: 'pipe' }
-    );
-    testContext.error = null;
-  } catch (err) {
-    testContext.error = err.message || err;
-  }
-});
-
-When('I set mode for item {string} to {string}', function(title, mode) {
-  const db = getTestDb();
-  return new Promise((resolve) => {
-    db.get('SELECT id FROM work_items WHERE title = ?', [title], (err, row) => {
-      // Removed db.close() - let Node.js handle cleanup
-      if (err || !row) {
-        testContext.error = 'Work item not found';
-        resolve();
-        return;
-      }
-      try {
-        execSync(
-          `node ${path.join(__dirname, '../../jettypod.js')} work set-mode ${row.id} ${mode}`,
-          { cwd: testDir, encoding: 'utf-8', stdio: 'pipe' }
-        );
-        testContext.error = null;
-      } catch (err) {
-        testContext.error = err.message || err;
-      }
-      resolve();
-    });
-  });
-});
-
-When('I set mode for the epic to {string}', function(mode) {
-  try {
-    execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work set-mode ${testContext.epicId} ${mode}`,
-      { cwd: testDir, encoding: 'utf-8', stdio: 'pipe' }
-    );
-    testContext.error = null;
-  } catch (err) {
-    testContext.error = err.message || err;
-  }
-});
-
-When('I try to set mode to {string}', function(mode) {
-  try {
-    // Get work item ID from testContext (set by create/start commands)
-    const workItemId = testContext.createdItemId || testContext.workItemId || testContext.firstWorkItemId;
-
-    if (!workItemId) {
-      throw new Error('No work item ID found in test context');
-    }
-
-    try {
-      testExecSync(
-        `node ${path.join(__dirname, '../../jettypod.js')} work set-mode ${workItemId} ${mode}`,
-        { cwd: testDir, encoding: 'utf-8', stdio: 'pipe' }
-      );
-      testContext.error = null;
-    } catch (cmdErr) {
-      // Check if error is due to invalid mode
-      const errOutput = cmdErr.stderr || cmdErr.message;
-      if (errOutput.includes('Invalid mode')) {
-        testContext.error = 'Invalid mode';
-      } else {
-        testContext.error = cmdErr.message || cmdErr;
-      }
-    }
-  } catch (err) {
-    testContext.error = err.message || err;
-  }
-});
-
-Then('I get error {string}', function(expectedError) {
-  assert(testContext.error, 'Expected an error but got none');
-  assert(testContext.error.includes(expectedError), `Expected error to include "${expectedError}" but got: ${testContext.error}`);
-});
-
-Then('item {string} has mode {string}', function(title, expectedMode) {
-  const db = getTestDb();
-  return new Promise((resolve) => {
-    db.get('SELECT mode FROM work_items WHERE title = ?', [title], (err, row) => {
-      // Removed db.close() - let Node.js handle cleanup
-      assert.strictEqual(row.mode, expectedMode);
-      resolve();
-    });
-  });
-});
-
-Then('the epic has mode {string}', function(expectedMode) {
-  const db = getTestDb();
-  return new Promise((resolve) => {
-    db.get('SELECT mode FROM work_items WHERE id = ?', [testContext.epicId], (err, row) => {
-      // Removed db.close() - let Node.js handle cleanup
-      assert.strictEqual(row.mode, expectedMode);
-      resolve();
-    });
-  });
-});
-
-Then('CLAUDE.md still has no mode line', function() {
-  const claudePath = path.join(testDir, 'CLAUDE.md');
-  const content = fs.readFileSync(claudePath, 'utf-8');
-  const modeMatch = content.match(/^Mode: (.+)$/m);
-  assert(!modeMatch, 'CLAUDE.md should not have a Mode line for epics');
-});
-
-Given('I start work on the feature {string}', async function(title) {
-  const { startWork } = require('../../features/work-commands');
-  const db = getTestDb();
-  return new Promise((resolve) => {
-    db.get('SELECT id FROM work_items WHERE title = ?', [title], async (err, row) => {
-      // Removed db.close() - let Node.js handle cleanup
-      if (err || !row) {
-        throw new Error('Work item not found');
-      }
-      testContext.result = await startWork(row.id);
-      resolve();
-    });
-  });
-});
-
-// Steps for bug-workflow-display.feature
-Then('the output contains {string}', function(text) {
-  assert(testContext.output, 'No output captured');
-  assert(testContext.output.includes(text), `Output does not contain: ${text}\n\nActual output:\n${testContext.output}`);
-});
-
-Then('the output does not contain {string}', function(text) {
-  assert(testContext.output, 'No output captured');
-  assert(!testContext.output.includes(text), `Output should not contain: ${text}\n\nActual output:\n${testContext.output}`);
-});
-
-// Simple bug/feature creation for backward compatibility
-Given('I create a bug {string}', function(title) {
-  try {
-    const output = execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work create bug "${title}"`,
-      { cwd: testDir, encoding: 'utf-8' }
-    );
-    testContext.lastOutput = output;
-    testContext.output = output;
-
-    const match = output.match(/Created \w+ #(\d+):/);
-    if (match) {
-      testContext.createdItemId = parseInt(match[1]);
-      testContext.lastBugId = parseInt(match[1]);
-      testContext.lastCreatedId = parseInt(match[1]);
-    }
-  } catch (err) {
-    testContext.error = err.stderr || err.message;
-  }
-});
-
-Given('I create a feature {string}', function(title) {
-  try {
-    const output = execSync(
-      `node ${path.join(__dirname, '../../jettypod.js')} work create feature "${title}"`,
-      { cwd: testDir, encoding: 'utf-8' }
-    );
-    testContext.lastOutput = output;
-    testContext.output = output;
-
-    const match = output.match(/Created \w+ #(\d+):/);
-    if (match) {
-      testContext.createdItemId = parseInt(match[1]);
-      testContext.lastFeatureId = parseInt(match[1]);
-      testContext.lastCreatedId = parseInt(match[1]);
-    }
-  } catch (err) {
-    testContext.error = err.stderr || err.message;
-  }
-});
-
-// Cleanup after all scenarios complete (AfterAll allows async operations)
-AfterAll(async function() {
-  const { closeDb } = require('../../lib/database');
-  await closeDb();
-});