popeye-cli 1.0.0

package/tests/types/project.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Tests for project types and schemas
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  ProjectSpecSchema,
+  OutputLanguageSchema,
+  OpenAIModelSchema,
+} from '../../src/types/project.js';
+
+describe('ProjectSpecSchema', () => {
+  describe('valid inputs', () => {
+    it('should accept a valid project spec with all fields', () => {
+      const spec = {
+        idea: 'Build a REST API for managing tasks',
+        name: 'task-api',
+        language: 'python',
+        openaiModel: 'gpt-4o',
+        outputDir: '/tmp/projects',
+      };
+
+      const result = ProjectSpecSchema.safeParse(spec);
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.idea).toBe(spec.idea);
+        expect(result.data.language).toBe('python');
+      }
+    });
+
+    it('should accept spec with only required fields', () => {
+      const spec = {
+        idea: 'Simple CLI tool',
+        language: 'typescript',
+        openaiModel: 'gpt-4o-mini',
+      };
+
+      const result = ProjectSpecSchema.safeParse(spec);
+      expect(result.success).toBe(true);
+    });
+
+    it('should accept all valid OpenAI models', () => {
+      const models = ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'];
+
+      for (const model of models) {
+        const spec = {
+          idea: 'Test project idea here',
+          language: 'python',
+          openaiModel: model,
+        };
+
+        const result = ProjectSpecSchema.safeParse(spec);
+        expect(result.success).toBe(true);
+      }
+    });
+  });
+
+  describe('invalid inputs', () => {
+    it('should reject idea shorter than 10 characters', () => {
+      const spec = {
+        idea: 'Too short',
+        language: 'python',
+        openaiModel: 'gpt-4o',
+      };
+
+      const result = ProjectSpecSchema.safeParse(spec);
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject invalid language', () => {
+      const spec = {
+        idea: 'Build something great',
+        language: 'java',
+        openaiModel: 'gpt-4o',
+      };
+
+      const result = ProjectSpecSchema.safeParse(spec);
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject invalid OpenAI model', () => {
+      const spec = {
+        idea: 'Build something great',
+        language: 'python',
+        openaiModel: 'invalid-model',
+      };
+
+      const result = ProjectSpecSchema.safeParse(spec);
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject missing required fields', () => {
+      const spec = {
+        name: 'my-project',
+      };
+
+      const result = ProjectSpecSchema.safeParse(spec);
+      expect(result.success).toBe(false);
+    });
+  });
+});
+
+describe('OutputLanguageSchema', () => {
+  it('should accept python', () => {
+    const result = OutputLanguageSchema.safeParse('python');
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept typescript', () => {
+    const result = OutputLanguageSchema.safeParse('typescript');
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject invalid language', () => {
+    const result = OutputLanguageSchema.safeParse('ruby');
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('OpenAIModelSchema', () => {
+  it('should accept all valid models', () => {
+    const validModels = ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'o1-preview', 'o1-mini'];
+
+    for (const model of validModels) {
+      const result = OpenAIModelSchema.safeParse(model);
+      expect(result.success).toBe(true);
+    }
+  });
+
+  it('should reject invalid model', () => {
+    const result = OpenAIModelSchema.safeParse('gpt-5');
+    expect(result.success).toBe(false);
+  });
+});

package/tests/workflow/consensus.test.ts

@@ -0,0 +1,221 @@
+/**
+ * Tests for consensus workflow
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  formatPlanForReview,
+  extractConcerns,
+  meetsThreshold,
+  validatePlanStructure,
+  calculateAverageScore,
+  getScoreTrend,
+} from '../../src/workflow/consensus.js';
+import type { ConsensusResult, ConsensusIteration } from '../../src/types/consensus.js';
+
+describe('formatPlanForReview', () => {
+  it('should format plan with context', () => {
+    const plan = '# My Plan\n\nThis is the plan content.';
+    const context = 'Python project for data processing';
+
+    const formatted = formatPlanForReview(plan, context);
+
+    expect(formatted).toContain('## Development Plan');
+    expect(formatted).toContain(plan);
+    expect(formatted).toContain('## Project Context');
+    expect(formatted).toContain(context);
+  });
+
+  it('should handle empty context', () => {
+    const plan = 'Simple plan';
+    const context = '';
+
+    const formatted = formatPlanForReview(plan, context);
+
+    expect(formatted).toContain(plan);
+    expect(formatted).toContain('## Project Context');
+  });
+});
+
+describe('extractConcerns', () => {
+  it('should extract concerns from result', () => {
+    const result: ConsensusResult = {
+      score: 80,
+      analysis: 'Good plan overall',
+      concerns: ['Missing error handling', 'No tests defined'],
+      recommendations: ['Add logging', 'Consider caching'],
+      approved: false,
+      rawResponse: '',
+    };
+
+    const concerns = extractConcerns(result);
+
+    expect(concerns).toContain('Missing error handling');
+    expect(concerns).toContain('No tests defined');
+    expect(concerns).toContain('Consider: Add logging');
+    expect(concerns).toContain('Consider: Consider caching');
+  });
+
+  it('should handle empty concerns and recommendations', () => {
+    const result: ConsensusResult = {
+      score: 95,
+      analysis: 'Perfect',
+      approved: true,
+      rawResponse: '',
+    };
+
+    const concerns = extractConcerns(result);
+
+    expect(concerns).toEqual([]);
+  });
+});
+
+describe('meetsThreshold', () => {
+  it('should return true when score meets threshold', () => {
+    expect(meetsThreshold(95, 95)).toBe(true);
+    expect(meetsThreshold(100, 95)).toBe(true);
+  });
+
+  it('should return false when score is below threshold', () => {
+    expect(meetsThreshold(94, 95)).toBe(false);
+    expect(meetsThreshold(0, 95)).toBe(false);
+  });
+
+  it('should use default threshold of 95', () => {
+    expect(meetsThreshold(95)).toBe(true);
+    expect(meetsThreshold(94)).toBe(false);
+  });
+});
+
+describe('validatePlanStructure', () => {
+  it('should validate plan with all required sections', () => {
+    const plan = `
+# Background
+Some background info
+
+## Goals
+1. Goal one
+2. Goal two
+
+### Milestones
+- Milestone 1
+- Milestone 2
+
+#### Tasks
+- Task 1
+- Task 2
+
+##### Test Plan
+- Test case 1
+`;
+
+    const result = validatePlanStructure(plan);
+
+    expect(result.valid).toBe(true);
+    expect(result.missingSections).toEqual([]);
+  });
+
+  it('should detect missing sections', () => {
+    const plan = `
+# Background
+Some background
+
+## Goals
+Some goals
+`;
+
+    const result = validatePlanStructure(plan);
+
+    expect(result.valid).toBe(false);
+    expect(result.missingSections).toContain('Milestones');
+    expect(result.missingSections).toContain('Tasks');
+    expect(result.missingSections).toContain('Test');
+  });
+
+  it('should handle case-insensitive matching', () => {
+    const plan = `
+# BACKGROUND
+## GOALS
+### MILESTONES
+#### TASKS
+##### TEST
+`;
+
+    const result = validatePlanStructure(plan);
+
+    expect(result.valid).toBe(true);
+  });
+});
+
+describe('calculateAverageScore', () => {
+  it('should calculate average of iteration scores', () => {
+    const iterations: ConsensusIteration[] = [
+      { iteration: 1, plan: '', result: { score: 80, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+      { iteration: 2, plan: '', result: { score: 90, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+      { iteration: 3, plan: '', result: { score: 100, analysis: '', approved: true, rawResponse: '' }, timestamp: '' },
+    ];
+
+    const average = calculateAverageScore(iterations);
+
+    expect(average).toBe(90);
+  });
+
+  it('should return 0 for empty iterations', () => {
+    expect(calculateAverageScore([])).toBe(0);
+  });
+
+  it('should handle single iteration', () => {
+    const iterations: ConsensusIteration[] = [
+      { iteration: 1, plan: '', result: { score: 75, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+    ];
+
+    expect(calculateAverageScore(iterations)).toBe(75);
+  });
+});
+
+describe('getScoreTrend', () => {
+  it('should detect improving trend', () => {
+    const iterations: ConsensusIteration[] = [
+      { iteration: 1, plan: '', result: { score: 70, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+      { iteration: 2, plan: '', result: { score: 75, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+      { iteration: 3, plan: '', result: { score: 85, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+      { iteration: 4, plan: '', result: { score: 90, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+    ];
+
+    expect(getScoreTrend(iterations)).toBe('improving');
+  });
+
+  it('should detect declining trend', () => {
+    const iterations: ConsensusIteration[] = [
+      { iteration: 1, plan: '', result: { score: 90, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+      { iteration: 2, plan: '', result: { score: 85, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+      { iteration: 3, plan: '', result: { score: 75, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+      { iteration: 4, plan: '', result: { score: 70, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+    ];
+
+    expect(getScoreTrend(iterations)).toBe('declining');
+  });
+
+  it('should detect stable trend', () => {
+    const iterations: ConsensusIteration[] = [
+      { iteration: 1, plan: '', result: { score: 80, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+      { iteration: 2, plan: '', result: { score: 82, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+      { iteration: 3, plan: '', result: { score: 81, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+      { iteration: 4, plan: '', result: { score: 83, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+    ];
+
+    expect(getScoreTrend(iterations)).toBe('stable');
+  });
+
+  it('should return stable for single iteration', () => {
+    const iterations: ConsensusIteration[] = [
+      { iteration: 1, plan: '', result: { score: 80, analysis: '', approved: false, rawResponse: '' }, timestamp: '' },
+    ];
+
+    expect(getScoreTrend(iterations)).toBe('stable');
+  });
+
+  it('should return stable for empty iterations', () => {
+    expect(getScoreTrend([])).toBe('stable');
+  });
+});

package/tests/workflow/test-runner.test.ts

@@ -0,0 +1,214 @@
+/**
+ * Tests for test runner module
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  buildTestCommand,
+  parseTestOutput,
+  getTestSummary,
+  DEFAULT_TEST_COMMANDS,
+} from '../../src/workflow/test-runner.js';
+
+describe('buildTestCommand', () => {
+  describe('Python', () => {
+    it('should build basic pytest command', () => {
+      const command = buildTestCommand({ language: 'python' });
+      expect(command).toBe('python -m pytest tests/');
+    });
+
+    it('should include verbose flag', () => {
+      const command = buildTestCommand({ language: 'python', verbose: true });
+      expect(command).toContain('-v');
+    });
+
+    it('should include coverage flag', () => {
+      const command = buildTestCommand({ language: 'python', coverage: true });
+      expect(command).toContain('--cov=src');
+      expect(command).toContain('--cov-report=term-missing');
+    });
+
+    it('should use custom test directory', () => {
+      const command = buildTestCommand({ language: 'python', testDir: 'my_tests/' });
+      expect(command).toContain('my_tests/');
+    });
+  });
+
+  describe('TypeScript', () => {
+    it('should build basic npm test command', () => {
+      const command = buildTestCommand({ language: 'typescript' });
+      expect(command).toBe('npm test');
+    });
+
+    it('should include coverage flag', () => {
+      const command = buildTestCommand({ language: 'typescript', coverage: true });
+      expect(command).toContain('--coverage');
+    });
+  });
+});
+
+describe('parseTestOutput', () => {
+  describe('Python/pytest', () => {
+    it('should parse successful pytest output', () => {
+      const output = `
+============================= test session starts ==============================
+collected 10 items
+
+tests/test_main.py ..........                                           [100%]
+
+============================== 10 passed in 2.34s ==============================
+`;
+
+      const result = parseTestOutput(output, 'python');
+
+      expect(result.success).toBe(true);
+      expect(result.passed).toBe(10);
+      expect(result.failed).toBe(0);
+      expect(result.total).toBe(10);
+    });
+
+    it('should parse pytest output with failures', () => {
+      const output = `
+============================= test session starts ==============================
+collected 5 items
+
+tests/test_main.py ...F.                                               [100%]
+
+=================================== FAILURES ===================================
+FAILED tests/test_main.py::test_something
+================================ 1 failed, 4 passed in 1.23s ==============================
+`;
+
+      const result = parseTestOutput(output, 'python');
+
+      expect(result.success).toBe(false);
+      expect(result.passed).toBe(4);
+      expect(result.failed).toBe(1);
+      expect(result.total).toBe(5);
+      expect(result.failedTests).toContain('tests/test_main.py::test_something');
+    });
+
+    it('should handle no tests collected', () => {
+      const output = 'collected 0 items';
+
+      const result = parseTestOutput(output, 'python');
+
+      expect(result.success).toBe(false);
+      expect(result.total).toBe(0);
+    });
+  });
+
+  describe('TypeScript/Jest', () => {
+    it('should parse successful Jest output', () => {
+      const output = `
+ PASS  tests/index.test.ts
+  MyComponent
+    v should render correctly (25 ms)
+    v should handle click events (12 ms)
+
+Tests: 2 passed, 2 total
+`;
+
+      const result = parseTestOutput(output, 'typescript');
+
+      expect(result.success).toBe(true);
+      expect(result.passed).toBe(2);
+      expect(result.total).toBe(2);
+    });
+
+    it('should parse Jest output with failures', () => {
+      const output = `
+ FAIL  tests/index.test.ts
+  MyComponent
+    v should render correctly (25 ms)
+    x should handle click events (12 ms)
+
+Tests: 1 failed, 1 passed, 2 total
+`;
+
+      const result = parseTestOutput(output, 'typescript');
+
+      expect(result.success).toBe(false);
+      expect(result.passed).toBe(1);
+      expect(result.failed).toBe(1);
+      expect(result.total).toBe(2);
+    });
+  });
+});
+
+describe('getTestSummary', () => {
+  it('should summarize successful tests', () => {
+    const result = {
+      success: true,
+      passed: 10,
+      failed: 0,
+      total: 10,
+      output: '',
+    };
+
+    const summary = getTestSummary(result);
+
+    expect(summary).toContain('10/10 tests passed');
+    expect(summary).toContain('✓');
+  });
+
+  it('should summarize failed tests', () => {
+    const result = {
+      success: false,
+      passed: 8,
+      failed: 2,
+      total: 10,
+      output: '',
+    };
+
+    const summary = getTestSummary(result);
+
+    expect(summary).toContain('8/10 tests passed');
+    expect(summary).toContain('2 failed');
+    expect(summary).toContain('✗');
+  });
+
+  it('should handle error case', () => {
+    const result = {
+      success: false,
+      passed: 0,
+      failed: 0,
+      total: 0,
+      output: '',
+      error: 'Tests crashed',
+    };
+
+    const summary = getTestSummary(result);
+
+    expect(summary).toContain('Tests crashed');
+  });
+
+  it('should handle no tests found', () => {
+    const result = {
+      success: false,
+      passed: 0,
+      failed: 0,
+      total: 0,
+      output: '',
+    };
+
+    const summary = getTestSummary(result);
+
+    expect(summary).toContain('No tests found');
+  });
+});
+
+describe('DEFAULT_TEST_COMMANDS', () => {
+  it('should have commands for both languages', () => {
+    expect(DEFAULT_TEST_COMMANDS.python).toBeDefined();
+    expect(DEFAULT_TEST_COMMANDS.typescript).toBeDefined();
+  });
+
+  it('should have valid pytest command for Python', () => {
+    expect(DEFAULT_TEST_COMMANDS.python).toContain('pytest');
+  });
+
+  it('should have valid npm command for TypeScript', () => {
+    expect(DEFAULT_TEST_COMMANDS.typescript).toContain('npm');
+  });
+});

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
+}

package/vitest.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['tests/**/*.test.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      include: ['src/**/*.ts'],
+      exclude: ['src/index.ts', 'src/**/*.d.ts'],
+      thresholds: {
+        statements: 80,
+        branches: 80,
+        functions: 80,
+        lines: 80,
+      },
+    },
+    testTimeout: 10000,
+  },
+});