@claudetools/cli 0.9.4 → 0.9.6

package/dist/onboard/docs-builder.js

@@ -0,0 +1,1037 @@
+// =============================================================================
+// Documentation Builder
+// =============================================================================
+// Builds comprehensive docs/ directory structure for AI agent assistance
+import { existsSync, mkdirSync, writeFileSync, readFileSync, appendFileSync } from 'fs';
+import { join } from 'path';
+import { isClaudeCliAvailable } from './claude-inference.js';
+import { spawn } from 'child_process';
+// =============================================================================
+// Directory Structure
+// =============================================================================
+const DOCS_STRUCTURE = {
+    // Root index
+    'index.md': 'Documentation Index',
+    // Architecture
+    'architecture/index.md': 'Architecture Overview',
+    'architecture/system-design.md': 'System Design',
+    'architecture/data-flow.md': 'Data Flow',
+    'architecture/components.md': 'Component Architecture',
+    // API Documentation
+    'api/index.md': 'API Documentation',
+    'api/endpoints.md': 'API Endpoints',
+    'api/schemas.md': 'Data Schemas',
+    'api/authentication.md': 'Authentication',
+    // Development Guides
+    'guides/index.md': 'Development Guides',
+    'guides/getting-started.md': 'Getting Started',
+    'guides/development-workflow.md': 'Development Workflow',
+    'guides/contributing.md': 'Contributing Guide',
+    // Technical Reference
+    'reference/index.md': 'Technical Reference',
+    'reference/configuration.md': 'Configuration',
+    'reference/environment.md': 'Environment Variables',
+    'reference/dependencies.md': 'Dependencies',
+    // Patterns & Conventions
+    'patterns/index.md': 'Patterns & Conventions',
+    'patterns/coding-standards.md': 'Coding Standards',
+    'patterns/naming-conventions.md': 'Naming Conventions',
+    'patterns/file-structure.md': 'File Structure',
+    // Testing
+    'testing/index.md': 'Testing Documentation',
+    'testing/strategy.md': 'Testing Strategy',
+    'testing/unit-tests.md': 'Unit Testing',
+    'testing/integration-tests.md': 'Integration Testing',
+    'testing/e2e-tests.md': 'E2E Testing',
+    // Deployment
+    'deployment/index.md': 'Deployment Documentation',
+    'deployment/environments.md': 'Environments',
+    'deployment/ci-cd.md': 'CI/CD Pipeline',
+    'deployment/infrastructure.md': 'Infrastructure',
+    // Decisions (ADRs)
+    'decisions/index.md': 'Architecture Decision Records',
+    'decisions/template.md': 'ADR Template',
+};
+// =============================================================================
+// Claude Inference for Doc Generation
+// =============================================================================
+async function runClaudeForDocs(prompt, projectPath, timeout = 90000) {
+    return new Promise((resolve) => {
+        const proc = spawn('claude', ['--print', '--dangerously-skip-permissions', prompt], {
+            cwd: projectPath,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            timeout,
+        });
+        let stdout = '';
+        const timer = setTimeout(() => {
+            proc.kill();
+            resolve(null);
+        }, timeout);
+        proc.stdout?.on('data', (data) => {
+            stdout += data.toString();
+        });
+        proc.on('close', (code) => {
+            clearTimeout(timer);
+            resolve(code === 0 ? stdout.trim() : null);
+        });
+        proc.on('error', () => {
+            clearTimeout(timer);
+            resolve(null);
+        });
+    });
+}
+// =============================================================================
+// Document Generators
+// =============================================================================
+function generateDocsIndex(projectName, stack, answers) {
+    return `# ${projectName} Documentation
+
+> Auto-generated documentation for AI agent assistance.
+> Regenerate with \`claudetools onboard --refresh\`
+
+## Project Overview
+
+${answers.projectDescription || `${projectName} - A ${stack.primaryLanguage} project.`}
+
+**Purpose:** ${answers.primaryPurpose || 'Software application'}
+**Target Audience:** ${answers.targetAudience || 'Developers'}
+
+## Quick Navigation
+
+### Architecture
+- [System Design](architecture/system-design.md) - Overall system architecture
+- [Data Flow](architecture/data-flow.md) - How data moves through the system
+- [Components](architecture/components.md) - Component breakdown
+
+### API
+- [Endpoints](api/endpoints.md) - API endpoint reference
+- [Schemas](api/schemas.md) - Data schemas and types
+- [Authentication](api/authentication.md) - Auth implementation
+
+### Guides
+- [Getting Started](guides/getting-started.md) - Setup and first steps
+- [Development Workflow](guides/development-workflow.md) - Day-to-day development
+- [Contributing](guides/contributing.md) - How to contribute
+
+### Reference
+- [Configuration](reference/configuration.md) - Configuration options
+- [Environment](reference/environment.md) - Environment variables
+- [Dependencies](reference/dependencies.md) - Project dependencies
+
+### Patterns
+- [Coding Standards](patterns/coding-standards.md) - Code style and standards
+- [Naming Conventions](patterns/naming-conventions.md) - Naming rules
+- [File Structure](patterns/file-structure.md) - Project organization
+
+### Testing
+- [Strategy](testing/strategy.md) - Testing approach
+- [Unit Tests](testing/unit-tests.md) - Unit testing guide
+- [E2E Tests](testing/e2e-tests.md) - End-to-end testing
+
+### Deployment
+- [Environments](deployment/environments.md) - Deployment environments
+- [CI/CD](deployment/ci-cd.md) - Continuous integration/deployment
+- [Infrastructure](deployment/infrastructure.md) - Infrastructure setup
+
+### Decisions
+- [ADR Index](decisions/index.md) - Architecture Decision Records
+
+---
+
+## Technology Stack
+
+**Language:** ${stack.primaryLanguage}
+**Package Manager:** ${stack.packageManager}
+
+${stack.frameworks.length > 0 ? `### Frameworks\n${stack.frameworks.map(f => `- **${f.name}** ${f.version} (${f.category})`).join('\n')}` : ''}
+
+${stack.libraries.length > 0 ? `### Libraries\n${stack.libraries.map(l => `- **${l.name}** ${l.version} (${l.category})`).join('\n')}` : ''}
+
+${stack.devTools.length > 0 ? `### Dev Tools\n${stack.devTools.map(t => `- **${t.name}** (${t.category})`).join('\n')}` : ''}
+
+---
+
+*Last updated: ${new Date().toISOString()}*
+`;
+}
+function generateArchitectureIndex(answers) {
+    return `# Architecture Overview
+
+${answers.architectureStyle ? `**Architecture Style:** ${answers.architectureStyle}` : ''}
+
+## Documents
+
+- [System Design](system-design.md) - High-level system architecture
+- [Data Flow](data-flow.md) - Data flow diagrams and descriptions
+- [Components](components.md) - Component architecture and responsibilities
+
+## Key Decisions
+
+Architecture decisions are documented in [/decisions](../decisions/index.md).
+`;
+}
+function generateSystemDesign(answers, stack) {
+    return `# System Design
+
+## Overview
+
+${answers.projectDescription || 'This document describes the system architecture.'}
+
+## Architecture Style
+
+${answers.architectureStyle || 'Not specified'}
+
+## High-Level Architecture
+
+\`\`\`
+┌─────────────────────────────────────────────────────────────┐
+│                        Application                           │
+├─────────────────────────────────────────────────────────────┤
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
+│  │   UI Layer  │  │   API Layer │  │  Services   │         │
+│  │             │  │             │  │             │         │
+│  │ ${stack.frameworks.find(f => f.category === 'frontend')?.name || 'Frontend'}     │  │ ${stack.frameworks.find(f => f.category === 'backend')?.name || 'Backend'}      │  │  Business   │         │
+│  │             │  │             │  │   Logic     │         │
+│  └─────────────┘  └─────────────┘  └─────────────┘         │
+├─────────────────────────────────────────────────────────────┤
+│                      Data Layer                              │
+│  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐         │
+│  │  Database   │  │    Cache    │  │   Storage   │         │
+│  └─────────────┘  └─────────────┘  └─────────────┘         │
+└─────────────────────────────────────────────────────────────┘
+\`\`\`
+
+## State Management
+
+${answers.stateManagement || 'See codebase for state management implementation.'}
+
+## Data Fetching
+
+${answers.dataFetching || 'See codebase for data fetching patterns.'}
+
+## Key Components
+
+<!-- AI Agent: Analyze the codebase to identify and document key components -->
+
+## Dependencies
+
+See [dependencies.md](../reference/dependencies.md) for full dependency list.
+`;
+}
+function generateDataFlow(answers) {
+    return `# Data Flow
+
+## Overview
+
+This document describes how data flows through the application.
+
+## Request Flow
+
+\`\`\`
+User Action
+    │
+    ▼
+┌─────────┐
+│   UI    │ ──────────────────────────────────────┐
+└────┬────┘                                       │
+     │                                            │
+     ▼                                            ▼
+┌─────────┐     ┌─────────┐     ┌─────────┐  ┌─────────┐
+│ State   │ ◄── │  API    │ ◄── │ Service │──│Database │
+│ Manager │     │ Client  │     │  Layer  │  │         │
+└─────────┘     └─────────┘     └─────────┘  └─────────┘
+\`\`\`
+
+## Data Fetching Pattern
+
+${answers.dataFetching || 'Standard fetch/API pattern'}
+
+## State Updates
+
+${answers.stateManagement || 'See state management documentation'}
+
+<!-- AI Agent: Document specific data flows for key features -->
+`;
+}
+function generateComponentArchitecture(stack) {
+    const isReact = stack.frameworks.some(f => ['react', 'next'].includes(f.name.toLowerCase()));
+    return `# Component Architecture
+
+## Overview
+
+${isReact ? 'This project uses React components with a functional component approach.' : 'Component-based architecture.'}
+
+## Component Hierarchy
+
+\`\`\`
+App
+├── Layout
+│   ├── Header
+│   ├── Navigation
+│   └── Footer
+├── Pages
+│   ├── Home
+│   ├── Dashboard
+│   └── Settings
+└── Shared
+    ├── UI Components
+    ├── Forms
+    └── Utilities
+\`\`\`
+
+## Component Guidelines
+
+1. **Single Responsibility** - Each component does one thing well
+2. **Composition** - Build complex UIs from simple components
+3. **Props Interface** - Clear, typed props for each component
+4. **State Colocation** - Keep state as close to usage as possible
+
+## Component Categories
+
+### Layout Components
+Structural components that define page layout.
+
+### Feature Components
+Business logic and feature-specific components.
+
+### UI Components
+Reusable, presentational components.
+
+### Utility Components
+Error boundaries, providers, HOCs.
+
+<!-- AI Agent: Analyze src/components to document actual component structure -->
+`;
+}
+function generateApiIndex(stack) {
+    return `# API Documentation
+
+## Overview
+
+API documentation for ${stack.frameworks.find(f => f.category === 'backend')?.name || 'the backend'}.
+
+## Documents
+
+- [Endpoints](endpoints.md) - API endpoint reference
+- [Schemas](schemas.md) - Request/response schemas
+- [Authentication](authentication.md) - Auth implementation
+
+## Base URL
+
+\`\`\`
+Development: http://localhost:3000/api
+Production: https://api.example.com
+\`\`\`
+
+## Authentication
+
+See [authentication.md](authentication.md) for details.
+
+## Error Handling
+
+All errors follow this format:
+
+\`\`\`json
+{
+  "error": {
+    "code": "ERROR_CODE",
+    "message": "Human readable message",
+    "details": {}
+  }
+}
+\`\`\`
+`;
+}
+function generateEndpoints() {
+    return `# API Endpoints
+
+## Overview
+
+This document lists all API endpoints.
+
+<!-- AI Agent: Scan route files to document actual endpoints -->
+
+## Endpoints
+
+### Authentication
+
+| Method | Path | Description |
+|--------|------|-------------|
+| POST | /api/auth/login | User login |
+| POST | /api/auth/register | User registration |
+| POST | /api/auth/logout | User logout |
+| GET | /api/auth/me | Get current user |
+
+### Resources
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | /api/resources | List resources |
+| POST | /api/resources | Create resource |
+| GET | /api/resources/:id | Get resource |
+| PUT | /api/resources/:id | Update resource |
+| DELETE | /api/resources/:id | Delete resource |
+
+## Request Examples
+
+\`\`\`bash
+# Login
+curl -X POST http://localhost:3000/api/auth/login \\
+  -H "Content-Type: application/json" \\
+  -d '{"email": "user@example.com", "password": "secret"}'
+\`\`\`
+`;
+}
+function generateSchemas(stack) {
+    const hasZod = stack.libraries.some(l => l.name === 'zod');
+    const hasPrisma = stack.libraries.some(l => l.name.includes('prisma'));
+    return `# Data Schemas
+
+## Overview
+
+${hasZod ? 'This project uses Zod for runtime validation.' : ''}
+${hasPrisma ? 'Database schemas are defined with Prisma.' : ''}
+
+## Core Schemas
+
+<!-- AI Agent: Extract actual schemas from codebase -->
+
+### User
+
+\`\`\`typescript
+interface User {
+  id: string;
+  email: string;
+  name: string;
+  createdAt: Date;
+  updatedAt: Date;
+}
+\`\`\`
+
+### Common Types
+
+\`\`\`typescript
+type ID = string;
+type Timestamp = Date;
+type Email = string;
+\`\`\`
+
+## Validation
+
+${hasZod ? `
+Schemas are validated using Zod:
+
+\`\`\`typescript
+import { z } from 'zod';
+
+const UserSchema = z.object({
+  email: z.string().email(),
+  name: z.string().min(1),
+  password: z.string().min(8),
+});
+\`\`\`
+` : 'See codebase for validation implementation.'}
+`;
+}
+function generateGettingStarted(stack) {
+    const pm = stack.packageManager;
+    const installCmd = pm === 'yarn' ? 'yarn' : pm === 'pnpm' ? 'pnpm install' : 'npm install';
+    const devCmd = pm === 'yarn' ? 'yarn dev' : pm === 'pnpm' ? 'pnpm dev' : 'npm run dev';
+    return `# Getting Started
+
+## Prerequisites
+
+- Node.js >= 18.0.0
+- ${stack.packageManager} package manager
+
+## Installation
+
+\`\`\`bash
+# Clone the repository
+git clone <repository-url>
+cd <project-name>
+
+# Install dependencies
+${installCmd}
+
+# Set up environment
+cp .env.example .env
+# Edit .env with your configuration
+
+# Start development server
+${devCmd}
+\`\`\`
+
+## Environment Setup
+
+1. Copy \`.env.example\` to \`.env\`
+2. Configure required variables (see [environment.md](../reference/environment.md))
+3. Set up any external services
+
+## First Steps
+
+1. Run the development server
+2. Open http://localhost:3000
+3. Explore the codebase
+
+## Common Tasks
+
+| Task | Command |
+|------|---------|
+| Development | \`${devCmd}\` |
+| Build | \`${pm === 'yarn' ? 'yarn build' : pm + ' run build'}\` |
+| Test | \`${pm === 'yarn' ? 'yarn test' : pm + ' test'}\` |
+| Lint | \`${pm === 'yarn' ? 'yarn lint' : pm + ' run lint'}\` |
+
+## Next Steps
+
+- Read [Development Workflow](development-workflow.md)
+- Review [Coding Standards](../patterns/coding-standards.md)
+- Check [Architecture Overview](../architecture/index.md)
+`;
+}
+function generateDevelopmentWorkflow(stack) {
+    return `# Development Workflow
+
+## Branch Strategy
+
+\`\`\`
+main
+  │
+  ├── develop
+  │     │
+  │     ├── feature/xxx
+  │     ├── fix/xxx
+  │     └── chore/xxx
+  │
+  └── release/x.x.x
+\`\`\`
+
+## Development Cycle
+
+1. **Create Branch** - \`git checkout -b feature/my-feature\`
+2. **Develop** - Make changes, write tests
+3. **Test** - Run test suite
+4. **Commit** - Follow commit conventions
+5. **Push** - Push to remote
+6. **PR** - Create pull request
+7. **Review** - Code review process
+8. **Merge** - Merge to develop
+
+## Commit Convention
+
+\`\`\`
+type(scope): description
+
+[optional body]
+
+[optional footer]
+\`\`\`
+
+Types: \`feat\`, \`fix\`, \`docs\`, \`style\`, \`refactor\`, \`test\`, \`chore\`
+
+## Code Review Checklist
+
+- [ ] Code follows project conventions
+- [ ] Tests pass
+- [ ] No console.log or debug code
+- [ ] Documentation updated if needed
+- [ ] No hardcoded values
+- [ ] Error handling in place
+`;
+}
+function generateCodingStandards(answers, stack) {
+    const conventions = answers.codingConventions || [];
+    return `# Coding Standards
+
+## Overview
+
+This document defines the coding standards for this project.
+
+## Language
+
+**Primary Language:** ${stack.primaryLanguage}
+
+## General Principles
+
+1. **Readability** - Code should be self-documenting
+2. **Simplicity** - Prefer simple solutions
+3. **Consistency** - Follow established patterns
+4. **Testability** - Write testable code
+
+## Conventions
+
+${conventions.length > 0 ? conventions.map(c => `- ${c}`).join('\n') : '- Follow standard conventions for the language'}
+
+## TypeScript Guidelines
+
+${stack.primaryLanguage === 'typescript' ? `
+- Use strict mode
+- Avoid \`any\` - use \`unknown\` if type is truly unknown
+- Prefer interfaces for object shapes
+- Use type guards for narrowing
+- Export types alongside implementations
+` : 'See language-specific guidelines.'}
+
+## Component Guidelines
+
+${stack.frameworks.some(f => f.name.toLowerCase().includes('react')) ? `
+- Use functional components
+- Keep components small and focused
+- Extract reusable logic to custom hooks
+- Use composition over inheritance
+- Prop types should be explicit
+` : ''}
+
+## File Organization
+
+\`\`\`
+src/
+├── components/     # UI components
+├── hooks/          # Custom hooks
+├── lib/            # Utilities
+├── services/       # API services
+├── types/          # Type definitions
+└── utils/          # Helper functions
+\`\`\`
+`;
+}
+function generateTestingStrategy(answers, stack) {
+    const approaches = answers.testingApproach || [];
+    const hasVitest = stack.devTools.some(t => t.name === 'vitest');
+    const hasJest = stack.devTools.some(t => t.name === 'jest');
+    const hasPlaywright = stack.devTools.some(t => t.name === 'playwright');
+    return `# Testing Strategy
+
+## Overview
+
+${Array.isArray(approaches) && approaches.length > 0 ? `Testing approaches used:\n${approaches.map((a) => `- ${a}`).join('\n')}` : 'Testing approach to be defined.'}
+
+## Test Framework
+
+${hasVitest ? '**Vitest** - Fast unit test runner' : ''}
+${hasJest ? '**Jest** - Test framework' : ''}
+${hasPlaywright ? '**Playwright** - E2E testing' : ''}
+
+## Testing Pyramid
+
+\`\`\`
+        ╱╲
+       ╱  ╲
+      ╱ E2E╲        Few, critical paths
+     ╱──────╲
+    ╱        ╲
+   ╱Integration╲    Some, key integrations
+  ╱────────────╲
+ ╱              ╲
+╱   Unit Tests   ╲  Many, fast, isolated
+╲────────────────╱
+\`\`\`
+
+## Test Organization
+
+\`\`\`
+__tests__/
+├── unit/           # Unit tests
+├── integration/    # Integration tests
+└── e2e/            # End-to-end tests
+\`\`\`
+
+## Running Tests
+
+\`\`\`bash
+# Run all tests
+${stack.packageManager} test
+
+# Run with coverage
+${stack.packageManager} test --coverage
+
+# Run specific test
+${stack.packageManager} test -- path/to/test
+\`\`\`
+
+## Coverage Requirements
+
+- Statements: 80%
+- Branches: 75%
+- Functions: 80%
+- Lines: 80%
+`;
+}
+function generateDeploymentEnvironments() {
+    return `# Environments
+
+## Overview
+
+| Environment | Purpose | URL |
+|-------------|---------|-----|
+| Development | Local dev | localhost:3000 |
+| Staging | Pre-production | staging.example.com |
+| Production | Live | example.com |
+
+## Environment Variables
+
+See [environment.md](../reference/environment.md) for variable documentation.
+
+## Configuration by Environment
+
+### Development
+- Debug logging enabled
+- Hot reload active
+- Mock services available
+
+### Staging
+- Production-like setup
+- Test data available
+- Debug tools enabled
+
+### Production
+- Optimized builds
+- Error tracking
+- Performance monitoring
+`;
+}
+function generateAdrTemplate() {
+    return `# ADR Template
+
+Use this template for new Architecture Decision Records.
+
+---
+
+# ADR-XXX: Title
+
+## Status
+
+Proposed | Accepted | Deprecated | Superseded
+
+## Context
+
+What is the issue that we're seeing that is motivating this decision?
+
+## Decision
+
+What is the change that we're proposing and/or doing?
+
+## Consequences
+
+What becomes easier or more difficult to do because of this change?
+
+### Positive
+
+- Benefit 1
+- Benefit 2
+
+### Negative
+
+- Drawback 1
+- Drawback 2
+
+### Neutral
+
+- Side effect 1
+
+## References
+
+- Link to related docs
+- Link to discussions
+`;
+}
+function generateAdrIndex() {
+    return `# Architecture Decision Records
+
+## Overview
+
+Architecture Decision Records (ADRs) document significant architectural decisions.
+
+## Index
+
+| ADR | Title | Status | Date |
+|-----|-------|--------|------|
+| 001 | [Template](template.md) | Template | - |
+
+## Creating New ADRs
+
+1. Copy \`template.md\`
+2. Number sequentially (ADR-002, ADR-003, etc.)
+3. Fill in all sections
+4. Submit for review
+
+## ADR Lifecycle
+
+1. **Proposed** - Under discussion
+2. **Accepted** - Decision made
+3. **Deprecated** - No longer applies
+4. **Superseded** - Replaced by newer ADR
+`;
+}
+// =============================================================================
+// Main Builder
+// =============================================================================
+export async function buildDocs(projectPath, projectName, stack, answers, options = {}) {
+    const docsPath = join(projectPath, 'docs');
+    const generatedDocs = [];
+    const useClaude = options.useClaudeInference && isClaudeCliAvailable();
+    // Create directory structure
+    const directories = [
+        docsPath,
+        join(docsPath, 'architecture'),
+        join(docsPath, 'api'),
+        join(docsPath, 'guides'),
+        join(docsPath, 'reference'),
+        join(docsPath, 'patterns'),
+        join(docsPath, 'testing'),
+        join(docsPath, 'deployment'),
+        join(docsPath, 'decisions'),
+    ];
+    for (const dir of directories) {
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+    // Generate base documents with templates
+    const docs = {
+        'index.md': generateDocsIndex(projectName, stack, answers),
+        'architecture/index.md': generateArchitectureIndex(answers),
+        'guides/index.md': '# Development Guides\n\n- [Getting Started](getting-started.md)\n- [Development Workflow](development-workflow.md)\n- [Contributing](contributing.md)\n',
+        'guides/getting-started.md': generateGettingStarted(stack),
+        'guides/development-workflow.md': generateDevelopmentWorkflow(stack),
+        'reference/index.md': '# Technical Reference\n\n- [Configuration](configuration.md)\n- [Environment](environment.md)\n- [Dependencies](dependencies.md)\n',
+        'patterns/index.md': '# Patterns & Conventions\n\n- [Coding Standards](coding-standards.md)\n- [Naming Conventions](naming-conventions.md)\n- [File Structure](file-structure.md)\n',
+        'testing/index.md': '# Testing Documentation\n\n- [Strategy](strategy.md)\n- [Unit Tests](unit-tests.md)\n- [Integration Tests](integration-tests.md)\n- [E2E Tests](e2e-tests.md)\n',
+        'deployment/index.md': '# Deployment Documentation\n\n- [Environments](environments.md)\n- [CI/CD](ci-cd.md)\n- [Infrastructure](infrastructure.md)\n',
+        'deployment/environments.md': generateDeploymentEnvironments(),
+        'decisions/index.md': generateAdrIndex(),
+        'decisions/template.md': generateAdrTemplate(),
+    };
+    // Claude-generated documents - analyze codebase and generate actual content
+    if (useClaude) {
+        const claudePrompts = {
+            'architecture/system-design.md': `Analyze this codebase and write a System Design document. Include:
+- Overall architecture overview
+- High-level component diagram (ASCII art)
+- Key modules and their responsibilities
+- Technology choices and rationale
+- Data storage approach
+Format as markdown. Be specific to THIS codebase, not generic.`,
+            'architecture/data-flow.md': `Analyze this codebase and document the Data Flow. Include:
+- How data enters the system (user input, API calls, etc.)
+- State management approach and data stores
+- Data transformation pipeline
+- API request/response flow
+- Side effects and external service communication
+Use ASCII diagrams where helpful. Be specific to this codebase.`,
+            'architecture/components.md': `Analyze the component structure in this codebase and document:
+- Component hierarchy (ASCII tree)
+- Key components and their purposes
+- Component categories (layout, feature, UI, utility)
+- Props patterns and data flow between components
+- Shared components and their usage
+Be specific to the actual components found.`,
+            'api/index.md': `Analyze this codebase's API structure and create an API Overview document:
+- API architecture approach (REST, GraphQL, tRPC, etc.)
+- Base URL and versioning strategy
+- Authentication method
+- Request/response format
+- Error handling conventions
+Be specific to what's actually implemented.`,
+            'api/endpoints.md': `Scan this codebase for API routes/endpoints and document them:
+- List all endpoints with methods (GET, POST, etc.)
+- Group by resource/feature
+- Include request parameters and body schemas
+- Include response formats
+- Note any middleware or authentication requirements
+Format as markdown tables. Document actual endpoints found.`,
+            'api/schemas.md': `Analyze this codebase for data schemas and types. Document:
+- Core data models/entities
+- TypeScript interfaces or types
+- Zod schemas if present
+- Database models if applicable
+- Request/response DTOs
+Include actual code examples from the codebase.`,
+            'api/authentication.md': `Analyze the authentication implementation in this codebase:
+- Authentication method (JWT, sessions, OAuth, etc.)
+- Login/logout flow
+- Token storage and refresh
+- Protected routes/middleware
+- User session management
+Document what's actually implemented, or note if auth is not yet implemented.`,
+            'guides/contributing.md': `Create a Contributing Guide for this project based on its setup:
+- How to set up the development environment
+- Code style and conventions used
+- Branch naming and PR process
+- Testing requirements
+- Commit message format
+Base this on actual project configuration found.`,
+            'reference/configuration.md': `Document the configuration system for this project:
+- Configuration files and their purposes
+- Build configuration (webpack, vite, tsconfig, etc.)
+- Framework configuration (next.config, etc.)
+- Linting and formatting setup
+Include actual config file contents and explanations.`,
+            'reference/environment.md': `Document environment variables for this project:
+- List all env vars from .env.example or .env files
+- Explain purpose of each variable
+- Mark required vs optional
+- Note default values
+- Group by category (database, API keys, feature flags)
+Document actual variables found in the codebase.`,
+            'reference/dependencies.md': `Analyze package.json and document key dependencies:
+- Core dependencies and their purposes
+- Development dependencies explained
+- Peer dependencies if any
+- Version requirements and compatibility notes
+Group by category (framework, UI, testing, tooling).`,
+            'patterns/coding-standards.md': generateCodingStandards(answers, stack) + `
+
+<!-- Claude: Enhance this with specific patterns observed in the codebase -->`,
+            'patterns/naming-conventions.md': `Analyze this codebase and document the naming conventions used:
+- File naming patterns (kebab-case, PascalCase, etc.)
+- Component naming conventions
+- Function and variable naming
+- CSS/styling class names
+- Route/URL naming
+Provide specific examples from the actual codebase.`,
+            'patterns/file-structure.md': `Document the file structure of this project:
+- Directory layout with explanations
+- File organization patterns
+- Module boundaries
+- Import/export conventions
+- Where different types of code belong
+Use ASCII tree diagrams. Be specific to this codebase.`,
+            'testing/strategy.md': generateTestingStrategy(answers, stack) + `
+
+<!-- Claude: Enhance with specific testing patterns from this codebase -->`,
+            'testing/unit-tests.md': `Document unit testing in this project:
+- Test framework and configuration
+- Test file organization
+- Mocking patterns used
+- Common test utilities
+- Example test patterns
+Include actual examples from the codebase if tests exist.`,
+            'testing/integration-tests.md': `Document integration testing in this project:
+- Integration test setup
+- Database/API mocking
+- Test data management
+- CI integration
+Include examples from the codebase if present, or recommendations if not.`,
+            'testing/e2e-tests.md': `Document E2E testing in this project:
+- E2E framework (Playwright, Cypress, etc.)
+- Test configuration
+- Page object patterns
+- Test data and fixtures
+- Running E2E tests locally and in CI
+Document actual setup or provide recommendations.`,
+            'deployment/ci-cd.md': `Analyze CI/CD configuration in this project:
+- CI/CD platform (GitHub Actions, etc.)
+- Workflow stages and jobs
+- Build and test commands
+- Deployment triggers
+- Environment handling
+Document actual .github/workflows or equivalent.`,
+            'deployment/infrastructure.md': `Document infrastructure for this project:
+- Hosting platform (Vercel, AWS, etc.)
+- Database infrastructure
+- CDN and caching
+- Monitoring and logging
+- Scaling considerations
+Document actual setup or common patterns for the stack.`,
+        };
+        // Generate Claude-powered docs in parallel batches
+        const claudeDocPaths = Object.keys(claudePrompts);
+        const batchSize = 3; // Run 3 at a time to avoid overwhelming
+        const totalClaudeDocs = claudeDocPaths.length;
+        let completedDocs = 0;
+        const progress = options.onProgress || (() => { });
+        progress(`Generating ${totalClaudeDocs} AI-powered docs...`, 0, totalClaudeDocs);
+        for (let i = 0; i < claudeDocPaths.length; i += batchSize) {
+            const batch = claudeDocPaths.slice(i, i + batchSize);
+            // Show which docs are being generated
+            const docNames = batch.map(p => p.split('/').pop()?.replace('.md', '')).join(', ');
+            progress(`Analyzing: ${docNames}`, completedDocs, totalClaudeDocs);
+            const results = await Promise.all(batch.map(async (docPath) => {
+                const prompt = claudePrompts[docPath];
+                const content = await runClaudeForDocs(prompt, projectPath);
+                return { docPath, content };
+            }));
+            for (const { docPath, content } of results) {
+                completedDocs++;
+                const docName = docPath.split('/').pop()?.replace('.md', '') || docPath;
+                if (content) {
+                    docs[docPath] = content;
+                    progress(`Generated: ${docName}`, completedDocs, totalClaudeDocs);
+                }
+                else {
+                    // Fallback to template if Claude fails
+                    docs[docPath] = docs[docPath] || getFallbackTemplate(docPath);
+                    progress(`Fallback: ${docName}`, completedDocs, totalClaudeDocs);
+                }
+            }
+        }
+        progress(`Completed ${totalClaudeDocs} documents`, totalClaudeDocs, totalClaudeDocs);
+    }
+    else {
+        // No Claude - use template fallbacks
+        docs['architecture/system-design.md'] = generateSystemDesign(answers, stack);
+        docs['architecture/data-flow.md'] = generateDataFlow(answers);
+        docs['architecture/components.md'] = generateComponentArchitecture(stack);
+        docs['api/index.md'] = generateApiIndex(stack);
+        docs['api/endpoints.md'] = generateEndpoints();
+        docs['api/schemas.md'] = generateSchemas(stack);
+        docs['api/authentication.md'] = '# Authentication\n\nAuthentication documentation to be added.\n';
+        docs['guides/contributing.md'] = '# Contributing\n\nContributing guide to be added.\n';
+        docs['reference/configuration.md'] = '# Configuration\n\nConfiguration documentation to be added.\n';
+        docs['reference/environment.md'] = '# Environment Variables\n\nEnvironment variable documentation to be added.\n';
+        docs['reference/dependencies.md'] = '# Dependencies\n\nDependency documentation to be added.\n';
+        docs['patterns/coding-standards.md'] = generateCodingStandards(answers, stack);
+        docs['patterns/naming-conventions.md'] = '# Naming Conventions\n\nNaming convention documentation to be added.\n';
+        docs['patterns/file-structure.md'] = '# File Structure\n\nFile structure documentation to be added.\n';
+        docs['testing/strategy.md'] = generateTestingStrategy(answers, stack);
+        docs['testing/unit-tests.md'] = '# Unit Testing\n\nUnit testing documentation to be added.\n';
+        docs['testing/integration-tests.md'] = '# Integration Testing\n\nIntegration testing documentation to be added.\n';
+        docs['testing/e2e-tests.md'] = '# E2E Testing\n\nE2E testing documentation to be added.\n';
+        docs['deployment/ci-cd.md'] = '# CI/CD Pipeline\n\nCI/CD documentation to be added.\n';
+        docs['deployment/infrastructure.md'] = '# Infrastructure\n\nInfrastructure documentation to be added.\n';
+    }
+    // Write all documents
+    for (const [relativePath, content] of Object.entries(docs)) {
+        const fullPath = join(docsPath, relativePath);
+        writeFileSync(fullPath, content);
+        // Determine category from path
+        const category = relativePath.includes('/')
+            ? relativePath.split('/')[0]
+            : 'general';
+        generatedDocs.push({
+            path: `docs/${relativePath}`,
+            title: DOCS_STRUCTURE[relativePath] || relativePath,
+            content,
+            generated: true,
+            category,
+        });
+    }
+    // Add docs/ to .gitignore
+    addToGitignore(projectPath, 'docs/');
+    return generatedDocs;
+}
+function getFallbackTemplate(docPath) {
+    const title = docPath.split('/').pop()?.replace('.md', '').replace(/-/g, ' ') || 'Documentation';
+    const capitalizedTitle = title.charAt(0).toUpperCase() + title.slice(1);
+    return `# ${capitalizedTitle}\n\nDocumentation to be added.\n`;
+}
+function addToGitignore(projectPath, entry) {
+    const gitignorePath = join(projectPath, '.gitignore');
+    try {
+        if (existsSync(gitignorePath)) {
+            const content = readFileSync(gitignorePath, 'utf-8');
+            if (!content.includes(entry)) {
+                appendFileSync(gitignorePath, `\n# ClaudeTools generated docs\n${entry}\n`);
+            }
+        }
+        else {
+            writeFileSync(gitignorePath, `# ClaudeTools generated docs\n${entry}\n`);
+        }
+    }
+    catch {
+        // Non-fatal
+    }
+}
+//# sourceMappingURL=docs-builder.js.map