jettypod 4.1.2 → 4.1.4

package/lib/decisions-helpers.test.js

@@ -1,310 +0,0 @@
-const decisionsHelpers = require('./decisions-helpers');
-const { createTestEnvironment } = require('./test-helpers');
-const { getDb, closeDb, resetDb } = require('./database');
-const config = require('./config');
-
-describe('Decisions Helpers', () => {
-  let testEnv;
-  let db;
-
-  beforeEach(() => {
-    resetDb();
-    testEnv = createTestEnvironment();
-    process.chdir(testEnv.testDir);
-    db = getDb();
-  });
-
-  afterEach(async () => {
-    
-    
-    await closeDb();
-    testEnv.cleanup();
-    resetDb();
-  });
-
-  describe('getProjectDecision', () => {
-    test('returns null when no project decision exists', () => {
-      const decision = decisionsHelpers.getProjectDecision();
-      expect(decision).toBeNull();
-    });
-
-    test('returns project decision when it exists', () => {
-      // Mock config with decision
-      const originalRead = config.read;
-      config.read = () => ({
-        project_discovery: {
-          winner: 'prototypes/test',
-          rationale: 'Testing approach',
-          started_date: '2025-10-31T00:00:00.000Z'
-        }
-      });
-
-      const decision = decisionsHelpers.getProjectDecision();
-
-      expect(decision).toEqual({
-        winner: 'prototypes/test',
-        rationale: 'Testing approach',
-        started_date: '2025-10-31T00:00:00.000Z'
-      });
-
-      config.read = originalRead;
-    });
-
-    test('handles missing rationale and date gracefully', () => {
-      const originalRead = config.read;
-      config.read = () => ({
-        project_discovery: {
-          winner: 'prototypes/test'
-        }
-      });
-
-      const decision = decisionsHelpers.getProjectDecision();
-
-      expect(decision).toEqual({
-        winner: 'prototypes/test',
-        rationale: null,
-        started_date: null
-      });
-
-      config.read = originalRead;
-    });
-
-    test('returns null on config read error', () => {
-      const originalRead = config.read;
-      config.read = () => {
-        throw new Error('Config error');
-      };
-
-      const decision = decisionsHelpers.getProjectDecision();
-
-      expect(decision).toBeNull();
-
-      config.read = originalRead;
-    });
-  });
-
-  describe('getDecisionsForEpic', () => {
-    test('returns empty array when epic has no decisions', async () => {
-      // Create epic without decisions
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title) VALUES (?, ?)', ['epic', 'Test Epic'], resolve);
-      });
-
-      const decisions = await decisionsHelpers.getDecisionsForEpic(1);
-
-      expect(decisions).toEqual([]);
-    });
-
-    test('returns decisions for specific epic', async () => {
-      // Create epic
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title) VALUES (?, ?)', ['epic', 'Test Epic'], resolve);
-      });
-
-      // Add decisions
-      await new Promise((resolve) => {
-        db.run(
-          'INSERT INTO discovery_decisions (work_item_id, aspect, decision, rationale) VALUES (?, ?, ?, ?)',
-          [1, 'Architecture', 'REST API', 'Simple and widely understood'],
-          resolve
-        );
-      });
-
-      await new Promise((resolve) => {
-        db.run(
-          'INSERT INTO discovery_decisions (work_item_id, aspect, decision, rationale) VALUES (?, ?, ?, ?)',
-          [1, 'Database', 'PostgreSQL', 'Robust and feature-rich'],
-          resolve
-        );
-      });
-
-      const decisions = await decisionsHelpers.getDecisionsForEpic(1);
-
-      expect(decisions).toHaveLength(2);
-      expect(decisions[0].aspect).toBe('Architecture');
-      expect(decisions[0].decision).toBe('REST API');
-      expect(decisions[1].aspect).toBe('Database');
-      expect(decisions[1].decision).toBe('PostgreSQL');
-    });
-
-    test('only returns decisions for specified epic', async () => {
-      // Create two epics
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title) VALUES (?, ?)', ['epic', 'Epic 1'], resolve);
-      });
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title) VALUES (?, ?)', ['epic', 'Epic 2'], resolve);
-      });
-
-      // Add decision to epic 1
-      await new Promise((resolve) => {
-        db.run(
-          'INSERT INTO discovery_decisions (work_item_id, aspect, decision, rationale) VALUES (?, ?, ?, ?)',
-          [1, 'Architecture', 'REST API', 'Simple'],
-          resolve
-        );
-      });
-
-      // Add decision to epic 2
-      await new Promise((resolve) => {
-        db.run(
-          'INSERT INTO discovery_decisions (work_item_id, aspect, decision, rationale) VALUES (?, ?, ?, ?)',
-          [2, 'Architecture', 'GraphQL', 'Flexible'],
-          resolve
-        );
-      });
-
-      const decisions = await decisionsHelpers.getDecisionsForEpic(1);
-
-      expect(decisions).toHaveLength(1);
-      expect(decisions[0].decision).toBe('REST API');
-    });
-  });
-
-  describe('getAllEpicDecisions', () => {
-    test('returns empty array when no decisions exist', async () => {
-      // Ensure db is ready
-      await new Promise((resolve) => {
-        db.get('SELECT 1', [], resolve);
-      });
-
-      const decisions = await decisionsHelpers.getAllEpicDecisions();
-      expect(decisions).toEqual([]);
-    });
-
-    test('returns all epic decisions across all epics', async () => {
-      // Create two epics
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title) VALUES (?, ?)', ['epic', 'Epic 1'], resolve);
-      });
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title) VALUES (?, ?)', ['epic', 'Epic 2'], resolve);
-      });
-
-      // Add decisions
-      await new Promise((resolve) => {
-        db.run(
-          'INSERT INTO discovery_decisions (work_item_id, aspect, decision, rationale) VALUES (?, ?, ?, ?)',
-          [1, 'Architecture', 'REST API', 'Simple'],
-          resolve
-        );
-      });
-
-      await new Promise((resolve) => {
-        db.run(
-          'INSERT INTO discovery_decisions (work_item_id, aspect, decision, rationale) VALUES (?, ?, ?, ?)',
-          [2, 'Architecture', 'GraphQL', 'Flexible'],
-          resolve
-        );
-      });
-
-      const decisions = await decisionsHelpers.getAllEpicDecisions();
-
-      expect(decisions).toHaveLength(2);
-      expect(decisions[0].epic_id).toBe(1);
-      expect(decisions[1].epic_id).toBe(2);
-    });
-  });
-
-  describe('getAllDecisions', () => {
-    test('returns structured object with project and epic decisions', async () => {
-      // Mock project decision
-      const originalRead = config.read;
-      config.read = () => ({
-        project_discovery: {
-          winner: 'prototypes/test',
-          rationale: 'Testing'
-        }
-      });
-
-      // Create epic with decision
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title) VALUES (?, ?)', ['epic', 'Test Epic'], resolve);
-      });
-
-      await new Promise((resolve) => {
-        db.run(
-          'INSERT INTO discovery_decisions (work_item_id, aspect, decision, rationale) VALUES (?, ?, ?, ?)',
-          [1, 'Architecture', 'REST API', 'Simple'],
-          resolve
-        );
-      });
-
-      const allDecisions = await decisionsHelpers.getAllDecisions();
-
-      expect(allDecisions.project).toEqual({
-        winner: 'prototypes/test',
-        rationale: 'Testing',
-        started_date: null
-      });
-
-      expect(allDecisions.epics).toHaveLength(1);
-      expect(allDecisions.epics[0].id).toBe(1);
-      expect(allDecisions.epics[0].title).toBe('Test Epic');
-      expect(allDecisions.epics[0].decisions).toHaveLength(1);
-      expect(allDecisions.epics[0].decisions[0].aspect).toBe('Architecture');
-
-      config.read = originalRead;
-    });
-
-    test('groups decisions by epic', async () => {
-      // Create epic with multiple decisions
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title) VALUES (?, ?)', ['epic', 'Test Epic'], resolve);
-      });
-
-      await new Promise((resolve) => {
-        db.run(
-          'INSERT INTO discovery_decisions (work_item_id, aspect, decision, rationale) VALUES (?, ?, ?, ?)',
-          [1, 'Architecture', 'REST API', 'Simple'],
-          resolve
-        );
-      });
-
-      await new Promise((resolve) => {
-        db.run(
-          'INSERT INTO discovery_decisions (work_item_id, aspect, decision, rationale) VALUES (?, ?, ?, ?)',
-          [1, 'Database', 'PostgreSQL', 'Robust'],
-          resolve
-        );
-      });
-
-      const allDecisions = await decisionsHelpers.getAllDecisions();
-
-      expect(allDecisions.epics).toHaveLength(1);
-      expect(allDecisions.epics[0].decisions).toHaveLength(2);
-    });
-  });
-
-  describe('hasDecisions', () => {
-    test('returns false when epic has no decisions', async () => {
-      // Create epic without decisions
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title) VALUES (?, ?)', ['epic', 'Test Epic'], resolve);
-      });
-
-      const result = await decisionsHelpers.hasDecisions(1);
-
-      expect(result).toBe(false);
-    });
-
-    test('returns true when epic has decisions', async () => {
-      // Create epic with decision
-      await new Promise((resolve) => {
-        db.run('INSERT INTO work_items (type, title) VALUES (?, ?)', ['epic', 'Test Epic'], resolve);
-      });
-
-      await new Promise((resolve) => {
-        db.run(
-          'INSERT INTO discovery_decisions (work_item_id, aspect, decision, rationale) VALUES (?, ?, ?, ?)',
-          [1, 'Architecture', 'REST API', 'Simple'],
-          resolve
-        );
-      });
-
-      const result = await decisionsHelpers.hasDecisions(1);
-
-      expect(result).toBe(true);
-    });
-  });
-});

package/lib/git-coordinator.js

@@ -1,167 +0,0 @@
-const { execSync } = require('child_process');
-const { getCurrentBranch } = require('./git');
-
-/**
- * Check if main branch has moved ahead of local branch
- * @returns {boolean} True if main has new commits
- */
-function checkMainAhead() {
-  try {
-    // Fetch latest from remote
-    execSync('git fetch origin main', { stdio: 'pipe' });
-
-    // Get commit count between local and remote main
-    const result = execSync('git rev-list --count HEAD..origin/main', { encoding: 'utf-8' });
-    const commitCount = parseInt(result.trim());
-
-    return commitCount > 0;
-  } catch (err) {
-    const errorMessage = err.message || err.stderr?.toString() || '';
-
-    // Network error detection
-    const networkPatterns = [
-      'Could not resolve host',
-      'Connection refused',
-      'Connection timed out',
-      'Failed to connect',
-      'Network is unreachable',
-      'ENOTFOUND',
-      'ETIMEDOUT',
-      'ECONNREFUSED'
-    ];
-
-    const isNetworkError = networkPatterns.some(pattern =>
-      errorMessage.includes(pattern)
-    );
-
-    if (isNetworkError) {
-      console.error('❌ Network failure while checking main branch');
-      console.error('   Cannot connect to remote repository');
-      console.error('');
-      console.error('To fix:');
-      console.error('   1. Check your internet connection');
-      console.error('   2. Verify remote repository is accessible');
-      console.error('   3. Try again after network is restored');
-      console.error('');
-      console.error('Command: git fetch origin main');
-      throw new Error('Network failure - cannot check main branch status');
-    }
-
-    throw new Error(`Failed to check main branch status: ${err.message}`);
-  }
-}
-
-/**
- * Determine if queue should be used for push
- * @returns {boolean} True if queue coordination needed
- */
-function shouldUseQueue() {
-  return checkMainAhead();
-}
-
-/**
- * Push current branch directly to main
- */
-function pushDirectlyToMain() {
-  try {
-    const currentBranch = getCurrentBranch();
-
-    if (currentBranch === 'main') {
-      // Already on main, just push
-      execSync('git push origin main', { stdio: 'inherit' });
-    } else {
-      // Push current branch to main
-      execSync(`git push origin ${currentBranch}:main`, { stdio: 'inherit' });
-    }
-  } catch (err) {
-    const errorMessage = err.message || err.stderr?.toString() || '';
-
-    // Push rejection detection
-    const rejectionPatterns = [
-      'rejected',
-      'non-fast-forward',
-      'Updates were rejected',
-      'failed to push',
-      'error: failed to push some refs'
-    ];
-
-    const isRejected = rejectionPatterns.some(pattern =>
-      errorMessage.includes(pattern)
-    );
-
-    if (isRejected) {
-      console.error('❌ Push rejected by remote');
-      console.error('   Remote has changes that you do not have locally');
-      console.error('');
-      console.error('To fix:');
-      console.error('   1. Pull latest changes: git pull --rebase');
-      console.error('   2. Resolve any conflicts if they occur');
-      console.error('   3. Try pushing again');
-      console.error('');
-      console.error('Your queue entry will remain for retry.');
-      throw new Error('Push rejected - remote has newer commits');
-    }
-
-    throw new Error(`Failed to push to main: ${err.message}`);
-  }
-}
-
-/**
- * Rebase current branch on top of main
- */
-function rebaseOnMain() {
-  try {
-    const currentBranch = getCurrentBranch();
-
-    // Fetch latest main
-    execSync('git fetch origin main', { stdio: 'pipe' });
-
-    if (currentBranch === 'main') {
-      // Already on main, just pull with rebase
-      execSync('git pull --rebase origin main', { stdio: 'inherit' });
-    } else {
-      // Rebase current branch on origin/main
-      execSync('git rebase origin/main', { stdio: 'inherit' });
-    }
-  } catch (err) {
-    const errorMessage = err.message || err.stderr?.toString() || '';
-    const exitCode = err.status;
-
-    // Rebase conflict detection
-    const conflictPatterns = [
-      'CONFLICT',
-      'Merge conflict',
-      'conflict',
-      'both modified',
-      'both added'
-    ];
-
-    const hasConflict = conflictPatterns.some(pattern =>
-      errorMessage.includes(pattern)
-    ) || exitCode === 1;
-
-    if (hasConflict) {
-      console.error('❌ Rebase conflicts detected');
-      console.error('   Your changes conflict with changes on main');
-      console.error('');
-      console.error('To resolve conflicts:');
-      console.error('   1. Run: git status');
-      console.error('   2. Edit conflicting files to resolve conflicts');
-      console.error('   3. Run: git add <resolved-files>');
-      console.error('   4. Run: git rebase --continue');
-      console.error('   5. Or abort: git rebase --abort');
-      console.error('');
-      console.error('Your queue entry will remain until conflicts are resolved.');
-      throw new Error('Rebase conflicts - manual resolution required');
-    }
-
-    throw new Error(`Failed to rebase on main: ${err.message}`);
-  }
-}
-
-module.exports = {
-  checkMainAhead,
-  shouldUseQueue,
-  pushDirectlyToMain,
-  rebaseOnMain
-};

package/lib/git.test.js

@@ -1,145 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-const { execSync } = require('child_process');
-const { createTestEnvironment } = require('./test-helpers');
-const {
-  isGitInstalled,
-  isGitRepo,
-  createOrCheckoutBranch,
-  getCurrentBranch,
-  slugify,
-  createFeatureBranchName
-} = require('./git');
-
-describe('Git Module', () => {
-  let testEnv;
-
-  beforeEach(() => {
-    testEnv = createTestEnvironment();
-    process.chdir(testEnv.testDir);
-  });
-
-  afterEach(() => {
-    testEnv.cleanup();
-  });
-
-  describe('isGitInstalled()', () => {
-    test('should return true when git is installed', () => {
-      expect(isGitInstalled()).toBe(true);
-    });
-  });
-
-  describe('isGitRepo()', () => {
-    test('should return false in non-git directory', () => {
-      expect(isGitRepo()).toBe(false);
-    });
-
-    test('should return true in git repository', () => {
-      execSync('git init', { stdio: 'pipe' });
-      expect(isGitRepo()).toBe(true);
-    });
-  });
-
-  describe('slugify()', () => {
-    test('should convert text to lowercase with hyphens', () => {
-      expect(slugify('Hello World')).toBe('hello-world');
-    });
-
-    test('should remove special characters', () => {
-      expect(slugify('Fix: Bug #123')).toBe('fix-bug-123');
-    });
-
-    test('should handle multiple spaces', () => {
-      expect(slugify('Multiple   Spaces')).toBe('multiple-spaces');
-    });
-
-    test('should throw error for non-string input', () => {
-      expect(() => slugify(123)).toThrow('slugify requires a string input');
-      expect(() => slugify(null)).toThrow('slugify requires a string input');
-    });
-  });
-
-  describe('createFeatureBranchName()', () => {
-    test('should create valid branch name', () => {
-      const branch = createFeatureBranchName(42, 'Add user auth');
-      expect(branch).toBe('feature/work-42-add-user-auth');
-    });
-
-    test('should throw error for invalid work item ID', () => {
-      expect(() => createFeatureBranchName('invalid', 'Title')).toThrow('workItemId must be a positive number');
-      expect(() => createFeatureBranchName(0, 'Title')).toThrow('workItemId must be a positive number');
-      expect(() => createFeatureBranchName(-5, 'Title')).toThrow('workItemId must be a positive number');
-    });
-
-    test('should throw error for invalid title', () => {
-      expect(() => createFeatureBranchName(1, 123)).toThrow('title must be a non-empty string');
-      expect(() => createFeatureBranchName(1, '')).toThrow('title must be a non-empty string');
-      expect(() => createFeatureBranchName(1, '   ')).toThrow('title must be a non-empty string');
-    });
-  });
-
-  describe('createOrCheckoutBranch()', () => {
-    beforeEach(() => {
-      execSync('git init', { stdio: 'pipe' });
-      execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
-      execSync('git config user.name "Test User"', { stdio: 'pipe' });
-      // Create initial commit
-      fs.writeFileSync('README.md', '# Test');
-      execSync('git add .', { stdio: 'pipe' });
-      execSync('git commit -m "Initial commit"', { stdio: 'pipe' });
-    });
-
-    test('should create new branch', () => {
-      const result = createOrCheckoutBranch('feature/test');
-      expect(result).toBe(true);
-      expect(getCurrentBranch()).toBe('feature/test');
-    });
-
-    test('should checkout existing branch', () => {
-      execSync('git checkout -b feature/existing', { stdio: 'pipe' });
-      execSync('git checkout main || git checkout master', { stdio: 'pipe' });
-
-      const result = createOrCheckoutBranch('feature/existing');
-      expect(result).toBe(true);
-      expect(getCurrentBranch()).toBe('feature/existing');
-    });
-
-    test('should throw error for invalid branch name', () => {
-      expect(() => createOrCheckoutBranch('branch name')).toThrow('Branch name cannot contain spaces');
-      expect(() => createOrCheckoutBranch('-invalid')).toThrow('Branch name cannot start with - or .');
-      expect(() => createOrCheckoutBranch('invalid~name')).toThrow('Branch name contains invalid characters');
-    });
-
-    test('should throw error in non-git repository', () => {
-      testEnv.cleanup();
-      testEnv = createTestEnvironment();
-      process.chdir(testEnv.testDir);
-
-      expect(() => createOrCheckoutBranch('feature/test')).toThrow('Not in a git repository');
-    });
-  });
-
-  describe('getCurrentBranch()', () => {
-    beforeEach(() => {
-      execSync('git init', { stdio: 'pipe' });
-      execSync('git config user.email "test@test.com"', { stdio: 'pipe' });
-      execSync('git config user.name "Test User"', { stdio: 'pipe' });
-      fs.writeFileSync('README.md', '# Test');
-      execSync('git add .', { stdio: 'pipe' });
-      execSync('git commit -m "Initial commit"', { stdio: 'pipe' });
-    });
-
-    test('should return current branch name', () => {
-      const branch = getCurrentBranch();
-      expect(['main', 'master']).toContain(branch);
-    });
-
-    test('should return null in non-git directory', () => {
-      testEnv.cleanup();
-      testEnv = createTestEnvironment();
-      process.chdir(testEnv.testDir);
-
-      expect(getCurrentBranch()).toBe(null);
-    });
-  });
-});