popeye-cli 1.0.0

package/src/workflow/plan-mode.ts

@@ -0,0 +1,356 @@
+/**
+ * Plan Mode workflow
+ * Handles idea expansion, plan creation, and consensus building
+ */
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import type { ProjectSpec } from '../types/project.js';
+import type { ProjectState, Milestone, Task } from '../types/workflow.js';
+import type { ConsensusConfig } from '../types/consensus.js';
+import { expandIdea as openaiExpandIdea } from '../adapters/openai.js';
+import { createPlan as claudeCreatePlan, analyzeCodebase } from '../adapters/claude.js';
+import {
+  createProject,
+  loadProject,
+  setPhase,
+  storePlan,
+  storeSpecification,
+  addMilestones,
+} from '../state/index.js';
+import { iterateUntilConsensus, type ConsensusProcessResult } from './consensus.js';
+
+/**
+ * Options for plan mode
+ */
+export interface PlanModeOptions {
+  projectDir: string;
+  consensusConfig?: Partial<ConsensusConfig>;
+  onProgress?: (phase: string, message: string) => void;
+}
+
+/**
+ * Result of plan mode
+ */
+export interface PlanModeResult {
+  success: boolean;
+  state: ProjectState;
+  consensusResult?: ConsensusProcessResult;
+  error?: string;
+}
+
+/**
+ * Expand a brief idea into a detailed specification
+ *
+ * @param idea - The brief project idea
+ * @param language - Target programming language
+ * @param onProgress - Progress callback
+ * @returns Expanded specification
+ */
+export async function expandIdea(
+  idea: string,
+  language: 'python' | 'typescript',
+  onProgress?: (message: string) => void
+): Promise<string> {
+  onProgress?.('Expanding idea into specification...');
+
+  const specification = await openaiExpandIdea(idea, language);
+
+  onProgress?.('Specification created');
+  return specification;
+}
+
+/**
+ * Create a development plan from a specification
+ *
+ * @param specification - The project specification
+ * @param context - Additional context
+ * @param onProgress - Progress callback
+ * @returns Development plan
+ */
+export async function createPlan(
+  specification: string,
+  context: string = '',
+  onProgress?: (message: string) => void
+): Promise<string> {
+  onProgress?.('Creating development plan...');
+
+  const result = await claudeCreatePlan(specification, context);
+
+  if (!result.success) {
+    throw new Error(`Failed to create plan: ${result.error}`);
+  }
+
+  onProgress?.('Development plan created');
+  return result.response;
+}
+
+/**
+ * Get existing project context by analyzing the codebase
+ *
+ * @param projectDir - The project directory
+ * @param onProgress - Progress callback
+ * @returns Context string
+ */
+export async function getProjectContext(
+  projectDir: string,
+  onProgress?: (message: string) => void
+): Promise<string> {
+  onProgress?.('Analyzing existing codebase...');
+
+  // Check if directory has any code
+  try {
+    const files = await fs.readdir(projectDir);
+    const hasCode = files.some((f) =>
+      ['.py', '.ts', '.js', '.tsx', '.jsx'].some((ext) => f.endsWith(ext))
+    );
+
+    if (!hasCode) {
+      onProgress?.('No existing code found');
+      return 'New project - no existing codebase';
+    }
+
+    const result = await analyzeCodebase(projectDir);
+
+    if (result.success) {
+      onProgress?.('Codebase analysis complete');
+      return result.response;
+    }
+
+    return 'Unable to analyze codebase';
+  } catch {
+    return 'New project - no existing codebase';
+  }
+}
+
+/**
+ * Save the plan to a markdown file
+ *
+ * @param projectDir - The project directory
+ * @param plan - The plan content
+ * @param filename - The filename (default: PLAN.md)
+ */
+export async function documentPlan(
+  projectDir: string,
+  plan: string,
+  filename: string = 'PLAN.md'
+): Promise<string> {
+  const planPath = path.join(projectDir, filename);
+
+  const content = `# Development Plan
+
+Generated: ${new Date().toISOString()}
+
+${plan}
+`;
+
+  await fs.writeFile(planPath, content, 'utf-8');
+  return planPath;
+}
+
+/**
+ * Parse milestones and tasks from a plan
+ *
+ * @param plan - The plan content
+ * @returns Parsed milestones with tasks
+ */
+export function parsePlanMilestones(plan: string): Omit<Milestone, 'id'>[] {
+  const milestones: Omit<Milestone, 'id'>[] = [];
+
+  // Look for milestone sections
+  const milestonePattern = /#+\s*(?:Milestone\s*\d+[:\s]*)?([^\n]+)\n([\s\S]*?)(?=#+\s*(?:Milestone|$)|$)/gi;
+  const taskPattern = /[-*]\s*(?:\[[ x]\]\s*)?(?:Task[:\s]*)?(.+)/gi;
+
+  let match;
+  while ((match = milestonePattern.exec(plan)) !== null) {
+    const name = match[1].trim();
+    const content = match[2];
+
+    // Skip non-milestone sections
+    if (name.toLowerCase().includes('background') ||
+        name.toLowerCase().includes('goal') ||
+        name.toLowerCase().includes('risk') ||
+        name.toLowerCase().includes('summary')) {
+      continue;
+    }
+
+    const tasks: Omit<Task, 'id' | 'status' | 'testsPassed'>[] = [];
+    let taskMatch;
+
+    while ((taskMatch = taskPattern.exec(content)) !== null) {
+      const taskName = taskMatch[1].trim();
+      if (taskName && !taskName.toLowerCase().startsWith('test')) {
+        tasks.push({
+          name: taskName,
+          description: taskName,
+        });
+      }
+    }
+
+    if (tasks.length > 0 || name.toLowerCase().includes('milestone')) {
+      milestones.push({
+        name,
+        description: content.slice(0, 200).trim(),
+        tasks: tasks as Task[],
+        status: 'pending',
+      });
+    }
+  }
+
+  // If no milestones found, create a default one
+  if (milestones.length === 0) {
+    milestones.push({
+      name: 'Implementation',
+      description: 'Main implementation milestone',
+      tasks: [],
+      status: 'pending',
+    });
+  }
+
+  return milestones;
+}
+
+/**
+ * Run the complete plan mode workflow
+ *
+ * @param spec - The project specification
+ * @param options - Plan mode options
+ * @returns Plan mode result
+ */
+export async function runPlanMode(
+  spec: ProjectSpec,
+  options: PlanModeOptions
+): Promise<PlanModeResult> {
+  const { projectDir, consensusConfig, onProgress } = options;
+
+  try {
+    // Create or load project
+    onProgress?.('plan-init', 'Initializing project...');
+
+    let state: ProjectState;
+    try {
+      state = await loadProject(projectDir);
+      onProgress?.('plan-init', 'Loaded existing project');
+    } catch {
+      state = await createProject(spec, projectDir);
+      onProgress?.('plan-init', 'Created new project');
+    }
+
+    // Expand idea if we don't have a specification
+    if (!state.specification) {
+      onProgress?.('expand-idea', 'Expanding idea into specification...');
+      const specification = await expandIdea(
+        spec.idea,
+        spec.language,
+        (msg) => onProgress?.('expand-idea', msg)
+      );
+
+      state = await storeSpecification(projectDir, specification);
+      onProgress?.('expand-idea', 'Specification complete');
+    }
+
+    // Get project context
+    onProgress?.('get-context', 'Gathering project context...');
+    const context = await getProjectContext(
+      projectDir,
+      (msg) => onProgress?.('get-context', msg)
+    );
+
+    // Create initial plan if we don't have one
+    if (!state.plan) {
+      onProgress?.('create-plan', 'Creating development plan...');
+      const plan = await createPlan(
+        state.specification!,
+        context,
+        (msg) => onProgress?.('create-plan', msg)
+      );
+
+      state = await storePlan(projectDir, plan);
+      onProgress?.('create-plan', 'Initial plan created');
+    }
+
+    // Run consensus loop
+    onProgress?.('consensus', 'Starting consensus review...');
+    const consensusResult = await iterateUntilConsensus(
+      state.plan!,
+      context,
+      {
+        projectDir,
+        config: consensusConfig,
+        onIteration: (iteration, result) => {
+          onProgress?.(
+            'consensus',
+            `Iteration ${iteration}: Score ${result.score}%`
+          );
+        },
+        onRevision: (iteration, _plan) => {
+          onProgress?.('consensus', `Revising plan (iteration ${iteration})...`);
+        },
+      }
+    );
+
+    // Store final plan
+    if (consensusResult.approved) {
+      state = await storePlan(projectDir, consensusResult.finalPlan);
+
+      // Parse and add milestones
+      const milestones = parsePlanMilestones(consensusResult.finalPlan);
+      state = await addMilestones(projectDir, milestones);
+
+      // Document the plan
+      await documentPlan(projectDir, consensusResult.finalPlan);
+
+      // Transition to execution phase
+      state = await setPhase(projectDir, 'execution');
+
+      onProgress?.('complete', `Plan approved with ${consensusResult.finalScore}% consensus`);
+    } else {
+      onProgress?.(
+        'failed',
+        `Consensus not reached after ${consensusResult.totalIterations} iterations (${consensusResult.finalScore}%)`
+      );
+    }
+
+    return {
+      success: consensusResult.approved,
+      state,
+      consensusResult,
+    };
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+    onProgress?.('error', errorMessage);
+
+    return {
+      success: false,
+      state: await loadProject(projectDir).catch(() => ({} as ProjectState)),
+      error: errorMessage,
+    };
+  }
+}
+
+/**
+ * Resume plan mode from where it left off
+ *
+ * @param projectDir - The project directory
+ * @param options - Plan mode options
+ * @returns Plan mode result
+ */
+export async function resumePlanMode(
+  projectDir: string,
+  options: Omit<PlanModeOptions, 'projectDir'>
+): Promise<PlanModeResult> {
+  const state = await loadProject(projectDir);
+
+  return runPlanMode(
+    {
+      idea: state.idea,
+      name: state.name,
+      language: state.language,
+      openaiModel: state.openaiModel,
+    },
+    {
+      ...options,
+      projectDir,
+    }
+  );
+}

package/src/workflow/test-runner.ts

@@ -0,0 +1,345 @@
+/**
+ * Test runner module
+ * Handles running tests for Python and TypeScript projects
+ */
+
+import { runTests as claudeRunTests } from '../adapters/claude.js';
+import type { OutputLanguage } from '../types/project.js';
+
+/**
+ * Test result from running tests
+ */
+export interface TestResult {
+  success: boolean;
+  passed: number;
+  failed: number;
+  total: number;
+  output: string;
+  failedTests?: string[];
+  error?: string;
+}
+
+/**
+ * Test configuration
+ */
+export interface TestConfig {
+  language: OutputLanguage;
+  testDir?: string;
+  coverage?: boolean;
+  verbose?: boolean;
+  timeout?: number;
+}
+
+/**
+ * Default test commands by language
+ */
+export const DEFAULT_TEST_COMMANDS: Record<OutputLanguage, string> = {
+  python: 'python -m pytest tests/ -v',
+  typescript: 'npm test',
+};
+
+/**
+ * Build the test command for a language
+ *
+ * @param config - Test configuration
+ * @returns The test command to run
+ */
+export function buildTestCommand(config: TestConfig): string {
+  const { language, testDir, coverage, verbose } = config;
+
+  switch (language) {
+    case 'python': {
+      const parts = ['python', '-m', 'pytest'];
+
+      if (testDir) {
+        parts.push(testDir);
+      } else {
+        parts.push('tests/');
+      }
+
+      if (verbose) {
+        parts.push('-v');
+      }
+
+      if (coverage) {
+        parts.push('--cov=src', '--cov-report=term-missing');
+      }
+
+      return parts.join(' ');
+    }
+
+    case 'typescript': {
+      const parts = ['npm', 'test'];
+
+      if (coverage) {
+        parts.push('--', '--coverage');
+      }
+
+      return parts.join(' ');
+    }
+  }
+}
+
+/**
+ * Parse test output to extract results
+ *
+ * @param output - The test command output
+ * @param language - The project language
+ * @returns Parsed test result
+ */
+export function parseTestOutput(output: string, language: OutputLanguage): TestResult {
+  let passed = 0;
+  let failed = 0;
+  let total = 0;
+  const failedTests: string[] = [];
+
+  switch (language) {
+    case 'python': {
+      // Parse pytest output
+      // Example: "5 passed, 2 failed, 1 skipped in 2.34s"
+      const summaryMatch = output.match(/(\d+)\s+passed/);
+      const failedMatch = output.match(/(\d+)\s+failed/);
+
+      if (summaryMatch) {
+        passed = parseInt(summaryMatch[1], 10);
+      }
+
+      if (failedMatch) {
+        failed = parseInt(failedMatch[1], 10);
+      }
+
+      total = passed + failed;
+
+      // Extract failed test names
+      const failedTestMatches = output.matchAll(/FAILED\s+([^\s]+)/g);
+      for (const match of failedTestMatches) {
+        failedTests.push(match[1]);
+      }
+      break;
+    }
+
+    case 'typescript': {
+      // Parse Jest/Vitest output
+      // Example: "Tests: 2 failed, 5 passed, 7 total"
+      const summaryMatch = output.match(/Tests:\s*(?:(\d+)\s+failed,\s*)?(\d+)\s+passed,\s*(\d+)\s+total/);
+
+      if (summaryMatch) {
+        failed = summaryMatch[1] ? parseInt(summaryMatch[1], 10) : 0;
+        passed = parseInt(summaryMatch[2], 10);
+        total = parseInt(summaryMatch[3], 10);
+      }
+
+      // Extract failed test names
+      const failedTestMatches = output.matchAll(/✕\s+(.+)/g);
+      for (const match of failedTestMatches) {
+        failedTests.push(match[1].trim());
+      }
+      break;
+    }
+  }
+
+  const success = failed === 0 && total > 0;
+
+  return {
+    success,
+    passed,
+    failed,
+    total,
+    output,
+    failedTests: failedTests.length > 0 ? failedTests : undefined,
+  };
+}
+
+/**
+ * Run Python tests
+ *
+ * @param cwd - Working directory
+ * @param config - Test configuration
+ * @returns Test result
+ */
+export async function runPythonTests(
+  cwd: string,
+  config: Partial<TestConfig> = {}
+): Promise<TestResult> {
+  const testCommand = buildTestCommand({
+    language: 'python',
+    ...config,
+  });
+
+  try {
+    const result = await claudeRunTests(testCommand, cwd);
+
+    if (!result.success && result.error) {
+      return {
+        success: false,
+        passed: 0,
+        failed: 0,
+        total: 0,
+        output: result.response,
+        error: result.error,
+      };
+    }
+
+    return parseTestOutput(result.response, 'python');
+  } catch (error) {
+    return {
+      success: false,
+      passed: 0,
+      failed: 0,
+      total: 0,
+      output: '',
+      error: error instanceof Error ? error.message : 'Unknown error running tests',
+    };
+  }
+}
+
+/**
+ * Run TypeScript tests
+ *
+ * @param cwd - Working directory
+ * @param config - Test configuration
+ * @returns Test result
+ */
+export async function runTypeScriptTests(
+  cwd: string,
+  config: Partial<TestConfig> = {}
+): Promise<TestResult> {
+  const testCommand = buildTestCommand({
+    language: 'typescript',
+    ...config,
+  });
+
+  try {
+    const result = await claudeRunTests(testCommand, cwd);
+
+    if (!result.success && result.error) {
+      return {
+        success: false,
+        passed: 0,
+        failed: 0,
+        total: 0,
+        output: result.response,
+        error: result.error,
+      };
+    }
+
+    return parseTestOutput(result.response, 'typescript');
+  } catch (error) {
+    return {
+      success: false,
+      passed: 0,
+      failed: 0,
+      total: 0,
+      output: '',
+      error: error instanceof Error ? error.message : 'Unknown error running tests',
+    };
+  }
+}
+
+/**
+ * Run tests for a project
+ *
+ * @param cwd - Working directory
+ * @param language - Project language
+ * @param config - Test configuration
+ * @returns Test result
+ */
+export async function runTests(
+  cwd: string,
+  language: OutputLanguage,
+  config: Partial<TestConfig> = {}
+): Promise<TestResult> {
+  switch (language) {
+    case 'python':
+      return runPythonTests(cwd, config);
+    case 'typescript':
+      return runTypeScriptTests(cwd, config);
+  }
+}
+
+/**
+ * Check if tests exist in a project
+ *
+ * @param cwd - Working directory
+ * @param language - Project language
+ * @returns True if tests exist
+ */
+export async function testsExist(
+  cwd: string,
+  language: OutputLanguage
+): Promise<boolean> {
+  const { promises: fs } = await import('node:fs');
+  const path = await import('node:path');
+
+  try {
+    switch (language) {
+      case 'python': {
+        // Check for tests/ directory or test_*.py files
+        const testsDir = path.join(cwd, 'tests');
+        try {
+          await fs.access(testsDir);
+          return true;
+        } catch {
+          // Check for test files in root
+          const files = await fs.readdir(cwd);
+          return files.some((f) => f.startsWith('test_') && f.endsWith('.py'));
+        }
+      }
+
+      case 'typescript': {
+        // Check for tests/, __tests__, or *.test.ts files
+        const testsDir = path.join(cwd, 'tests');
+        const testsDirAlt = path.join(cwd, '__tests__');
+
+        try {
+          await fs.access(testsDir);
+          return true;
+        } catch {
+          try {
+            await fs.access(testsDirAlt);
+            return true;
+          } catch {
+            // Check for test files in src
+            const srcDir = path.join(cwd, 'src');
+            try {
+              const files = await fs.readdir(srcDir, { recursive: true });
+              return files.some(
+                (f) =>
+                  (f.toString().endsWith('.test.ts') || f.toString().endsWith('.spec.ts'))
+              );
+            } catch {
+              return false;
+            }
+          }
+        }
+      }
+    }
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get test summary string
+ *
+ * @param result - Test result
+ * @returns Human-readable summary
+ */
+export function getTestSummary(result: TestResult): string {
+  if (result.error) {
+    return `Tests failed to run: ${result.error}`;
+  }
+
+  if (result.total === 0) {
+    return 'No tests found';
+  }
+
+  const status = result.success ? '✓' : '✗';
+  let summary = `${status} ${result.passed}/${result.total} tests passed`;
+
+  if (result.failed > 0) {
+    summary += ` (${result.failed} failed)`;
+  }
+
+  return summary;
+}