popeye-cli 1.0.0

package/tests/adapters/openai.test.ts

@@ -0,0 +1,145 @@
+/**
+ * Tests for OpenAI adapter
+ */
+
+import { describe, it, expect } from 'vitest';
+import { parseConsensusResponse } from '../../src/adapters/openai.js';
+
+describe('parseConsensusResponse', () => {
+  it('should parse a complete consensus response', () => {
+    const response = `
+ANALYSIS:
+This is a well-structured plan that covers the main requirements.
+The architecture is sound and follows best practices.
+
+STRENGTHS:
+- Clear project structure
+- Comprehensive test coverage
+- Good separation of concerns
+
+CONCERNS:
+- Missing error handling strategy
+- No deployment plan
+- Security considerations not addressed
+
+RECOMMENDATIONS:
+- Add error handling middleware
+- Include deployment configuration
+- Document security measures
+
+CONSENSUS: 85%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.score).toBe(85);
+    expect(result.approved).toBe(false);
+    expect(result.analysis).toContain('well-structured plan');
+    expect(result.strengths).toContain('Clear project structure');
+    expect(result.concerns).toContain('Missing error handling strategy');
+    expect(result.recommendations).toContain('Add error handling middleware');
+    expect(result.rawResponse).toBe(response);
+  });
+
+  it('should mark as approved when score >= 95', () => {
+    const response = `
+ANALYSIS:
+Excellent plan.
+
+STRENGTHS:
+- Everything is perfect
+
+CONCERNS:
+- None
+
+RECOMMENDATIONS:
+- None needed
+
+CONSENSUS: 98%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.score).toBe(98);
+    expect(result.approved).toBe(true);
+  });
+
+  it('should handle missing sections gracefully', () => {
+    const response = `
+Some random text without proper formatting.
+
+CONSENSUS: 70%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.score).toBe(70);
+    expect(result.approved).toBe(false);
+    expect(result.analysis).toBe('');
+    expect(result.strengths).toEqual([]);
+    expect(result.concerns).toEqual([]);
+  });
+
+  it('should handle missing score', () => {
+    const response = `
+ANALYSIS:
+No score provided in this response.
+
+STRENGTHS:
+- Some strength
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.score).toBe(0);
+    expect(result.approved).toBe(false);
+  });
+
+  it('should parse bulleted lists correctly', () => {
+    const response = `
+ANALYSIS:
+Good plan.
+
+STRENGTHS:
+- First strength
+- Second strength
+* Third strength
++ Fourth strength
+
+CONCERNS:
+1. First concern
+2. Second concern
+
+RECOMMENDATIONS:
+- Recommendation one
+- Recommendation two
+
+CONSENSUS: 80%
+`;
+
+    const result = parseConsensusResponse(response);
+
+    expect(result.strengths).toHaveLength(4);
+    expect(result.concerns).toHaveLength(2);
+    expect(result.recommendations).toHaveLength(2);
+  });
+
+  it('should handle various score formats', () => {
+    // With space
+    expect(parseConsensusResponse('CONSENSUS: 90%').score).toBe(90);
+
+    // Without space
+    expect(parseConsensusResponse('CONSENSUS:95%').score).toBe(95);
+
+    // Lowercase
+    expect(parseConsensusResponse('consensus: 88%').score).toBe(88);
+
+    // Mixed case
+    expect(parseConsensusResponse('Consensus: 75%').score).toBe(75);
+  });
+
+  it('should handle edge case scores', () => {
+    expect(parseConsensusResponse('CONSENSUS: 0%').score).toBe(0);
+    expect(parseConsensusResponse('CONSENSUS: 100%').score).toBe(100);
+  });
+});

package/tests/config/config.test.ts

@@ -0,0 +1,208 @@
+/**
+ * Tests for configuration management
+ */
+
+import { describe, it, expect } from 'vitest';
+import { DEFAULT_CONFIG } from '../../src/config/defaults.js';
+import { ConfigSchema } from '../../src/config/schema.js';
+import { deepMerge } from '../../src/config/index.js';
+
+describe('DEFAULT_CONFIG', () => {
+  it('should have all required sections', () => {
+    expect(DEFAULT_CONFIG.consensus).toBeDefined();
+    expect(DEFAULT_CONFIG.apis).toBeDefined();
+    expect(DEFAULT_CONFIG.project).toBeDefined();
+    expect(DEFAULT_CONFIG.directories).toBeDefined();
+    expect(DEFAULT_CONFIG.output).toBeDefined();
+  });
+
+  it('should have valid consensus defaults', () => {
+    expect(DEFAULT_CONFIG.consensus.threshold).toBe(95);
+    expect(DEFAULT_CONFIG.consensus.max_disagreements).toBe(5);
+    expect(DEFAULT_CONFIG.consensus.escalation_action).toBe('pause');
+  });
+
+  it('should have valid API defaults', () => {
+    expect(DEFAULT_CONFIG.apis.openai.model).toBe('gpt-4o');
+    expect(DEFAULT_CONFIG.apis.openai.temperature).toBe(0.3);
+    expect(DEFAULT_CONFIG.apis.openai.max_tokens).toBe(4096);
+  });
+
+  it('should have valid project defaults', () => {
+    expect(DEFAULT_CONFIG.project.default_language).toBe('python');
+    expect(DEFAULT_CONFIG.project.python.package_manager).toBe('pip');
+    expect(DEFAULT_CONFIG.project.typescript.package_manager).toBe('npm');
+  });
+
+  it('should pass schema validation', () => {
+    const result = ConfigSchema.safeParse(DEFAULT_CONFIG);
+    expect(result.success).toBe(true);
+  });
+});
+
+describe('ConfigSchema', () => {
+  it('should accept valid complete config', () => {
+    const config = {
+      consensus: {
+        threshold: 90,
+        max_disagreements: 3,
+        escalation_action: 'pause' as const,
+      },
+      apis: {
+        openai: {
+          model: 'gpt-4o-mini' as const,
+          temperature: 0.5,
+          max_tokens: 2048,
+          available_models: ['gpt-4o', 'gpt-4o-mini'],
+        },
+        claude: {
+          model: 'claude-sonnet-4-20250514',
+        },
+      },
+      project: {
+        default_language: 'typescript' as const,
+        python: {
+          package_manager: 'pip' as const,
+          test_framework: 'pytest',
+          min_version: '3.10',
+        },
+        typescript: {
+          package_manager: 'npm' as const,
+          test_framework: 'vitest' as const,
+          min_version: '18',
+        },
+      },
+      directories: {
+        docs: './docs',
+        tests: './tests',
+        plans: './plans',
+      },
+      output: {
+        format: 'markdown' as const,
+        verbose: true,
+        timestamps: false,
+        show_consensus_dialog: true,
+      },
+    };
+
+    const result = ConfigSchema.safeParse(config);
+    expect(result.success).toBe(true);
+  });
+
+  it('should accept partial config', () => {
+    const config = {
+      consensus: {
+        threshold: 80,
+      },
+    };
+
+    const result = ConfigSchema.safeParse(config);
+    expect(result.success).toBe(true);
+  });
+
+  it('should reject invalid threshold', () => {
+    const config = {
+      consensus: {
+        threshold: 150,
+      },
+    };
+
+    const result = ConfigSchema.safeParse(config);
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject invalid language', () => {
+    const config = {
+      project: {
+        default_language: 'java',
+      },
+    };
+
+    const result = ConfigSchema.safeParse(config);
+    expect(result.success).toBe(false);
+  });
+
+  it('should reject invalid model', () => {
+    const config = {
+      apis: {
+        openai: {
+          model: 'gpt-5',
+        },
+      },
+    };
+
+    const result = ConfigSchema.safeParse(config);
+    expect(result.success).toBe(false);
+  });
+});
+
+describe('deepMerge', () => {
+  it('should merge simple objects', () => {
+    const target = { a: 1, b: 2 };
+    const source = { b: 3, c: 4 };
+
+    const result = deepMerge(target, source);
+
+    expect(result).toEqual({ a: 1, b: 3, c: 4 });
+  });
+
+  it('should deep merge nested objects', () => {
+    const target = {
+      level1: {
+        level2: {
+          a: 1,
+          b: 2,
+        },
+      },
+    };
+    const source = {
+      level1: {
+        level2: {
+          b: 3,
+          c: 4,
+        },
+      },
+    };
+
+    const result = deepMerge(target, source);
+
+    expect(result).toEqual({
+      level1: {
+        level2: {
+          a: 1,
+          b: 3,
+          c: 4,
+        },
+      },
+    });
+  });
+
+  it('should not modify original objects', () => {
+    const target = { a: 1 };
+    const source = { b: 2 };
+
+    deepMerge(target, source);
+
+    expect(target).toEqual({ a: 1 });
+    expect(source).toEqual({ b: 2 });
+  });
+
+  it('should handle arrays by replacement', () => {
+    const target = { arr: [1, 2, 3] };
+    const source = { arr: [4, 5] };
+
+    const result = deepMerge(target, source);
+
+    expect(result.arr).toEqual([4, 5]);
+  });
+
+  it('should skip undefined values in source', () => {
+    const target = { a: 1, b: 2 };
+    const source = { a: undefined, c: 3 };
+
+    const result = deepMerge(target, source);
+
+    // deepMerge skips undefined values, keeping original
+    expect(result).toEqual({ a: 1, b: 2, c: 3 });
+  });
+});

package/tests/generators/generators.test.ts

@@ -0,0 +1,185 @@
+/**
+ * Tests for project generators
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  getProjectFiles,
+  getTestCommand,
+  getBuildCommand,
+  getLintCommand,
+  getFileExtension,
+  getSourceDir,
+  getTestDir,
+} from '../../src/generators/index.js';
+import {
+  generatePyprojectToml,
+  generateReadme as generatePythonReadme,
+  generateGitignore as generatePythonGitignore,
+} from '../../src/generators/templates/python.js';
+import {
+  generatePackageJson,
+  generateTsconfig,
+  generateReadme as generateTsReadme,
+  generateGitignore as generateTsGitignore,
+} from '../../src/generators/templates/typescript.js';
+
+describe('getProjectFiles', () => {
+  it('should return Python project files', () => {
+    const files = getProjectFiles('my-project', 'python');
+
+    expect(files).toContain('pyproject.toml');
+    expect(files).toContain('requirements.txt');
+    expect(files).toContain('README.md');
+    expect(files).toContain('tests/conftest.py');
+  });
+
+  it('should return TypeScript project files', () => {
+    const files = getProjectFiles('my-project', 'typescript');
+
+    expect(files).toContain('package.json');
+    expect(files).toContain('tsconfig.json');
+    expect(files).toContain('README.md');
+    expect(files).toContain('src/index.ts');
+  });
+});
+
+describe('getTestCommand', () => {
+  it('should return pytest for Python', () => {
+    expect(getTestCommand('python')).toContain('pytest');
+  });
+
+  it('should return npm test for TypeScript', () => {
+    expect(getTestCommand('typescript')).toContain('npm');
+  });
+});
+
+describe('getBuildCommand', () => {
+  it('should return pip install for Python', () => {
+    expect(getBuildCommand('python')).toContain('pip');
+  });
+
+  it('should return npm build for TypeScript', () => {
+    expect(getBuildCommand('typescript')).toContain('npm');
+    expect(getBuildCommand('typescript')).toContain('build');
+  });
+});
+
+describe('getLintCommand', () => {
+  it('should return ruff for Python', () => {
+    expect(getLintCommand('python')).toContain('ruff');
+  });
+
+  it('should return npm lint for TypeScript', () => {
+    expect(getLintCommand('typescript')).toContain('lint');
+  });
+});
+
+describe('getFileExtension', () => {
+  it('should return py for Python', () => {
+    expect(getFileExtension('python')).toBe('py');
+  });
+
+  it('should return ts for TypeScript', () => {
+    expect(getFileExtension('typescript')).toBe('ts');
+  });
+});
+
+describe('getSourceDir', () => {
+  it('should return src for both languages', () => {
+    expect(getSourceDir('python')).toBe('src');
+    expect(getSourceDir('typescript')).toBe('src');
+  });
+});
+
+describe('getTestDir', () => {
+  it('should return tests for both languages', () => {
+    expect(getTestDir('python')).toBe('tests');
+    expect(getTestDir('typescript')).toBe('tests');
+  });
+});
+
+describe('Python templates', () => {
+  describe('generatePyprojectToml', () => {
+    it('should generate valid pyproject.toml', () => {
+      const content = generatePyprojectToml('my-project');
+
+      expect(content).toContain('[build-system]');
+      expect(content).toContain('name = "my-project"');
+      expect(content).toContain('requires-python');
+      expect(content).toContain('[tool.pytest.ini_options]');
+    });
+  });
+
+  describe('generateReadme', () => {
+    it('should include project name', () => {
+      const readme = generatePythonReadme('awesome-app', 'An awesome application');
+
+      expect(readme).toContain('# awesome-app');
+      expect(readme).toContain('An awesome application');
+      expect(readme).toContain('Installation');
+      expect(readme).toContain('pytest');
+    });
+  });
+
+  describe('generateGitignore', () => {
+    it('should include Python patterns', () => {
+      const gitignore = generatePythonGitignore();
+
+      expect(gitignore).toContain('__pycache__');
+      expect(gitignore).toContain('*.py[cod]');  // Pattern for .pyc, .pyo, .pyd
+      expect(gitignore).toContain('venv');
+      expect(gitignore).toContain('.env');
+      expect(gitignore).toContain('.popeye');
+    });
+  });
+});
+
+describe('TypeScript templates', () => {
+  describe('generatePackageJson', () => {
+    it('should generate valid package.json', () => {
+      const content = generatePackageJson('my-app', 'Test app');
+      const pkg = JSON.parse(content);
+
+      expect(pkg.name).toBe('my-app');
+      expect(pkg.description).toBe('Test app');
+      expect(pkg.scripts.build).toBeDefined();
+      expect(pkg.scripts.test).toBeDefined();
+      expect(pkg.devDependencies.typescript).toBeDefined();
+    });
+  });
+
+  describe('generateTsconfig', () => {
+    it('should generate valid tsconfig.json', () => {
+      const content = generateTsconfig();
+      const config = JSON.parse(content);
+
+      expect(config.compilerOptions).toBeDefined();
+      expect(config.compilerOptions.strict).toBe(true);
+      expect(config.compilerOptions.target).toBe('ES2022');
+      expect(config.include).toContain('src/**/*');
+    });
+  });
+
+  describe('generateReadme', () => {
+    it('should include project name', () => {
+      const readme = generateTsReadme('cool-app', 'A cool application');
+
+      expect(readme).toContain('# cool-app');
+      expect(readme).toContain('A cool application');
+      expect(readme).toContain('npm install');
+      expect(readme).toContain('npm test');
+    });
+  });
+
+  describe('generateGitignore', () => {
+    it('should include Node patterns', () => {
+      const gitignore = generateTsGitignore();
+
+      expect(gitignore).toContain('node_modules');
+      expect(gitignore).toContain('dist');
+      expect(gitignore).toContain('.env');
+      expect(gitignore).toContain('.popeye');
+    });
+  });
+});

package/tests/types/consensus.test.ts

@@ -0,0 +1,152 @@
+/**
+ * Tests for consensus types and schemas
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  ConsensusConfigSchema,
+  DEFAULT_CONSENSUS_CONFIG,
+} from '../../src/types/consensus.js';
+
+describe('ConsensusConfigSchema', () => {
+  describe('valid inputs', () => {
+    it('should accept valid config with all fields', () => {
+      const config = {
+        threshold: 90,
+        maxIterations: 3,
+        openaiKey: 'sk-test-key',
+        openaiModel: 'gpt-4o' as const,
+        escalationAction: 'pause' as const,
+        temperature: 0.5,
+        maxTokens: 2048,
+      };
+
+      const result = ConsensusConfigSchema.safeParse(config);
+      expect(result.success).toBe(true);
+    });
+
+    it('should accept config with required fields only', () => {
+      const config = {
+        openaiKey: 'sk-test-key',
+        openaiModel: 'gpt-4o' as const,
+      };
+
+      const result = ConsensusConfigSchema.safeParse(config);
+      expect(result.success).toBe(true);
+    });
+
+    it('should accept threshold at boundaries', () => {
+      // Minimum threshold
+      const minResult = ConsensusConfigSchema.safeParse({
+        threshold: 0,
+        openaiKey: 'sk-test-key',
+        openaiModel: 'gpt-4o' as const,
+      });
+      expect(minResult.success).toBe(true);
+
+      // Maximum threshold
+      const maxResult = ConsensusConfigSchema.safeParse({
+        threshold: 100,
+        openaiKey: 'sk-test-key',
+        openaiModel: 'gpt-4o' as const,
+      });
+      expect(maxResult.success).toBe(true);
+    });
+  });
+
+  describe('invalid inputs', () => {
+    it('should reject threshold below 0', () => {
+      const config = {
+        threshold: -1,
+        openaiKey: 'sk-test-key',
+        openaiModel: 'gpt-4o' as const,
+      };
+      const result = ConsensusConfigSchema.safeParse(config);
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject threshold above 100', () => {
+      const config = {
+        threshold: 101,
+        openaiKey: 'sk-test-key',
+        openaiModel: 'gpt-4o' as const,
+      };
+      const result = ConsensusConfigSchema.safeParse(config);
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject maxIterations below 1', () => {
+      const config = {
+        maxIterations: 0,
+        openaiKey: 'sk-test-key',
+        openaiModel: 'gpt-4o' as const,
+      };
+      const result = ConsensusConfigSchema.safeParse(config);
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject maxIterations above 10', () => {
+      const config = {
+        maxIterations: 11,
+        openaiKey: 'sk-test-key',
+        openaiModel: 'gpt-4o' as const,
+      };
+      const result = ConsensusConfigSchema.safeParse(config);
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject temperature below 0', () => {
+      const config = {
+        temperature: -0.1,
+        openaiKey: 'sk-test-key',
+        openaiModel: 'gpt-4o' as const,
+      };
+      const result = ConsensusConfigSchema.safeParse(config);
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject temperature above 2', () => {
+      const config = {
+        temperature: 2.1,
+        openaiKey: 'sk-test-key',
+        openaiModel: 'gpt-4o' as const,
+      };
+      const result = ConsensusConfigSchema.safeParse(config);
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject maxTokens below 100', () => {
+      const config = {
+        maxTokens: 50,
+        openaiKey: 'sk-test-key',
+        openaiModel: 'gpt-4o' as const,
+      };
+      const result = ConsensusConfigSchema.safeParse(config);
+      expect(result.success).toBe(false);
+    });
+
+    it('should reject maxTokens above 32000', () => {
+      const config = {
+        maxTokens: 200000,
+        openaiKey: 'sk-test-key',
+        openaiModel: 'gpt-4o' as const,
+      };
+      const result = ConsensusConfigSchema.safeParse(config);
+      expect(result.success).toBe(false);
+    });
+  });
+});
+
+describe('DEFAULT_CONSENSUS_CONFIG', () => {
+  it('should have valid default values', () => {
+    expect(DEFAULT_CONSENSUS_CONFIG.threshold).toBe(95);
+    expect(DEFAULT_CONSENSUS_CONFIG.maxIterations).toBe(5);
+    expect(DEFAULT_CONSENSUS_CONFIG.openaiModel).toBe('gpt-4o');
+    expect(DEFAULT_CONSENSUS_CONFIG.temperature).toBe(0.3);
+    expect(DEFAULT_CONSENSUS_CONFIG.maxTokens).toBe(4096);
+  });
+
+  it('should have escalation action', () => {
+    expect(DEFAULT_CONSENSUS_CONFIG.escalationAction).toBe('pause');
+  });
+});