jettypod 4.1.2 → 4.1.4

package/features/fix-text-wrapping.feature

@@ -1,42 +0,0 @@
-Feature: Fix Text Wrapping in Terminal Output
-  Terminal-aware word wrapping that respects terminal width and aligns
-  continuation lines with tree structure indentation
-
-  Approach: Terminal-Aware Word-Wrap with Alignment
-
-@text-wrapping
-Scenario: Long titles wrap at word boundaries within terminal width
-  Given I have a feature with a title longer than the terminal width
-  When I run jettypod backlog with current terminal width
-  Then the title wraps at word boundaries
-  And continuation lines align with the content indentation
-  And no words are split mid-character
-
-@text-wrapping
-Scenario: Long descriptions wrap cleanly in expanded view
-  Given I have a feature with a long description
-  When I run jettypod backlog --expand=1 with current terminal width
-  Then the description wraps at word boundaries
-  And continuation lines have proper "Description: " prefix indentation
-  And the text fits within terminal width
-
-@text-wrapping
-Scenario: Tree structure preserved with wrapped text
-  Given I have nested items with long titles
-  When I run jettypod backlog --expand=all with current terminal width
-  Then tree connectors (├──, └──) display correctly
-  And wrapped continuation lines align under the item content
-  And tree structure remains visually clear
-
-@text-wrapping
-Scenario: Terminal width changes are respected
-  Given the terminal width is 120 columns
-  And I have items with titles that wrap at 120 columns
-  When the terminal is resized to 80 columns
-  And I run jettypod backlog with current terminal width
-  Then text wraps to fit 80 columns
-  And alignment adjusts to the new width
-
-# SPEED MODE: Only happy paths above
-# STABLE MODE: Will add error handling (very narrow terminals, missing columns value, very long words)
-# PRODUCTION MODE: Will add performance testing for large backlogs

package/features/git-hooks/git-hooks.feature

@@ -1,30 +0,0 @@
-Feature: Git Hook Integration
-  As a developer
-  I want work item status to update automatically on git operations
-  So that I don't have to manually track progress
-
-  Scenario: First commit updates status to in_progress
-    Given I have a work item with status "todo"
-    And the work item is set as current work
-    When I make my first commit
-    Then the work item status should be "in_progress"
-
-  Scenario: Merge to main updates status to done
-    Given I have a work item with status "in_progress"
-    And the work item is set as current work
-    And I am on a feature branch
-    When I merge to main
-    Then the work item status should be "done"
-
-  Scenario: No current work item - hooks do nothing
-    Given no work item is set as current
-    When I make a commit
-    Then no errors occur
-
-  Scenario: Integration - hooks work with existing work commands
-    Given I have initialized jettypod with git
-    And I create a work item via work commands
-    And I start work on the item
-    When I commit changes
-    Then the work item status updates automatically
-    And the current work file still exists

package/features/git-hooks/index.js

@@ -1,93 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-/**
- * Install JettyPod git hooks into .git/hooks directory
- * @returns {boolean} True if hooks installed successfully, false if not a git repo
- * @throws {Error} If hook files cannot be copied or made executable
- */
-function installHooks() {
-  const gitHooksDir = path.join(process.cwd(), '.git', 'hooks');
-  const jettypodHooksDir = path.join(__dirname);
-
-  if (!fs.existsSync(gitHooksDir)) {
-    console.log('⚠️  Not a git repository - skipping hook installation');
-    return false;
-  }
-
-  const hooks = ['pre-commit', 'post-commit', 'post-merge'];
-
-  hooks.forEach(hook => {
-    // Check both locations: features/git-hooks and .jettypod/hooks
-    let sourcePath = path.join(jettypodHooksDir, hook);
-    if (!fs.existsSync(sourcePath)) {
-      sourcePath = path.join(process.cwd(), '.jettypod', 'hooks', hook);
-    }
-
-    if (!fs.existsSync(sourcePath)) {
-      console.log(`⚠️  Hook ${hook} not found, skipping`);
-      return;
-    }
-
-    const targetPath = path.join(gitHooksDir, hook);
-
-    try {
-      // Read hook content and inject module path
-      let hookContent = fs.readFileSync(sourcePath, 'utf-8');
-
-      // Find the jettypod root (where node_modules is)
-      const jettypodRoot = path.dirname(require.main.filename);
-      const modulesPath = path.join(jettypodRoot, 'node_modules');
-
-      // Inject NODE_PATH setup after shebang
-      if (hookContent.includes('require(\'sqlite3\')')) {
-        hookContent = hookContent.replace(
-          '#!/usr/bin/env node',
-          `#!/usr/bin/env node\n\n// Injected module path\nprocess.env.NODE_PATH = '${modulesPath}' + ':' + (process.env.NODE_PATH || '');require('module').Module._initPaths();`
-        );
-      }
-
-      // Replace __JETTYPOD_ROOT__ placeholder with actual jettypod root path
-      hookContent = hookContent.replace(/__JETTYPOD_ROOT__/g, jettypodRoot);
-
-      fs.writeFileSync(targetPath, hookContent);
-
-      // Make executable
-      fs.chmodSync(targetPath, 0o755);
-    } catch (err) {
-      throw new Error(`Failed to install ${hook} hook: ${err.message}`);
-    }
-  });
-
-  console.log('✓ Git hooks installed (pre-commit, post-commit, post-merge)');
-  return true;
-}
-
-/**
- * Check if JettyPod git hooks are installed
- * @returns {boolean} True if hooks are installed
- */
-function areHooksInstalled() {
-  const gitHooksDir = path.join(process.cwd(), '.git', 'hooks');
-  if (!fs.existsSync(gitHooksDir)) {
-    return false;
-  }
-
-  try {
-    const postCommitPath = path.join(gitHooksDir, 'post-commit');
-    if (!fs.existsSync(postCommitPath)) {
-      return false;
-    }
-
-    const content = fs.readFileSync(postCommitPath, 'utf-8');
-    return content.includes('JettyPod');
-  } catch (err) {
-    // If we can't read the file, assume not installed
-    return false;
-  }
-}
-
-module.exports = {
-  installHooks,
-  areHooksInstalled
-};

package/features/git-hooks/index.test.js

@@ -1,137 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { createTestEnvironment } = require('../../lib/test-helpers');
-const { installHooks, areHooksInstalled } = require('./index');
-const { execSync } = require('child_process');
-
-describe('Git Hooks', () => {
-  let testEnv;
-
-  beforeEach(() => {
-    testEnv = createTestEnvironment();
-    process.chdir(testEnv.testDir);
-  });
-
-  afterEach(() => {
-    testEnv.cleanup();
-  });
-
-  describe('installHooks()', () => {
-    test('should return false if not a git repository', () => {
-      const result = installHooks();
-      expect(result).toBe(false);
-    });
-
-    test('should install hooks in git repository', () => {
-      // Initialize git repo
-      execSync('git init', { stdio: 'pipe' });
-
-      // Create source hooks
-      const hooksSourceDir = path.join(testEnv.testDir, 'features', 'git-hooks');
-      fs.mkdirSync(hooksSourceDir, { recursive: true });
-
-      fs.writeFileSync(path.join(hooksSourceDir, 'pre-commit'), '#!/usr/bin/env node\nconsole.log("test");');
-      fs.writeFileSync(path.join(hooksSourceDir, 'post-commit'), '#!/usr/bin/env node\n// JettyPod hook');
-      fs.writeFileSync(path.join(hooksSourceDir, 'post-merge'), '#!/usr/bin/env node\nconsole.log("test");');
-
-      const result = installHooks();
-
-      expect(result).toBe(true);
-      expect(fs.existsSync('.git/hooks/pre-commit')).toBe(true);
-      expect(fs.existsSync('.git/hooks/post-commit')).toBe(true);
-      expect(fs.existsSync('.git/hooks/post-merge')).toBe(true);
-    });
-
-    test('should make hooks executable', () => {
-      execSync('git init', { stdio: 'pipe' });
-
-      const hooksSourceDir = path.join(testEnv.testDir, 'features', 'git-hooks');
-      fs.mkdirSync(hooksSourceDir, { recursive: true });
-
-      fs.writeFileSync(path.join(hooksSourceDir, 'pre-commit'), '#!/usr/bin/env node\nconsole.log("test");');
-      fs.writeFileSync(path.join(hooksSourceDir, 'post-commit'), '#!/usr/bin/env node\n// JettyPod');
-      fs.writeFileSync(path.join(hooksSourceDir, 'post-merge'), '#!/usr/bin/env node\nconsole.log("test");');
-
-      installHooks();
-
-      const preCommitPath = path.join(testEnv.testDir, '.git', 'hooks', 'pre-commit');
-      const stats = fs.statSync(preCommitPath);
-      // Check if executable bit is set (mode & 0o111)
-      expect(stats.mode & 0o111).not.toBe(0);
-    });
-
-    test('should succeed when hooks exist in production directory', () => {
-      execSync('git init', { stdio: 'pipe' });
-
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
-
-      // This will find hooks in the real features/git-hooks directory
-      const result = installHooks();
-
-      expect(result).toBe(true);
-      consoleSpy.mockRestore();
-    });
-
-    test('should check alternate hook location (.jettypod/hooks)', () => {
-      execSync('git init', { stdio: 'pipe' });
-
-      const altHooksDir = path.join(testEnv.testDir, '.jettypod', 'hooks');
-      fs.mkdirSync(altHooksDir, { recursive: true });
-
-      fs.writeFileSync(path.join(altHooksDir, 'pre-commit'), '#!/usr/bin/env node\nconsole.log("test");');
-      fs.writeFileSync(path.join(altHooksDir, 'post-commit'), '#!/usr/bin/env node\n// JettyPod');
-      fs.writeFileSync(path.join(altHooksDir, 'post-merge'), '#!/usr/bin/env node\nconsole.log("test");');
-
-      const result = installHooks();
-
-      expect(result).toBe(true);
-      expect(fs.existsSync('.git/hooks/post-commit')).toBe(true);
-    });
-  });
-
-  describe('areHooksInstalled()', () => {
-    test('should return false if not a git repository', () => {
-      const result = areHooksInstalled();
-      expect(result).toBe(false);
-    });
-
-    test('should return false if hooks not installed', () => {
-      execSync('git init', { stdio: 'pipe' });
-
-      const result = areHooksInstalled();
-      expect(result).toBe(false);
-    });
-
-    test('should return true if JettyPod hooks installed', () => {
-      execSync('git init', { stdio: 'pipe' });
-
-      fs.writeFileSync('.git/hooks/post-commit', '#!/usr/bin/env node\n// JettyPod hook\nconsole.log("test");');
-
-      const result = areHooksInstalled();
-      expect(result).toBe(true);
-    });
-
-    test('should return false if hooks exist but are not JettyPod hooks', () => {
-      execSync('git init', { stdio: 'pipe' });
-
-      fs.writeFileSync('.git/hooks/post-commit', '#!/usr/bin/env node\nconsole.log("other hook");');
-
-      const result = areHooksInstalled();
-      expect(result).toBe(false);
-    });
-
-    test('should return false if hook file cannot be read', () => {
-      execSync('git init', { stdio: 'pipe' });
-
-      fs.writeFileSync('.git/hooks/post-commit', '#!/usr/bin/env node\n// JettyPod');
-      fs.chmodSync('.git/hooks/post-commit', 0o000);
-
-      const result = areHooksInstalled();
-
-      // Cleanup
-      fs.chmodSync('.git/hooks/post-commit', 0o644);
-
-      expect(result).toBe(false);
-    });
-  });
-});

package/features/git-hooks/post-commit

@@ -1,56 +0,0 @@
-#!/usr/bin/env node
-
-// JettyPod Git Hook: post-commit
-// Auto-updates work item status and regenerates docs
-
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-
-const jettypodDir = path.join(process.cwd(), '.jettypod');
-const currentWorkPath = path.join(jettypodDir, 'current-work.json');
-const dbPath = path.join(jettypodDir, 'work.db');
-
-// Update work item status if needed
-(async () => {
-  if (fs.existsSync(currentWorkPath)) {
-    const currentWork = JSON.parse(fs.readFileSync(currentWorkPath, 'utf-8'));
-
-    // Only update if status is todo
-    if (currentWork.status === 'todo') {
-      try {
-        const { updateStatus } = require('../../features/work-tracking');
-        await updateStatus(currentWork.id, 'in_progress');
-
-        // Update current work file
-        currentWork.status = 'in_progress';
-        fs.writeFileSync(currentWorkPath, JSON.stringify(currentWork, null, 2));
-
-        console.log(`\n✓ Work item #${currentWork.id} status updated: todo → in_progress`);
-      } catch (err) {
-        console.error('Failed to update work item:', err);
-      }
-    }
-  }
-})();
-
-// Always generate docs on every commit
-generateDocs();
-
-function generateDocs() {
-  const featuresDir = path.join(process.cwd(), 'features');
-  const outputPath = path.join(process.cwd(), 'SYSTEM-BEHAVIOR.md');
-
-  // Skip if no features directory
-  if (!fs.existsSync(featuresDir)) {
-    return;
-  }
-
-  try {
-    const docsGenerator = require(path.join(process.cwd(), 'lib', 'docs-generator'));
-    docsGenerator.generate();
-    console.log('📚 Documentation updated');
-  } catch (err) {
-    // Fail silently - docs generation is optional
-  }
-}

package/features/git-hooks/post-merge

@@ -1,47 +0,0 @@
-#!/usr/bin/env node
-
-// JettyPod Git Hook: post-merge
-// Auto-updates work item status to done when merging to main
-
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-
-const jettypodDir = path.join(process.cwd(), '.jettypod');
-const currentWorkPath = path.join(jettypodDir, 'current-work.json');
-const dbPath = path.join(jettypodDir, 'work.db');
-
-// Skip if no current work
-if (!fs.existsSync(currentWorkPath)) {
-  process.exit(0);
-}
-
-// Check if we're on main/master
-let currentBranch;
-try {
-  currentBranch = execSync('git branch --show-current', { encoding: 'utf-8' }).trim();
-} catch (e) {
-  process.exit(0);
-}
-
-if (currentBranch !== 'main' && currentBranch !== 'master') {
-  process.exit(0);
-}
-
-const currentWork = JSON.parse(fs.readFileSync(currentWorkPath, 'utf-8'));
-
-// Update to done using shared updateStatus (includes epic auto-close logic)
-(async () => {
-  try {
-    const { updateStatus } = require('__JETTYPOD_ROOT__/features/work-tracking');
-    await updateStatus(currentWork.id, 'done');
-
-    // Clear current work pointer since work is done
-    fs.unlinkSync(currentWorkPath);
-
-    console.log(`\n✓ Work item #${currentWork.id} status updated: → done (merged to ${currentBranch})`);
-  } catch (err) {
-    console.error('Failed to update work item:', err);
-    process.exit(1);
-  }
-})();

package/features/git-hooks/pre-commit

@@ -1,28 +0,0 @@
-#!/usr/bin/env node
-
-// Pre-commit hook: Run tests before allowing commit
-
-const { execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-
-// Check if we're in a real project (not a test directory)
-const packageJsonPath = path.join(process.cwd(), 'package.json');
-if (!fs.existsSync(packageJsonPath)) {
-  // Skip tests in test directories
-  process.exit(0);
-}
-
-console.log('\n🧪 Running tests before commit...\n');
-
-try {
-  // Run tests
-  execSync('npm test', { stdio: 'inherit' });
-
-  console.log('\n✅ Tests passed! Proceeding with commit.\n');
-  process.exit(0);
-} catch (err) {
-  console.log('\n❌ Tests failed! Commit blocked.\n');
-  console.log('Fix the failing tests or use --no-verify to skip this check.\n');
-  process.exit(1);
-}

package/features/git-hooks/simple-steps.js

@@ -1,53 +0,0 @@
-const { Given, When, Then } = 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 testDir = path.join('/tmp', 'hooks-simple-' + Date.now());
-const dbFileName = process.env.NODE_ENV === 'test' ? 'test-work.db' : 'work.db';
-let originalDir;
-let workItemId;
-
-Given('I initialize a git repo with jettypod', function () {
-  originalDir = process.cwd();
-  // 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);
-
-  execSync('git init', { stdio: 'pipe' });
-  execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
-  execSync('git config user.name "Test"', { stdio: 'pipe' });
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} init`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
-});
-
-Given('I create and start work on a todo item', function () {
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} work create feature "Test"`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} work status 1 todo`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
-  execSync(`node ${path.join(originalDir, 'jettypod.js')} work start 1`, { stdio: 'pipe', env: { ...process.env, NODE_ENV: 'test' } });
-  workItemId = 1;
-});
-
-Then('the hook updates status to in_progress', function () {
-  const dbPath = path.join(testDir, '.jettypod', dbFileName);
-  const db = new sqlite3.Database(dbPath);
-
-  return new Promise((resolve) => {
-    db.get(`SELECT status FROM work_items WHERE id = ?`, [workItemId], (err, row) => {
-      db.close();
-      assert.strictEqual(row.status, 'in_progress');
-
-      // Cleanup
-      if (fs.existsSync(testDir)) {
-        process.chdir(originalDir);
-        fs.rmSync(testDir, { recursive: true, force: true });
-      }
-
-      resolve();
-    });
-  });
-});

package/features/git-hooks/simple-test.feature

@@ -1,10 +0,0 @@
-Feature: Git Hooks Integration
-  As a developer
-  I want work item status to auto-update on commits
-  So I don't manually track progress
-
-  Scenario: Integration - post-commit hook updates status
-    Given I initialize a git repo with jettypod
-    And I create and start work on a todo item
-    When I make a commit
-    Then the hook updates status to in_progress