wiggum-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Ralph CLI Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,341 @@
+# ralph-cli
+
+**AI-powered feature development loop CLI** - Auto-detect your tech stack and generate intelligent development environments.
+
+```
+ ██████╗   █████╗  ██╗      ██████╗  ██╗  ██╗
+ ██╔══██╗ ██╔══██╗ ██║      ██╔══██╗ ██║  ██║
+ ██████╔╝ ███████║ ██║      ██████╔╝ ███████║
+ ██╔══██╗ ██╔══██║ ██║      ██╔═══╝  ██╔══██║
+ ██║  ██║ ██║  ██║ ███████╗ ██║      ██║  ██║
+ ╚═╝  ╚═╝ ╚═╝  ╚═╝ ╚══════╝ ╚═╝      ╚═╝  ╚═╝
+```
+*Simpson Yellow (#FED90F) branding*
+
+## Installation
+
+```bash
+# Initialize in your project (recommended)
+npx ralph-cli init
+
+# Or install globally
+npm install -g ralph-cli
+```
+
+## Quick Start
+
+```bash
+# 1. Initialize Ralph in your project
+npx ralph-cli init
+
+# 2. Create a new feature specification
+ralph new my-feature
+
+# 3. Edit the spec file (opens in your editor)
+ralph new my-feature --edit
+
+# 4. Run the feature development loop
+ralph run my-feature
+
+# 5. Monitor progress in real-time
+ralph monitor my-feature
+```
+
+## Commands
+
+### `ralph init`
+
+Initialize Ralph in the current project. Scans your codebase to detect the tech stack and generates configuration files.
+
+```bash
+ralph init [options]
+```
+
+**Options:**
+| Flag | Description |
+|------|-------------|
+| `--ai` | Enable AI-enhanced analysis for deeper insights |
+| `--provider <name>` | AI provider: `anthropic`, `openai`, or `openrouter` (default: `anthropic`) |
+| `-y, --yes` | Accept defaults and skip confirmations |
+
+**Examples:**
+```bash
+# Basic initialization with interactive prompts
+ralph init
+
+# Initialize with AI enhancement using Anthropic
+ralph init --ai
+
+# Initialize with OpenAI provider, skip confirmations
+ralph init --ai --provider openai --yes
+```
+
+---
+
+### `ralph run <feature>`
+
+Run the feature development loop for a specific feature. Executes the AI-driven implementation workflow.
+
+```bash
+ralph run <feature> [options]
+```
+
+**Options:**
+| Flag | Description |
+|------|-------------|
+| `--worktree` | Use git worktree for isolation (enables parallel execution) |
+| `--resume` | Resume an interrupted loop (reuses existing branch/worktree) |
+| `--model <model>` | Claude model to use (e.g., `opus`, `sonnet`) |
+| `--max-iterations <n>` | Maximum implementation iterations (default: 50) |
+| `--max-e2e-attempts <n>` | Maximum E2E test retry attempts (default: 3) |
+
+**Examples:**
+```bash
+# Run the feature loop
+ralph run user-authentication
+
+# Run with git worktree isolation
+ralph run payment-flow --worktree
+
+# Resume an interrupted session
+ralph run payment-flow --resume
+
+# Use specific model with iteration limits
+ralph run my-feature --model opus --max-iterations 30
+```
+
+---
+
+### `ralph monitor <feature>`
+
+Launch the monitoring dashboard to track feature development progress in real-time.
+
+```bash
+ralph monitor <feature> [options]
+```
+
+**Options:**
+| Flag | Description |
+|------|-------------|
+| `--interval <seconds>` | Refresh interval in seconds (default: 5) |
+| `--bash` | Use bash script monitor instead of built-in |
+| `--python` | Use Python TUI monitor (if available) |
+
+**Examples:**
+```bash
+# Monitor with default settings
+ralph monitor user-authentication
+
+# Monitor with faster refresh rate
+ralph monitor my-feature --interval 2
+
+# Use bash monitor script
+ralph monitor my-feature --bash
+```
+
+---
+
+### `ralph new <feature>`
+
+Create a new feature specification from template.
+
+```bash
+ralph new <feature> [options]
+```
+
+**Options:**
+| Flag | Description |
+|------|-------------|
+| `-e, --edit` | Open in editor after creation |
+| `--editor <editor>` | Editor to use (defaults to `$EDITOR` or `code`) |
+| `-y, --yes` | Skip confirmation prompts |
+| `-f, --force` | Force overwrite if file exists |
+
+**Examples:**
+```bash
+# Create a new spec with interactive prompts
+ralph new user-dashboard
+
+# Create and open in VS Code
+ralph new user-dashboard --edit
+
+# Create with vim, skip confirmations
+ralph new user-dashboard --edit --editor vim --yes
+
+# Overwrite existing spec
+ralph new user-dashboard --force
+```
+
+## Generated Files Structure
+
+After running `ralph init`, the following structure is created:
+
+```
+.ralph/
+├── ralph.config.js          # Main configuration file
+├── prompts/                  # AI prompt templates
+│   ├── PROMPT.md            # Implementation prompt
+│   ├── PROMPT_feature.md    # Feature planning prompt
+│   ├── PROMPT_e2e.md        # E2E testing prompt
+│   ├── PROMPT_verify.md     # Verification prompt
+│   └── PROMPT_review.md     # PR review prompt
+├── scripts/                  # Automation scripts
+│   ├── feature-loop.sh      # Main development loop
+│   └── ralph-monitor.sh     # Monitoring script
+├── specs/                    # Feature specifications
+│   └── _example.md          # Example spec template
+└── CLAUDE.md                # Project context for Claude
+```
+
+## Detection Capabilities
+
+Ralph automatically detects and configures support for:
+
+### Core
+- **Frameworks:** Next.js (App/Pages Router), React, Vue, Nuxt, Svelte, SvelteKit, Remix, Astro
+- **Package Managers:** npm, yarn, pnpm, bun
+- **Testing:** Jest, Vitest (unit), Playwright, Cypress (E2E)
+- **Styling:** Tailwind CSS, CSS Modules, Styled Components, Emotion, Sass
+
+### Data Layer
+- **Databases:** PostgreSQL, MySQL, SQLite, MongoDB, Redis
+- **ORMs:** Prisma, Drizzle, TypeORM, Mongoose, Kysely
+- **APIs:** REST, GraphQL, tRPC, OpenAPI
+
+### Frontend
+- **State Management:** Zustand, Jotai, Redux, Pinia, Recoil, MobX, Valtio
+- **UI Components:** shadcn/ui, Radix, Material UI, Chakra UI, Ant Design, Headless UI
+- **Form Handling:** React Hook Form, Formik, Zod, Yup
+
+### Services
+- **Authentication:** NextAuth.js, Clerk, Auth0, Supabase Auth, Lucia, Better Auth
+- **Analytics:** PostHog, Mixpanel, Amplitude, Google Analytics, Plausible
+- **Payments:** Stripe, Paddle, LemonSqueezy
+- **Email:** Resend, SendGrid, Postmark, Mailgun
+
+### Infrastructure
+- **Deployment:** Vercel, Netlify, Railway, Fly.io, Docker, AWS
+- **Monorepos:** Turborepo, Nx, Lerna, pnpm workspaces
+
+### MCP (Model Context Protocol)
+- Detects existing MCP server configurations
+- Identifies if project is an MCP server/client
+- Recommends relevant MCP servers based on stack
+
+## AI Enhancement
+
+Ralph supports AI-enhanced analysis for deeper project insights:
+
+```bash
+ralph init --ai --provider anthropic
+```
+
+### Supported Providers
+
+| Provider | Environment Variable | Description |
+|----------|---------------------|-------------|
+| Anthropic | `ANTHROPIC_API_KEY` | Claude models (recommended) |
+| OpenAI | `OPENAI_API_KEY` | GPT models |
+| OpenRouter | `OPENROUTER_API_KEY` | Multiple model providers |
+
+### AI Analysis Features
+
+When AI enhancement is enabled, Ralph provides:
+- **Architecture Analysis:** Understanding of project structure and patterns
+- **Code Quality Insights:** Best practices and potential improvements
+- **Dependency Review:** Security and update recommendations
+- **Custom Recommendations:** Tailored suggestions for your stack
+
+## Configuration
+
+### ralph.config.js
+
+```javascript
+export default {
+  // Project paths
+  paths: {
+    root: '.ralph',
+    specs: '.ralph/specs',
+    prompts: '.ralph/prompts',
+    scripts: '.ralph/scripts',
+  },
+
+  // Feature loop settings
+  loop: {
+    maxIterations: 10,
+    maxE2eAttempts: 5,
+    defaultModel: 'sonnet',
+  },
+
+  // AI settings
+  ai: {
+    provider: 'anthropic',
+    enhance: false,
+  },
+
+  // Detected stack (auto-populated)
+  stack: {
+    framework: { name: 'Next.js', version: '14.0.0' },
+    testing: {
+      unit: { name: 'Vitest' },
+      e2e: { name: 'Playwright' },
+    },
+    // ... other detected technologies
+  },
+};
+```
+
+## Requirements
+
+- Node.js 18.0.0 or higher
+- Git (for worktree features)
+- Claude Code CLI (for running the development loop)
+
+## Environment Variables
+
+| Variable | Required | Description |
+|----------|----------|-------------|
+| `ANTHROPIC_API_KEY` | For AI features | Anthropic API key |
+| `OPENAI_API_KEY` | For OpenAI provider | OpenAI API key |
+| `OPENROUTER_API_KEY` | For OpenRouter provider | OpenRouter API key |
+| `EDITOR` | Optional | Default editor for `--edit` flag |
+| `DEBUG` | Optional | Enable debug logging |
+
+## Contributing
+
+Contributions are welcome! Please read our contributing guidelines before submitting a pull request.
+
+### Development Setup
+
+```bash
+# Clone the repository
+git clone https://github.com/your-org/ralph-cli.git
+cd ralph-cli
+
+# Install dependencies
+npm install
+
+# Build the project
+npm run build
+
+# Run locally
+node bin/ralph.js init
+```
+
+### Running Tests
+
+```bash
+# Type checking
+npx tsc --noEmit
+
+# Run tests (when available)
+npm test
+```
+
+## License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+---
+
+Built with Simpson Yellow (#FED90F) by the Ralph team.

package/bin/ralph.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+
+import { main } from '../dist/index.js';
+
+main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/dist/ai/enhancer.d.ts

@@ -0,0 +1,100 @@
+/**
+ * AI Enhancer Module
+ * Uses AI to analyze the codebase for deeper insights
+ */
+import type { ScanResult } from '../scanner/types.js';
+import { type AIProvider } from './providers.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;
+}
+/**
+ * AI Enhancer class
+ * Provides AI-powered analysis to enhance scan results
+ */
+export declare class AIEnhancer {
+    private provider;
+    private verbose;
+    constructor(options?: EnhancerOptions);
+    /**
+     * Check if AI enhancement is available
+     */
+    isAvailable(): boolean;
+    /**
+     * Get the required environment variable for the current provider
+     */
+    getRequiredEnvVar(): string;
+    /**
+     * Enhance scan results with AI analysis
+     */
+    enhance(scanResult: ScanResult): Promise<EnhancedScanResult>;
+}
+/**
+ * Convenience function to enhance scan results with AI
+ */
+export declare function enhanceWithAI(scanResult: ScanResult, options?: EnhancerOptions): Promise<EnhancedScanResult>;
+/**
+ * Format AI analysis result for display
+ */
+export declare function formatAIAnalysis(analysis: AIAnalysisResult): string;
+//# sourceMappingURL=enhancer.d.ts.map

package/dist/ai/enhancer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enhancer.d.ts","sourceRoot":"","sources":["../../src/ai/enhancer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,UAAU,EAAkC,MAAM,qBAAqB,CAAC;AACtF,OAAO,EAAY,KAAK,UAAU,EAA8B,MAAM,gBAAgB,CAAC;AAIvF;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACtC,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;IACtC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,qBAAqB,CAAC,EAAE,oBAAoB,EAAE,CAAC;IAC/C,iBAAiB,CAAC,EAAE,gBAAgB,EAAE,CAAC;IACvC,qBAAqB,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAC5C,uBAAuB,CAAC,EAAE,MAAM,EAAE,CAAC;IACnC,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,UAAU;IACpD,UAAU,CAAC,EAAE,gBAAgB,CAAC;IAC9B,UAAU,EAAE,OAAO,CAAC;IACpB,UAAU,CAAC,EAAE,UAAU,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,EAAE,UAAU,CAAC;IACtB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAyED;;;GAGG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAa;IAC7B,OAAO,CAAC,OAAO,CAAU;gBAEb,OAAO,GAAE,eAAoB;IAKzC;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,iBAAiB,IAAI,MAAM;IAI3B;;OAEG;IACG,OAAO,CAAC,UAAU,EAAE,UAAU,GAAG,OAAO,CAAC,kBAAkB,CAAC;CAiEnE;AAED;;GAEG;AACH,wBAAsB,aAAa,CACjC,UAAU,EAAE,UAAU,EACtB,OAAO,CAAC,EAAE,eAAe,GACxB,OAAO,CAAC,kBAAkB,CAAC,CAG7B;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,MAAM,CAoFnE"}

package/dist/ai/enhancer.js

@@ -0,0 +1,233 @@
+/**
+ * AI Enhancer Module
+ * Uses AI to analyze the codebase for deeper insights
+ */
+import { generateText } from 'ai';
+import { getModel, hasApiKey, getApiKeyEnvVar } from './providers.js';
+import { SYSTEM_PROMPT, createAnalysisPrompt } from './prompts.js';
+import { logger } from '../utils/logger.js';
+/**
+ * Parse AI response JSON safely
+ */
+function parseAIResponse(text) {
+    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);
+    }
+    catch (error) {
+        logger.warn('Failed to parse AI response as JSON');
+        return null;
+    }
+}
+/**
+ * Apply AI insights to enhance the detected stack
+ */
+function applyEnhancements(stack, analysis) {
+    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 {
+    provider;
+    verbose;
+    constructor(options = {}) {
+        this.provider = options.provider || 'anthropic';
+        this.verbose = options.verbose || false;
+    }
+    /**
+     * Check if AI enhancement is available
+     */
+    isAvailable() {
+        return hasApiKey(this.provider);
+    }
+    /**
+     * Get the required environment variable for the current provider
+     */
+    getRequiredEnvVar() {
+        return getApiKeyEnvVar(this.provider);
+    }
+    /**
+     * Enhance scan results with AI analysis
+     */
+    async enhance(scanResult) {
+        // 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, options) {
+    const enhancer = new AIEnhancer(options);
+    return enhancer.enhance(scanResult);
+}
+/**
+ * Format AI analysis result for display
+ */
+export function formatAIAnalysis(analysis) {
+    const lines = [];
+    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');
+}
+//# sourceMappingURL=enhancer.js.map