wiggum-cli 0.4.8 → 0.5.0

package/src/ai/agents/index.ts

@@ -1,27 +1,29 @@
 /**
- * Agents Index
- * Multi-agent analysis with Orchestrator-Worker + Evaluator-Optimizer pattern
+ * Agents Index (v0.5.0)
+ * Simplified single-agent analysis with MCP detection
  *
  * Architecture:
- * Phase 1: Planning Orchestrator (creates analysis plan)
- * Phase 2: Parallel Workers (context enricher + tech researchers)
- * Phase 3: Synthesis (merge results + MCP detection)
- * Phase 4: Evaluator-Optimizer (QA loop)
+ * Phase 1: Codebase Analyzer (unified agent with tools)
+ * Phase 2: MCP Detection (pure function)
+ *
+ * This replaces the complex 4-phase multi-agent system (v0.4.5-v0.4.9)
+ * which added overhead without improving output quality.
  */
 
 // Types - export all for consumers
 export type {
-  // New architecture types
+  // New architecture types (v0.5.0)
+  CodebaseAnalyzerInput,
+  RalphMcpServers,
+  ProgressCallback,
+  // Legacy types (backward compatibility)
   AnalysisPlan,
   EnrichedContext,
   TechResearchResult,
-  RalphMcpServers,
   EvaluationResult,
   ContextEnricherInput,
   TechResearcherInput,
   SynthesisInput,
-  ProgressCallback,
-  // Legacy types (backward compatibility)
   CodebaseAnalysis,
   StackResearch,
   McpRecommendations,
@@ -33,16 +35,17 @@ export type {
   OrchestratorInput,
 } from './types.js';
 
-// New architecture exports
+// v0.5.0 exports
+export { runCodebaseAnalyzer } from './codebase-analyzer.js';
+export { detectRalphMcpServers, convertToLegacyMcpRecommendations } from './mcp-detector.js';
+export { detectProjectType } from './stack-utils.js';
+
+// Legacy exports (deprecated but kept for backward compatibility)
 export { runPlanningOrchestrator } from './planning-orchestrator.js';
 export { runContextEnricher } from './context-enricher.js';
 export { runTechResearcher, runTechResearchPool } from './tech-researcher.js';
-export { detectRalphMcpServers, convertToLegacyMcpRecommendations } from './mcp-detector.js';
 export { runSynthesisAgent } from './synthesis-agent.js';
 export { runEvaluatorOptimizer } from './evaluator-optimizer.js';
-export { detectProjectType } from './stack-utils.js';
-
-// Legacy exports (for backward compatibility during migration)
 export { runCodebaseAnalyst } from './codebase-analyst.js';
 export { runStackResearcher } from './stack-researcher.js';
 export { runOrchestrator, mergeAgentResults } from './orchestrator.js';
@@ -52,26 +55,24 @@ import type { LanguageModel } from 'ai';
 import type { ScanResult } from '../../scanner/types.js';
 import type {
   MultiAgentAnalysis,
-  AgentCapabilities,
   AgentOptions,
-  EnrichedContext,
 } from './types.js';
-import { runPlanningOrchestrator } from './planning-orchestrator.js';
-import { runContextEnricher } from './context-enricher.js';
-import { runTechResearchPool } from './tech-researcher.js';
-import { detectRalphMcpServers } from './mcp-detector.js';
-import { runSynthesisAgent } from './synthesis-agent.js';
-import { runEvaluatorOptimizer } from './evaluator-optimizer.js';
+import { runCodebaseAnalyzer } from './codebase-analyzer.js';
 import { detectProjectType } from './stack-utils.js';
+import { detectRalphMcpServers, convertToLegacyMcpRecommendations } from './mcp-detector.js';
 import { logger } from '../../utils/logger.js';
 
 /**
- * Run the full multi-agent analysis pipeline (new architecture)
+ * Run simplified multi-agent analysis pipeline (v0.5.0)
+ *
+ * Phase 1: Codebase Analyzer - Single agent explores codebase with tools
+ * Phase 2: MCP Detection - Pure function detects required MCP servers
  *
- * Phase 1: Planning Orchestrator - Creates focused analysis plan
- * Phase 2: Parallel Workers - Context enricher + tech researchers run concurrently
- * Phase 3: Synthesis - Merges results + detects MCPs
- * Phase 4: Evaluator-Optimizer - QA loop (max 2 iterations)
+ * This simplified architecture reduces:
+ * - Token cost: ~15,000 → ~5,000
+ * - LLM calls: 7-11 → 2-3
+ * - Agents: 7 → 1
+ * - Failure points: Many → Few
  */
 export async function runMultiAgentAnalysis(
   model: LanguageModel,
@@ -79,9 +80,9 @@ export async function runMultiAgentAnalysis(
   scanResult: ScanResult,
   options: AgentOptions = {}
 ): Promise<MultiAgentAnalysis | null> {
-  const { tavilyApiKey, context7ApiKey, verbose = false, onProgress } = options;
+  const { verbose = false, onProgress } = options;
 
-  // Helper to report progress (uses callback or falls back to logger)
+  // Helper to report progress
   const report = (phase: string, detail?: string) => {
     if (onProgress) {
       onProgress(phase, detail);
@@ -90,116 +91,36 @@ export async function runMultiAgentAnalysis(
     }
   };
 
-  // Determine capabilities
-  const capabilities: AgentCapabilities = {
-    hasTavily: !!tavilyApiKey,
-    hasContext7: !!context7ApiKey,
-  };
-
   if (verbose && !onProgress) {
-    logger.info('Starting multi-agent analysis (4-phase architecture)...');
-    logger.info(`Capabilities: Tavily=${capabilities.hasTavily}, Context7=${capabilities.hasContext7}`);
+    logger.info('Starting simplified analysis (v0.5.0)...');
   }
 
   try {
     // ═══════════════════════════════════════════════════════════════
-    // PHASE 1: Planning Orchestrator
-    // ═══════════════════════════════════════════════════════════════
-    report('Phase 1/4: Planning');
-
-    const plan = await runPlanningOrchestrator(model, modelId, scanResult, verbose && !onProgress);
-
-    report('Phase 1/4: Planning', `${plan.areasToExplore.length} areas, ${plan.technologiesToResearch.length} technologies`);
-
-    // ═══════════════════════════════════════════════════════════════
-    // PHASE 2: Parallel Workers
-    // ═══════════════════════════════════════════════════════════════
-    const workerCount = plan.technologiesToResearch.length + 1; // tech researchers + context enricher
-    report('Phase 2/4: Analyzing', `${workerCount} parallel workers`);
-
-    // Run context enricher and tech researchers in parallel with error recovery
-    const [contextResult, researchResult] = await Promise.allSettled([
-      runContextEnricher(
-        model,
-        modelId,
-        {
-          scanResult,
-          areasToExplore: plan.areasToExplore,
-          questionsToAnswer: plan.questionsToAnswer,
-        },
-        verbose && !onProgress
-      ),
-      runTechResearchPool(
-        model,
-        modelId,
-        plan.technologiesToResearch,
-        { tavilyApiKey, context7ApiKey },
-        verbose && !onProgress
-      ),
-    ]);
-
-    // Extract results with fallbacks for failed workers
-    const enrichedContext = contextResult.status === 'fulfilled'
-      ? contextResult.value
-      : getDefaultEnrichedContext(scanResult);
-
-    const techResearch = researchResult.status === 'fulfilled'
-      ? researchResult.value
-      : [];
-
-    // Log any worker failures
-    if (contextResult.status === 'rejected') {
-      logger.warn(`Context Enricher failed: ${contextResult.reason instanceof Error ? contextResult.reason.message : String(contextResult.reason)}`);
-    }
-    if (researchResult.status === 'rejected') {
-      logger.warn(`Tech Research Pool failed: ${researchResult.reason instanceof Error ? researchResult.reason.message : String(researchResult.reason)}`);
-    }
-
-    report('Phase 2/4: Analyzing', 'complete');
-
-    // ═══════════════════════════════════════════════════════════════
-    // PHASE 3: Synthesis + MCP Detection
+    // PHASE 1: Codebase Analyzer (unified agent)
     // ═══════════════════════════════════════════════════════════════
-    report('Phase 3/4: Synthesizing');
-
-    // Detect MCPs (pure function, no LLM) - pass project type for context-aware recommendations
-    const mcpServers = detectRalphMcpServers(scanResult.stack, enrichedContext.projectType);
+    report('Phase 1/2: Analyzing codebase');
 
-    // Run synthesis agent
-    const synthesizedResult = await runSynthesisAgent(
+    const result = await runCodebaseAnalyzer(
       model,
       modelId,
-      {
-        enrichedContext,
-        techResearch,
-        mcpServers,
-        plan,
-        stack: scanResult.stack,
-      },
+      { scanResult },
       verbose && !onProgress
     );
 
-    report('Phase 3/4: Synthesizing', 'complete');
+    report('Phase 1/2: Analyzing codebase', 'complete');
 
     // ═══════════════════════════════════════════════════════════════
-    // PHASE 4: Evaluator-Optimizer QA Loop
+    // PHASE 2: MCP Detection (already done in analyzer, just report)
     // ═══════════════════════════════════════════════════════════════
-    report('Phase 4/4: Quality check');
+    report('Phase 2/2: Detecting MCP servers');
 
-    const finalResult = await runEvaluatorOptimizer(
-      model,
-      modelId,
-      synthesizedResult,
-      scanResult,
-      2, // Max 2 iterations
-      verbose && !onProgress
-    );
-
-    report('Phase 4/4: Quality check', 'complete');
+    const mcpCount = result.mcpServers.essential.length + result.mcpServers.recommended.length;
+    report('Phase 2/2: Detecting MCP servers', `${mcpCount} servers detected`);
 
-    return finalResult;
+    return result;
   } catch (error) {
-    logger.error(`Multi-agent analysis failed: ${error instanceof Error ? error.message : String(error)}`);
+    logger.error(`Analysis failed: ${error instanceof Error ? error.message : String(error)}`);
 
     // Fall back to default result
     return getDefaultMultiAgentAnalysis(scanResult);
@@ -211,6 +132,7 @@ export async function runMultiAgentAnalysis(
  */
 function getDefaultMultiAgentAnalysis(scanResult: ScanResult): MultiAgentAnalysis {
   const projectType = detectProjectType(scanResult.stack);
+  const mcpServers = detectRalphMcpServers(scanResult.stack, projectType);
 
   return {
     codebaseAnalysis: {
@@ -242,29 +164,6 @@ function getDefaultMultiAgentAnalysis(scanResult: ScanResult): MultiAgentAnalysi
       documentationHints: ['Check official docs'],
       researchMode: 'knowledge-only',
     },
-    mcpServers: {
-      essential: ['filesystem', 'git', 'playwright'],
-      recommended: [],
-    },
-  };
-}
-
-/**
- * Get default enriched context when Context Enricher fails
- */
-function getDefaultEnrichedContext(scanResult: ScanResult): EnrichedContext {
-  const projectType = detectProjectType(scanResult.stack);
-
-  return {
-    entryPoints: ['src/index.ts'],
-    keyDirectories: { src: 'Source code' },
-    namingConventions: 'camelCase',
-    commands: {
-      test: 'npm test',
-      build: 'npm run build',
-      dev: 'npm run dev',
-    },
-    answeredQuestions: {},
-    projectType,
+    mcpServers: convertToLegacyMcpRecommendations(mcpServers),
   };
 }

package/src/ai/agents/planning-orchestrator.ts

@@ -1,6 +1,10 @@
 /**
  * Planning Orchestrator Agent (Phase 1)
  * Creates an analysis plan that guides the parallel workers
+ *
+ * @deprecated v0.5.0 - No longer used in main pipeline.
+ * The unified codebase-analyzer.ts replaces this agent.
+ * Kept for backward compatibility and reference.
  */
 
 import { type LanguageModel } from 'ai';

package/src/ai/agents/synthesis-agent.ts

@@ -1,6 +1,10 @@
 /**
  * Synthesis Agent (Phase 3)
  * Merges results from parallel workers and generates implementation guidelines
+ *
+ * @deprecated v0.5.0 - No longer used in main pipeline.
+ * The unified codebase-analyzer.ts outputs directly without synthesis.
+ * Kept for backward compatibility and reference.
  */
 
 import { type LanguageModel } from 'ai';

package/src/ai/agents/tech-researcher.ts

@@ -2,6 +2,10 @@
  * Tech Researcher Worker (Phase 2)
  * Researches best practices for a specific technology
  * Multiple instances run in parallel via runTechResearchPool
+ *
+ * @deprecated v0.5.0 - No longer used in main pipeline.
+ * Tech research is now handled by the model's built-in knowledge.
+ * Kept for backward compatibility and reference.
  */
 
 import { stepCountIs, type LanguageModel, type Tool } from 'ai';

package/src/ai/agents/types.ts

@@ -255,8 +255,17 @@ export interface OrchestratorInput {
 // New Agent Input Types
 // ============================================================
 
+/**
+ * Input for the Codebase Analyzer (v0.5.0 unified agent)
+ */
+export interface CodebaseAnalyzerInput {
+  /** The scan result from the scanner */
+  scanResult: ScanResult;
+}
+
 /**
  * Input for the Context Enricher worker
+ * @deprecated Use CodebaseAnalyzerInput with runCodebaseAnalyzer
  */
 export interface ContextEnricherInput {
   /** The scan result from the scanner */