wiggum-cli 0.1.0

package/dist/utils/header.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Display the RALPH ASCII header in Simpson yellow
+ */
+export declare function displayHeader(): void;
+//# sourceMappingURL=header.d.ts.map

package/dist/utils/header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"header.d.ts","sourceRoot":"","sources":["../../src/utils/header.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,wBAAgB,aAAa,IAAI,IAAI,CASpC"}

package/dist/utils/header.js

@@ -0,0 +1,15 @@
+import cfonts from 'cfonts';
+/**
+ * Display the RALPH ASCII header in Simpson yellow
+ */
+export function displayHeader() {
+    cfonts.say('RALPH', {
+        font: 'block',
+        colors: ['#FED90F'],
+        letterSpacing: 1,
+        lineHeight: 1,
+        space: true,
+        maxLength: 0,
+    });
+}
+//# sourceMappingURL=header.js.map

package/dist/utils/header.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"header.js","sourceRoot":"","sources":["../../src/utils/header.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAE5B;;GAEG;AACH,MAAM,UAAU,aAAa;IAC3B,MAAM,CAAC,GAAG,CAAC,OAAO,EAAE;QAClB,IAAI,EAAE,OAAO;QACb,MAAM,EAAE,CAAC,SAAS,CAAC;QACnB,aAAa,EAAE,CAAC;QAChB,UAAU,EAAE,CAAC;QACb,KAAK,EAAE,IAAI;QACX,SAAS,EAAE,CAAC;KACb,CAAC,CAAC;AACL,CAAC"}

package/dist/utils/logger.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Logging utilities with colored output
+ */
+export declare const logger: {
+    info(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    debug(message: string): void;
+};
+//# sourceMappingURL=logger.d.ts.map

package/dist/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,eAAO,MAAM,MAAM;kBACH,MAAM,GAAG,IAAI;qBAIV,MAAM,GAAG,IAAI;kBAIhB,MAAM,GAAG,IAAI;mBAIZ,MAAM,GAAG,IAAI;mBAIb,MAAM,GAAG,IAAI;CAK7B,CAAC"}

package/dist/utils/logger.js

@@ -0,0 +1,24 @@
+import pc from 'picocolors';
+/**
+ * Logging utilities with colored output
+ */
+export const logger = {
+    info(message) {
+        console.log(pc.blue('info'), message);
+    },
+    success(message) {
+        console.log(pc.green('success'), message);
+    },
+    warn(message) {
+        console.log(pc.yellow('warn'), message);
+    },
+    error(message) {
+        console.log(pc.red('error'), message);
+    },
+    debug(message) {
+        if (process.env.DEBUG) {
+            console.log(pc.gray('debug'), message);
+        }
+    },
+};
+//# sourceMappingURL=logger.js.map

package/dist/utils/logger.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.js","sourceRoot":"","sources":["../../src/utils/logger.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B;;GAEG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;IACpB,IAAI,CAAC,OAAe;QAClB,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC;IACxC,CAAC;IAED,OAAO,CAAC,OAAe;QACrB,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE,OAAO,CAAC,CAAC;IAC5C,CAAC;IAED,IAAI,CAAC,OAAe;QAClB,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,CAAC;IAC1C,CAAC;IAED,KAAK,CAAC,OAAe;QACnB,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;IACxC,CAAC;IAED,KAAK,CAAC,OAAe;QACnB,IAAI,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,CAAC;YACtB,OAAO,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,OAAO,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;CACF,CAAC"}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "wiggum-cli",
+  "version": "0.1.0",
+  "description": "AI-powered feature development loop CLI",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "ralph": "./bin/ralph.js"
+  },
+  "scripts": {
+    "build": "tsc && npm run copy-templates",
+    "copy-templates": "cp -r src/templates dist/",
+    "dev": "tsc --watch",
+    "start": "node bin/ralph.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "cli",
+    "ai",
+    "development",
+    "automation",
+    "feature-loop",
+    "code-generation",
+    "tech-stack-detection"
+  ],
+  "author": "Ralph CLI Contributors",
+  "license": "MIT",
+  "dependencies": {
+    "@ai-sdk/anthropic": "^3.0.15",
+    "@ai-sdk/openai": "^3.0.12",
+    "@clack/prompts": "^0.7.0",
+    "ai": "^6.0.41",
+    "cfonts": "^3.2.0",
+    "commander": "^12.1.0",
+    "picocolors": "^1.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.0",
+    "typescript": "^5.3.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/src/ai/enhancer.ts

@@ -0,0 +1,350 @@
+/**
+ * AI Enhancer Module
+ * Uses AI to analyze the codebase for deeper insights
+ */
+
+import { generateText } from 'ai';
+import type { ScanResult, DetectedStack, DetectionResult } from '../scanner/types.js';
+import { getModel, type AIProvider, hasApiKey, getApiKeyEnvVar } from './providers.js';
+import { SYSTEM_PROMPT, createAnalysisPrompt } from './prompts.js';
+import { logger } from '../utils/logger.js';
+
+/**
+ * Framework insights from AI analysis
+ */
+export interface FrameworkInsights {
+  variant?: string;
+  confidence: 'high' | 'medium' | 'low';
+  notes?: string;
+}
+
+/**
+ * Architectural pattern detected by AI
+ */
+export interface ArchitecturalPattern {
+  pattern: string;
+  confidence: 'high' | 'medium' | 'low';
+  evidence: string;
+}
+
+/**
+ * Coding convention detected by AI
+ */
+export interface CodingConvention {
+  convention: string;
+  suggestion: string;
+}
+
+/**
+ * MCP server recommendation
+ */
+export interface McpRecommendation {
+  name: string;
+  reason: string;
+}
+
+/**
+ * Additional detection suggestions
+ */
+export interface AdditionalDetections {
+  possibleMissed?: string[];
+  refinements?: string[];
+}
+
+/**
+ * AI analysis result
+ */
+export interface AIAnalysisResult {
+  frameworkInsights?: FrameworkInsights;
+  architecturalPatterns?: ArchitecturalPattern[];
+  codingConventions?: CodingConvention[];
+  recommendedMcpServers?: McpRecommendation[];
+  customPromptSuggestions?: string[];
+  additionalDetections?: AdditionalDetections;
+}
+
+/**
+ * Enhanced scan result with AI insights
+ */
+export interface EnhancedScanResult extends ScanResult {
+  aiAnalysis?: AIAnalysisResult;
+  aiEnhanced: boolean;
+  aiProvider?: AIProvider;
+  aiError?: string;
+}
+
+/**
+ * Options for the AI enhancer
+ */
+export interface EnhancerOptions {
+  provider?: AIProvider;
+  verbose?: boolean;
+}
+
+/**
+ * Parse AI response JSON safely
+ */
+function parseAIResponse(text: string): AIAnalysisResult | null {
+  try {
+    // Try to extract JSON from the response
+    // The AI might wrap it in markdown code blocks
+    let jsonText = text;
+
+    // Remove markdown code blocks if present
+    const jsonMatch = text.match(/```(?:json)?\s*([\s\S]*?)```/);
+    if (jsonMatch) {
+      jsonText = jsonMatch[1];
+    }
+
+    // Try to find JSON object
+    const objectMatch = jsonText.match(/\{[\s\S]*\}/);
+    if (objectMatch) {
+      jsonText = objectMatch[0];
+    }
+
+    return JSON.parse(jsonText) as AIAnalysisResult;
+  } catch (error) {
+    logger.warn('Failed to parse AI response as JSON');
+    return null;
+  }
+}
+
+/**
+ * Apply AI insights to enhance the detected stack
+ */
+function applyEnhancements(
+  stack: DetectedStack,
+  analysis: AIAnalysisResult
+): DetectedStack {
+  const enhanced = { ...stack };
+
+  // Enhance framework detection with AI insights
+  if (analysis.frameworkInsights && enhanced.framework) {
+    // If AI detected a more specific variant with high confidence
+    if (
+      analysis.frameworkInsights.variant &&
+      analysis.frameworkInsights.confidence === 'high'
+    ) {
+      enhanced.framework = {
+        ...enhanced.framework,
+        variant: analysis.frameworkInsights.variant,
+        evidence: [
+          ...enhanced.framework.evidence,
+          `AI: ${analysis.frameworkInsights.notes || 'variant detected'}`,
+        ],
+      };
+    }
+  }
+
+  // Enhance MCP recommendations
+  if (analysis.recommendedMcpServers && analysis.recommendedMcpServers.length > 0) {
+    const aiRecommended = analysis.recommendedMcpServers.map(r => r.name);
+
+    enhanced.mcp = {
+      ...enhanced.mcp,
+      recommended: [
+        ...(enhanced.mcp?.recommended || []),
+        ...aiRecommended.filter(r => !enhanced.mcp?.recommended?.includes(r)),
+      ],
+    };
+  }
+
+  return enhanced;
+}
+
+/**
+ * AI Enhancer class
+ * Provides AI-powered analysis to enhance scan results
+ */
+export class AIEnhancer {
+  private provider: AIProvider;
+  private verbose: boolean;
+
+  constructor(options: EnhancerOptions = {}) {
+    this.provider = options.provider || 'anthropic';
+    this.verbose = options.verbose || false;
+  }
+
+  /**
+   * Check if AI enhancement is available
+   */
+  isAvailable(): boolean {
+    return hasApiKey(this.provider);
+  }
+
+  /**
+   * Get the required environment variable for the current provider
+   */
+  getRequiredEnvVar(): string {
+    return getApiKeyEnvVar(this.provider);
+  }
+
+  /**
+   * Enhance scan results with AI analysis
+   */
+  async enhance(scanResult: ScanResult): Promise<EnhancedScanResult> {
+    // Check if API key is available
+    if (!this.isAvailable()) {
+      const envVar = this.getRequiredEnvVar();
+      return {
+        ...scanResult,
+        aiEnhanced: false,
+        aiError: `API key not found. Set ${envVar} to enable AI enhancement.`,
+      };
+    }
+
+    try {
+      // Get the configured model
+      const { model, provider, modelId } = getModel(this.provider);
+
+      if (this.verbose) {
+        logger.info(`Using AI provider: ${provider} (${modelId})`);
+      }
+
+      // Create the analysis prompt
+      const prompt = createAnalysisPrompt(scanResult);
+
+      // Call the AI model
+      const { text } = await generateText({
+        model,
+        system: SYSTEM_PROMPT,
+        prompt,
+        maxOutputTokens: 2000,
+        temperature: 0.3, // Lower temperature for more consistent output
+      });
+
+      // Parse the response
+      const analysis = parseAIResponse(text);
+
+      if (!analysis) {
+        return {
+          ...scanResult,
+          aiEnhanced: false,
+          aiProvider: this.provider,
+          aiError: 'Failed to parse AI analysis response',
+        };
+      }
+
+      // Apply enhancements to the stack
+      const enhancedStack = applyEnhancements(scanResult.stack, analysis);
+
+      return {
+        ...scanResult,
+        stack: enhancedStack,
+        aiAnalysis: analysis,
+        aiEnhanced: true,
+        aiProvider: this.provider,
+      };
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger.error(`AI enhancement failed: ${errorMessage}`);
+
+      return {
+        ...scanResult,
+        aiEnhanced: false,
+        aiProvider: this.provider,
+        aiError: errorMessage,
+      };
+    }
+  }
+}
+
+/**
+ * Convenience function to enhance scan results with AI
+ */
+export async function enhanceWithAI(
+  scanResult: ScanResult,
+  options?: EnhancerOptions
+): Promise<EnhancedScanResult> {
+  const enhancer = new AIEnhancer(options);
+  return enhancer.enhance(scanResult);
+}
+
+/**
+ * Format AI analysis result for display
+ */
+export function formatAIAnalysis(analysis: AIAnalysisResult): string {
+  const lines: string[] = [];
+
+  lines.push('=== AI Analysis ===');
+  lines.push('');
+
+  // Framework insights
+  if (analysis.frameworkInsights) {
+    lines.push('Framework Insights:');
+    if (analysis.frameworkInsights.variant) {
+      lines.push(`  Variant: ${analysis.frameworkInsights.variant}`);
+    }
+    lines.push(`  Confidence: ${analysis.frameworkInsights.confidence}`);
+    if (analysis.frameworkInsights.notes) {
+      lines.push(`  Notes: ${analysis.frameworkInsights.notes}`);
+    }
+    lines.push('');
+  }
+
+  // Architectural patterns
+  if (analysis.architecturalPatterns && analysis.architecturalPatterns.length > 0) {
+    lines.push('Architectural Patterns:');
+    for (const pattern of analysis.architecturalPatterns) {
+      lines.push(`  - ${pattern.pattern} [${pattern.confidence}]`);
+      lines.push(`    Evidence: ${pattern.evidence}`);
+    }
+    lines.push('');
+  }
+
+  // Coding conventions
+  if (analysis.codingConventions && analysis.codingConventions.length > 0) {
+    lines.push('Coding Conventions:');
+    for (const convention of analysis.codingConventions) {
+      lines.push(`  - ${convention.convention}`);
+      lines.push(`    Suggestion: ${convention.suggestion}`);
+    }
+    lines.push('');
+  }
+
+  // MCP recommendations
+  if (analysis.recommendedMcpServers && analysis.recommendedMcpServers.length > 0) {
+    lines.push('Recommended MCP Servers:');
+    for (const server of analysis.recommendedMcpServers) {
+      lines.push(`  - ${server.name}`);
+      lines.push(`    Reason: ${server.reason}`);
+    }
+    lines.push('');
+  }
+
+  // Custom prompt suggestions
+  if (analysis.customPromptSuggestions && analysis.customPromptSuggestions.length > 0) {
+    lines.push('Custom Prompt Suggestions:');
+    for (const suggestion of analysis.customPromptSuggestions) {
+      lines.push(`  - ${suggestion}`);
+    }
+    lines.push('');
+  }
+
+  // Additional detections
+  if (analysis.additionalDetections) {
+    if (
+      analysis.additionalDetections.possibleMissed &&
+      analysis.additionalDetections.possibleMissed.length > 0
+    ) {
+      lines.push('Possibly Missed Technologies:');
+      for (const tech of analysis.additionalDetections.possibleMissed) {
+        lines.push(`  - ${tech}`);
+      }
+      lines.push('');
+    }
+
+    if (
+      analysis.additionalDetections.refinements &&
+      analysis.additionalDetections.refinements.length > 0
+    ) {
+      lines.push('Detection Refinements:');
+      for (const refinement of analysis.additionalDetections.refinements) {
+        lines.push(`  - ${refinement}`);
+      }
+      lines.push('');
+    }
+  }
+
+  return lines.join('\n');
+}

package/src/ai/index.ts

@@ -0,0 +1,38 @@
+/**
+ * AI Module
+ * Main export for AI-enhanced analysis functionality
+ */
+
+// Provider configuration
+export {
+  type AIProvider,
+  type ProviderConfig,
+  getModel,
+  hasApiKey,
+  getAvailableProvider,
+  getApiKeyEnvVar,
+} from './providers.js';
+
+// Analysis prompts
+export {
+  formatStackForPrompt,
+  SYSTEM_PROMPT,
+  createAnalysisPrompt,
+  createValidationPrompt,
+  createRecommendationsPrompt,
+} from './prompts.js';
+
+// AI enhancer
+export {
+  type FrameworkInsights,
+  type ArchitecturalPattern,
+  type CodingConvention,
+  type McpRecommendation,
+  type AdditionalDetections,
+  type AIAnalysisResult,
+  type EnhancedScanResult,
+  type EnhancerOptions,
+  AIEnhancer,
+  enhanceWithAI,
+  formatAIAnalysis,
+} from './enhancer.js';