popeye-cli 1.0.0

package/src/adapters/claude.ts

@@ -0,0 +1,298 @@
+/**
+ * Claude Agent SDK adapter
+ * Wraps the Claude Agent SDK for code execution and generation
+ */
+
+import { query, type SDKMessage } from '@anthropic-ai/claude-agent-sdk';
+
+/**
+ * Options for executing a prompt through Claude
+ */
+export interface ClaudeExecuteOptions {
+  cwd?: string;
+  allowedTools?: string[];
+  permissionMode?: 'default' | 'acceptEdits' | 'bypassPermissions' | 'plan';
+  systemPrompt?: string;
+  timeout?: number;
+  onMessage?: (message: SDKMessage) => void;
+}
+
+/**
+ * Result from Claude execution
+ */
+export interface ClaudeExecuteResult {
+  success: boolean;
+  response: string;
+  toolCalls: ToolCallRecord[];
+  error?: string;
+}
+
+/**
+ * Record of a tool call made by Claude
+ */
+export interface ToolCallRecord {
+  tool: string;
+  input: Record<string, unknown>;
+  output?: string;
+}
+
+/**
+ * Default allowed tools for autonomous operation
+ */
+export const DEFAULT_ALLOWED_TOOLS = [
+  'Read',
+  'Write',
+  'Edit',
+  'MultiEdit',
+  'Bash',
+  'Grep',
+  'Glob',
+  'LS',
+  'TodoRead',
+  'TodoWrite',
+];
+
+/**
+ * Execute a prompt through the Claude Agent SDK
+ *
+ * @param prompt - The prompt to execute
+ * @param options - Execution options
+ * @returns The execution result
+ */
+export async function executePrompt(
+  prompt: string,
+  options: ClaudeExecuteOptions = {}
+): Promise<ClaudeExecuteResult> {
+  const {
+    cwd,
+    allowedTools = DEFAULT_ALLOWED_TOOLS,
+    permissionMode = 'bypassPermissions',
+    systemPrompt,
+    onMessage,
+  } = options;
+
+  const toolCalls: ToolCallRecord[] = [];
+  let response = '';
+  let error: string | undefined;
+
+  try {
+    const result = query({
+      prompt,
+      options: {
+        cwd,
+        allowedTools,
+        permissionMode,
+        systemPrompt: systemPrompt || { type: 'preset', preset: 'claude_code' },
+      },
+    });
+
+    for await (const message of result) {
+      // Call the message handler if provided
+      if (onMessage) {
+        onMessage(message);
+      }
+
+      // Process different message types
+      if (message.type === 'assistant') {
+        const assistantMessage = message as { type: 'assistant'; message: { content: string | Array<{ type: string; text?: string }> } };
+        if (typeof assistantMessage.message.content === 'string') {
+          response += assistantMessage.message.content;
+        } else if (Array.isArray(assistantMessage.message.content)) {
+          for (const block of assistantMessage.message.content) {
+            if (block.type === 'text' && block.text) {
+              response += block.text;
+            }
+          }
+        }
+      } else if (message.type === 'result') {
+        // Handle result messages which may contain tool information
+        const resultMessage = message as { type: 'result'; result?: string; error?: { message: string } };
+        if (resultMessage.error) {
+          error = resultMessage.error.message;
+        }
+      }
+    }
+
+    return {
+      success: !error,
+      response: response.trim(),
+      toolCalls,
+      error,
+    };
+  } catch (err) {
+    return {
+      success: false,
+      response: '',
+      toolCalls,
+      error: err instanceof Error ? err.message : 'Unknown error executing prompt',
+    };
+  }
+}
+
+/**
+ * Execute code generation for a specific task
+ *
+ * @param task - The task description
+ * @param context - Additional context about the project
+ * @param options - Execution options
+ */
+export async function generateCode(
+  task: string,
+  context: string,
+  options: ClaudeExecuteOptions = {}
+): Promise<ClaudeExecuteResult> {
+  const prompt = `
+## Task
+${task}
+
+## Project Context
+${context}
+
+## Instructions
+1. Implement the task following best practices
+2. Write clean, well-documented code
+3. Include appropriate error handling
+4. Follow the project's existing patterns and style
+
+Please implement this task now.
+`.trim();
+
+  return executePrompt(prompt, {
+    ...options,
+    allowedTools: options.allowedTools || [
+      ...DEFAULT_ALLOWED_TOOLS,
+      'WebSearch',
+      'WebFetch',
+    ],
+  });
+}
+
+/**
+ * Run tests and capture results
+ *
+ * @param testCommand - The test command to run
+ * @param cwd - Working directory
+ */
+export async function runTests(
+  testCommand: string,
+  cwd?: string
+): Promise<ClaudeExecuteResult> {
+  const prompt = `
+Run the following test command and report the results:
+
+\`\`\`bash
+${testCommand}
+\`\`\`
+
+After running the tests:
+1. Report the total number of tests
+2. Report how many passed and failed
+3. If there are failures, summarize what failed
+4. Provide any relevant error messages
+`.trim();
+
+  return executePrompt(prompt, {
+    cwd,
+    allowedTools: ['Bash', 'Read'],
+    permissionMode: 'bypassPermissions',
+  });
+}
+
+/**
+ * Analyze codebase to understand structure and patterns
+ *
+ * @param cwd - Working directory of the project
+ */
+export async function analyzeCodebase(cwd: string): Promise<ClaudeExecuteResult> {
+  const prompt = `
+Analyze this codebase and provide:
+
+1. **Project Structure**: Overview of directories and their purposes
+2. **Key Technologies**: Languages, frameworks, and major dependencies
+3. **Architecture Patterns**: Design patterns and architectural decisions observed
+4. **Code Style**: Naming conventions, formatting, and documentation style
+5. **Test Setup**: Testing framework and test organization
+6. **Build/Deploy**: Build tools and deployment configuration
+
+Be concise but thorough in your analysis.
+`.trim();
+
+  return executePrompt(prompt, {
+    cwd,
+    allowedTools: ['Read', 'Glob', 'Grep', 'LS'],
+    permissionMode: 'default', // Read-only analysis
+  });
+}
+
+/**
+ * Create a development plan from a specification
+ *
+ * @param specification - The project specification
+ * @param context - Additional context (existing code, etc.)
+ */
+export async function createPlan(
+  specification: string,
+  context: string = ''
+): Promise<ClaudeExecuteResult> {
+  const prompt = `
+Create a detailed development plan for the following specification:
+
+## Specification
+${specification}
+
+${context ? `## Additional Context\n${context}` : ''}
+
+## Required Plan Sections
+
+1. **Background & Context**: Summarize the project requirements
+2. **Goals & Objectives**: List measurable objectives
+3. **Milestones**: Break down into major phases
+4. **Tasks**: Detail specific tasks for each milestone
+5. **Test Plan**: Define tests for each task
+6. **Risks & Mitigations**: Identify potential issues
+
+Format the plan as markdown with clear sections and bullet points.
+`.trim();
+
+  return executePrompt(prompt, {
+    allowedTools: ['Read', 'Glob'],
+    permissionMode: 'plan',
+  });
+}
+
+/**
+ * Revise a plan based on feedback
+ *
+ * @param originalPlan - The original plan
+ * @param feedback - Feedback to incorporate
+ * @param concerns - Specific concerns to address
+ */
+export async function revisePlan(
+  originalPlan: string,
+  feedback: string,
+  concerns: string[]
+): Promise<ClaudeExecuteResult> {
+  const prompt = `
+Revise the following plan based on the feedback provided:
+
+## Original Plan
+${originalPlan}
+
+## Feedback
+${feedback}
+
+## Specific Concerns to Address
+${concerns.map((c, i) => `${i + 1}. ${c}`).join('\n')}
+
+## Instructions
+1. Address each concern specifically
+2. Maintain the same plan structure
+3. Note what changed from the original
+4. Ensure the revised plan is complete and actionable
+`.trim();
+
+  return executePrompt(prompt, {
+    allowedTools: [],
+    permissionMode: 'plan',
+  });
+}

package/src/adapters/openai.ts

@@ -0,0 +1,300 @@
+/**
+ * OpenAI API adapter
+ * Handles consensus reviews and plan validation
+ */
+
+import OpenAI from 'openai';
+import type { ConsensusResult, ConsensusConfig, OpenAIModel } from '../types/index.js';
+import { getOpenAIToken } from '../auth/index.js';
+import { DEFAULT_CONSENSUS_CONFIG } from '../types/consensus.js';
+
+/**
+ * Create an OpenAI client with stored credentials
+ */
+export async function createClient(): Promise<OpenAI> {
+  const apiKey = await getOpenAIToken();
+
+  if (!apiKey) {
+    throw new Error('OpenAI API key not found. Run: popeye-cli auth openai');
+  }
+
+  return new OpenAI({ apiKey });
+}
+
+/**
+ * Request consensus review from OpenAI
+ *
+ * @param plan - The development plan to review
+ * @param context - Project context
+ * @param config - Consensus configuration
+ * @returns Consensus result
+ */
+export async function requestConsensus(
+  plan: string,
+  context: string,
+  config: Partial<ConsensusConfig> = {}
+): Promise<ConsensusResult> {
+  const {
+    openaiModel = DEFAULT_CONSENSUS_CONFIG.openaiModel,
+    temperature = DEFAULT_CONSENSUS_CONFIG.temperature,
+    maxTokens = DEFAULT_CONSENSUS_CONFIG.maxTokens,
+  } = config;
+
+  const client = await createClient();
+
+  // Build the consensus review prompt (matches spec section 11.1)
+  const prompt = buildConsensusPrompt(plan, context);
+
+  try {
+    const completion = await client.chat.completions.create({
+      model: openaiModel,
+      messages: [{ role: 'user', content: prompt }],
+      temperature,
+      max_tokens: maxTokens,
+    });
+
+    const response = completion.choices[0]?.message?.content || '';
+    return parseConsensusResponse(response);
+  } catch (error) {
+    if (error instanceof OpenAI.RateLimitError) {
+      // Implement exponential backoff retry
+      await sleep(5000);
+      return requestConsensus(plan, context, config);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Build the consensus review prompt
+ * Follows spec section 11.1 format
+ */
+function buildConsensusPrompt(plan: string, context: string): string {
+  return `You are a senior software architect reviewing a development plan.
+Analyze the following plan for completeness, correctness, and feasibility.
+
+PROJECT CONTEXT:
+${context}
+
+PROPOSED PLAN:
+${plan}
+
+Please provide:
+1. ANALYSIS: Detailed review of the plan
+2. STRENGTHS: What works well
+3. CONCERNS: Issues or gaps identified
+4. RECOMMENDATIONS: Specific improvements
+5. CONSENSUS SCORE: A percentage (0-100%) indicating your agreement
+   - 95-100%: Ready for execution
+   - 80-94%: Minor revisions needed
+   - 60-79%: Significant revisions needed
+   - Below 60%: Major rework required
+
+Format your consensus score as: CONSENSUS: [X]%
+
+Be thorough but constructive in your feedback.`;
+}
+
+/**
+ * Parse the consensus response from OpenAI
+ * Extracts score, analysis, concerns, etc.
+ */
+export function parseConsensusResponse(response: string): ConsensusResult {
+  // Extract consensus score
+  const scoreMatch = response.match(/CONSENSUS:\s*(\d+)%/i);
+  const score = scoreMatch ? parseInt(scoreMatch[1], 10) : 0;
+
+  // Extract sections
+  const analysis = extractSection(response, 'ANALYSIS', 'STRENGTHS');
+  const strengthsText = extractSection(response, 'STRENGTHS', 'CONCERNS');
+  const concernsText = extractSection(response, 'CONCERNS', 'RECOMMENDATIONS');
+  const recommendationsText = extractSection(response, 'RECOMMENDATIONS', 'CONSENSUS');
+
+  // Parse lists from sections
+  const strengths = parseList(strengthsText);
+  const concerns = parseList(concernsText);
+  const recommendations = parseList(recommendationsText);
+
+  return {
+    score,
+    analysis: analysis.trim(),
+    strengths,
+    concerns,
+    recommendations,
+    approved: score >= 95,
+    rawResponse: response,
+  };
+}
+
+/**
+ * Extract a section from the response between two headers
+ */
+function extractSection(response: string, startHeader: string, endHeader: string): string {
+  const startPattern = new RegExp(`${startHeader}[:\\s]*`, 'i');
+  const endPattern = new RegExp(`${endHeader}[:\\s]*`, 'i');
+
+  const startMatch = response.match(startPattern);
+  if (!startMatch) return '';
+
+  const startIndex = startMatch.index! + startMatch[0].length;
+  const endMatch = response.slice(startIndex).match(endPattern);
+
+  if (!endMatch) {
+    return response.slice(startIndex).trim();
+  }
+
+  return response.slice(startIndex, startIndex + endMatch.index!).trim();
+}
+
+/**
+ * Parse a bulleted or numbered list from text
+ */
+function parseList(text: string): string[] {
+  if (!text) return [];
+
+  const lines = text.split('\n');
+  const items: string[] = [];
+
+  for (const line of lines) {
+    // Match bullets (-, *, +) or numbers (1., 2., etc.)
+    const match = line.match(/^[\s]*[-*+][\s]+(.+)$|^[\s]*\d+\.[\s]+(.+)$/);
+    if (match) {
+      const item = (match[1] || match[2]).trim();
+      if (item) {
+        items.push(item);
+      }
+    } else if (line.trim() && !line.match(/^[A-Z]+:/)) {
+      // Non-empty line that's not a header
+      items.push(line.trim());
+    }
+  }
+
+  return items;
+}
+
+/**
+ * Helper sleep function for rate limiting
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Validate that a model is available
+ */
+export async function validateModel(model: OpenAIModel): Promise<boolean> {
+  try {
+    const client = await createClient();
+    const models = await client.models.list();
+    return models.data.some((m) => m.id === model);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * List available models
+ */
+export async function listAvailableModels(): Promise<string[]> {
+  try {
+    const client = await createClient();
+    const models = await client.models.list();
+
+    return models.data
+      .filter(
+        (m) =>
+          m.id.includes('gpt-4') ||
+          m.id.includes('gpt-3.5') ||
+          m.id.startsWith('o1')
+      )
+      .map((m) => m.id)
+      .sort();
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Expand a brief idea into a full specification using OpenAI
+ *
+ * @param idea - The brief project idea
+ * @param language - Target programming language
+ * @returns Expanded specification
+ */
+export async function expandIdea(
+  idea: string,
+  language: 'python' | 'typescript'
+): Promise<string> {
+  const client = await createClient();
+
+  const prompt = `You are a senior software architect. A user wants to build a project with the following idea:
+
+"${idea}"
+
+The project will be implemented in ${language === 'python' ? 'Python' : 'TypeScript'}.
+
+Expand this into a complete software specification including:
+
+1. **Project Overview**: A clear description of what will be built
+2. **Core Features**: List of main features and functionality
+3. **Technical Requirements**:
+   - Language and framework choices
+   - Database requirements (if any)
+   - External APIs or services needed
+   - Authentication requirements (if any)
+4. **Architecture Overview**: High-level system design
+5. **API Specification** (if applicable): Key endpoints and their purposes
+6. **Data Models**: Key entities and their relationships
+7. **Non-Functional Requirements**: Performance, security, scalability considerations
+8. **Deployment**: Docker configuration and deployment approach
+
+Be specific and actionable. The specification should be detailed enough that a developer could implement it without further clarification.`;
+
+  const completion = await client.chat.completions.create({
+    model: 'gpt-4o',
+    messages: [{ role: 'user', content: prompt }],
+    temperature: 0.7,
+    max_tokens: 4096,
+  });
+
+  return completion.choices[0]?.message?.content || idea;
+}
+
+/**
+ * Get feedback on generated code
+ *
+ * @param code - The code to review
+ * @param context - Context about what the code should do
+ */
+export async function reviewCode(code: string, context: string): Promise<ConsensusResult> {
+  const client = await createClient();
+
+  const prompt = `You are a senior software engineer reviewing code. Review the following code:
+
+CONTEXT:
+${context}
+
+CODE:
+\`\`\`
+${code}
+\`\`\`
+
+Provide:
+1. ANALYSIS: Overall code quality assessment
+2. STRENGTHS: What's done well
+3. CONCERNS: Issues, bugs, or improvements needed
+4. RECOMMENDATIONS: Specific fixes or enhancements
+5. CONSENSUS SCORE: A percentage (0-100%) of how production-ready this code is
+
+Format your score as: CONSENSUS: [X]%`;
+
+  const completion = await client.chat.completions.create({
+    model: 'gpt-4o',
+    messages: [{ role: 'user', content: prompt }],
+    temperature: 0.3,
+    max_tokens: 2048,
+  });
+
+  const response = completion.choices[0]?.message?.content || '';
+  return parseConsensusResponse(response);
+}