project completed

.github/workflows/generate_docs_action.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+"""
+GitHub Actions script to call DocWizard API and generate documentation.
+Checks OpenRouter rate limits and skips if approaching daily limit.
+"""
+
+import os
+import json
+import sys
+import time
+from pathlib import Path
+import requests
+
+# Environment variables
+OPENROUTER_API_KEY = os.getenv('OPENROUTER_API_KEY')
+DOCWIZARD_API_URL = os.getenv('DOCWIZARD_API_URL')
+GITHUB_REPOSITORY = os.getenv('GITHUB_REPOSITORY')
+GITHUB_SERVER_URL = os.getenv('GITHUB_SERVER_URL', 'https://github.com')
+
+# Validate required vars
+if not OPENROUTER_API_KEY:
+    print("❌ Error: OPENROUTER_API_KEY secret not set")
+    sys.exit(1)
+
+if not DOCWIZARD_API_URL:
+    print("❌ Error: DOCWIZARD_API_URL secret not set")
+    sys.exit(1)
+
+repo_url = f"{GITHUB_SERVER_URL}/{GITHUB_REPOSITORY}"
+print(f"🔍 Generating docs for: {repo_url}")
+
+# Step 1: Check rate limits before proceeding
+print("\n📊 Checking OpenRouter API rate limits...")
+headers = {
+    'Authorization': f'Bearer {OPENROUTER_API_KEY}',
+    'HTTP-Referer': 'https://github.com/actions',
+    'X-Title': 'DocWizard-GitHubAction'
+}
+
+# Make a minimal request to check headers
+try:
+    check_response = requests.post(
+        f"{DOCWIZARD_API_URL}/health",
+        headers=headers,
+        timeout=10
+    )
+except Exception as e:
+    print(f"⚠️ Could not reach DocWizard API: {e}")
+    print("Skipping documentation generation")
+    sys.exit(0)
+
+# Check rate limit headers from OpenRouter
+remaining = check_response.headers.get('x-ratelimit-remaining-requests')
+if remaining:
+    try:
+        remaining = int(remaining)
+        print(f"✓ Rate limit remaining: {remaining} requests")
+        
+        if remaining < 10:
+            print(f"⚠️ Rate limit warning: Only {remaining} requests remaining today!")
+            print("Skipping documentation generation to preserve rate limit")
+            sys.exit(1)  # Exit with error to trigger the notification step
+    except ValueError:
+        pass
+
+# Step 2: Call generate-docs endpoint
+print(f"\n🚀 Calling {DOCWIZARD_API_URL}/generate-docs...")
+try:
+    response = requests.post(
+        f"{DOCWIZARD_API_URL}/generate-docs",
+        json={"repo_url": repo_url},
+        headers=headers,
+        timeout=600,
+        stream=True
+    )
+except Exception as e:
+    print(f"❌ API request failed: {e}")
+    sys.exit(1)
+
+if response.status_code != 200:
+    print(f"❌ API returned status {response.status_code}")
+    error_data = response.text[:200]
+    print(f"Response: {error_data}")
+    sys.exit(1)
+
+# Step 3: Process streaming response and build documentation
+print("\n📝 Processing documentation stream...")
+docs_folder = Path("docs")
+docs_folder.mkdir(exist_ok=True)
+
+api_ref_path = docs_folder / "API_REFERENCE.md"
+file_count = 0
+
+with open(api_ref_path, 'w') as f:
+    f.write("# API Reference\n\n")
+    f.write(f"Auto-generated by DocWizard for: {repo_url}\n")
+    f.write(f"Generated at: {time.strftime('%Y-%m-%d %H:%M:%S UTC', time.gmtime())}\n\n")
+    f.write("---\n\n")
+    
+    try:
+        for line in response.iter_lines():
+            if not line:
+                continue
+            
+            try:
+                data = json.loads(line)
+                
+                if data.get('status') == 'file_processed':
+                    file_info = data.get('file', {})
+                    filename = file_info.get('filename')
+                    doc = file_info.get('documentation')
+                    
+                    if doc:
+                        f.write(f"## 📄 {filename}\n\n")
+                        f.write(doc)
+                        f.write("\n\n---\n\n")
+                        file_count += 1
+                        print(f"  ✓ Processed {filename}")
+                
+                elif data.get('status') == 'rate_limit':
+                    print(f"  ⚠️ {data.get('message')}")
+                
+                elif data.get('status') == 'error':
+                    print(f"  ❌ Error: {data.get('message')}")
+                    sys.exit(1)
+            
+            except json.JSONDecodeError:
+                continue
+    
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Stream error: {e}")
+        sys.exit(1)
+
+print(f"\n✅ Documentation generated successfully!")
+print(f"📁 Saved to: {api_ref_path}")
+print(f"📊 Total files processed: {file_count}")

.github/workflows/update-docs.yml

@@ -0,0 +1,53 @@
+name: Update Documentation
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  update-docs:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.11'
+
+      - name: Install dependencies
+        run: |
+          pip install -r requirements.txt
+          pip install requests
+
+      - name: Generate and update API reference
+        env:
+          OPENROUTER_API_KEY: ${{ secrets.OPENROUTER_API_KEY }}
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          DOCWIZARD_API_URL: ${{ secrets.DOCWIZARD_API_URL }}
+        run: |
+          python .github/workflows/generate_docs_action.py
+
+      - name: Commit and push changes
+        if: success()
+        run: |
+          git config --local user.email "action@github.com"
+          git config --local user.name "GitHub Actions Bot"
+          git add docs/API_REFERENCE.md
+          git commit -m "docs: update API reference [skip ci]" || echo "No changes to commit"
+          git push
+
+      - name: Report rate limit issue
+        if: failure()
+        uses: actions/github-script@v6
+        with:
+          script: |
+            github.rest.issues.createComment({
+              issue_number: context.issue.number,
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              body: '⚠️ **DocWizard Rate Limit**: OpenRouter API rate limit is near threshold. Documentation generation skipped. Please try again tomorrow.'
+            })

.gitignore

@@ -0,0 +1,58 @@
+# Environment
+.env
+.env.local
+.env.production
+
+# Python
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.egg-info/
+dist/
+build/
+*.egg
+
+# Virtual environment
+venv/
+env/
+.venv/
+
+# FAISS indexes (local data, don't commit)
+faiss_indexes/
+
+# Node / Frontend
+node_modules/
+frontend/dist/
+frontend/build/
+.npm
+
+# Vite
+*.local
+
+# VS Code
+.vscode/
+*.code-workspace
+
+# OS files
+.DS_Store
+Thumbs.db
+desktop.ini
+
+# Logs
+*.log
+logs/
+npm-debug.log*
+
+# Testing
+.pytest_cache/
+htmlcov/
+.coverage
+
+# Jupyter (if you ever experiment)
+.ipynb_checkpoints/
+
+# Sentence transformers cache (large model files)
+.cache/
+models/

backend/doc_generator.py

@@ -0,0 +1,456 @@
+import os
+import time
+import requests
+from typing import Dict, List, Any
+from openai import OpenAI
+from dotenv import load_dotenv
+
+# Load .env file
+load_dotenv()
+
+# LLM model with environment variable override
+MODEL = os.getenv("LLM_MODEL", "qwen/qwen3-coder:free")
+
+
+def generate_docs_for_repo(parsed_files: List[Dict[str, Any]]) -> Dict[str, str]:
+    """
+    Generates Markdown documentation for an entire repository in a SINGLE API call.
+    
+    Args:
+        parsed_files: List of dicts, each with keys:
+            - 'filename': str (the file path)
+            - 'parsed_data': dict with 'functions', 'classes', 'imports' from parser.py
+    
+    Returns:
+        Dict mapping filename -> markdown documentation string
+    """
+    if not parsed_files:
+        return {}
+    
+    # Get API key from environment
+    api_key = os.getenv('OPENROUTER_API_KEY')
+    if not api_key:
+        raise ValueError("OPENROUTER_API_KEY environment variable not set")
+    
+    # Initialize OpenAI client with OpenRouter base URL
+    client = OpenAI(
+        api_key=api_key,
+        base_url='https://openrouter.ai/api/v1'
+    )
+    
+    # Build ONE comprehensive prompt for all files
+    files_summary = []
+    for file_item in parsed_files:
+        filename = file_item['filename']
+        parsed_data = file_item['parsed_data']
+        
+        functions_text = "\n".join([
+            f"  - {func['name']}(): {func['docstring'] or 'No docstring'}"
+            for func in parsed_data.get('functions', [])
+        ])
+        
+        classes_text = "\n".join([
+            f"  - {cls['name']}: {cls['docstring'] or 'No docstring'}"
+            for cls in parsed_data.get('classes', [])
+        ])
+        
+        imports_text = "\n".join([
+            f"  - {imp}"
+            for imp in parsed_data.get('imports', [])
+        ])
+        
+        file_summary = f"""### File: {filename}
+Functions:
+{functions_text or "  None"}
+
+Classes:
+{classes_text or "  None"}
+
+Imports:
+{imports_text or "  None"}
+"""
+        files_summary.append(file_summary)
+    
+    # Single comprehensive prompt with detailed formatting instructions
+    combined_prompt = f"""You are a professional code documentation expert. I have a Python repository with {len(parsed_files)} file(s) to document.
+
+For EACH file below, write RICH, DETAILED Markdown documentation following this EXACT structure:
+
+## filename.py
+### Overview
+[ONE LINE SUMMARY: What this file does in plain English]
+
+### Key Components
+[CREATE A TABLE with columns: Name | Type | Purpose | Parameters]
+[Include ALL important functions and classes]
+[Format: | function_name() | Function | Brief purpose | parameter_types |]
+[Format: | ClassName | Class | Brief purpose | __init__ params |]
+
+### Usage Example
+[REALISTIC code example with actual variable names and imports]
+[Show how to actually use the main components]
+[Include multiple lines if needed]
+
+### Notes
+[Important gotchas, warnings, or tips about this file]
+[Performance considerations if relevant]
+[Dependencies or requirements if relevant]
+
+---
+
+IMPORTANT FORMATTING RULES:
+1. Use ## for file headers ONLY
+2. Use ### for section headers (Overview, Key Components, Usage Example, Notes)
+3. For Key Components table, use markdown table format with pipes
+4. Code examples must be in ```python code blocks
+5. Always end with --- (three dashes) between files
+6. Be verbose and helpful - this is for developers who need to understand code quickly
+7. Include actual sample data/variable names in usage examples
+8. Explain WHY and HOW, not just WHAT
+
+=== REPOSITORY FILES ===
+
+{''.join(files_summary)}
+
+=== DOCUMENTATION ===
+
+Now write comprehensive documentation for each file following the structure above exactly."""
+
+    # Make ONE API call for the entire repository
+    markdown_output = ""
+    retry_count = 0
+    max_retries = 1
+    
+    while retry_count <= max_retries:
+        try:
+            stream = client.chat.completions.create(
+                model=MODEL,
+                messages=[
+                    {
+                        'role': 'user',
+                        'content': combined_prompt
+                    }
+                ],
+                stream=True,
+                max_tokens=8000,
+                timeout=30,
+                extra_headers={
+                    'HTTP-Referer': 'http://localhost:3000',
+                    'X-Title': 'DocWizard'
+                }
+            )
+            
+            # Collect all streamed chunks
+            for chunk in stream:
+                if chunk.choices[0].delta.content:
+                    markdown_output += chunk.choices[0].delta.content
+            
+            break  # Success, exit retry loop
+        
+        except requests.exceptions.ConnectionError as e:
+            print(f"❌ Cannot reach OpenRouter - check internet connection: {e}")
+            raise
+        
+        except requests.exceptions.Timeout as e:
+            print(f"❌ Request timed out (30s): {e}")
+            raise
+        
+        except requests.exceptions.HTTPError as e:
+            # Check for 429 (rate limit)
+            if e.response and e.response.status_code == 429:
+                if retry_count < max_retries:
+                    print(f"⚠️ Rate limit hit (HTTP 429) - waiting 60 seconds before retry...")
+                    time.sleep(60)
+                    retry_count += 1
+                    continue
+                else:
+                    print(f"❌ Rate limit hit (HTTP 429) - max retries exhausted")
+                    raise
+            else:
+                print(f"❌ HTTP Error {e.response.status_code if e.response else 'unknown'}: {e}")
+                raise
+        
+        except Exception as e:
+            # Print full exception details so we can debug
+            print(f"❌ Unexpected error: {type(e).__name__}: {e}")
+            import traceback
+            print("Full traceback:")
+            traceback.print_exc()
+            raise
+    
+    # Parse the response and split by filename
+    result = {}
+    current_filename = None
+    current_doc = ""
+    
+    for line in markdown_output.split('\n'):
+        # Check if this is a file header (## filename or ### filename)
+        if line.startswith('##') and not line.startswith('###'):
+            # Save previous file if exists
+            if current_filename and current_doc.strip():
+                result[current_filename] = current_doc.strip()
+            
+            # Extract filename from header
+            header_text = line.replace('##', '').strip()
+            # Try to match to an actual filename
+            for file_item in parsed_files:
+                if file_item['filename'] in header_text or header_text in file_item['filename']:
+                    current_filename = file_item['filename']
+                    current_doc = ""
+                    break
+            else:
+                # Fallback: use the header text as-is
+                current_filename = header_text
+                current_doc = ""
+        elif current_filename:
+            current_doc += line + "\n"
+    
+    # Save the last file
+    if current_filename and current_doc.strip():
+        result[current_filename] = current_doc.strip()
+    
+    # Ensure all files have documentation (fallback to combined output if parsing failed)
+    if not result:
+        # If we couldn't parse individual files, return the combined output for all files
+        for file_item in parsed_files:
+            result[file_item['filename']] = markdown_output
+    else:
+        # For files without specific documentation, add a note
+        for file_item in parsed_files:
+            if file_item['filename'] not in result:
+                result[file_item['filename']] = f"Documentation for {file_item['filename']} is included in the comprehensive repository documentation above."
+    
+    return result
+
+
+def generate_readme_for_repo(repo_url: str, docs_list: List[Dict[str, str]]) -> str:
+    """
+    Generates a comprehensive README.md for a repository using AI.
+    
+    Args:
+        repo_url: The repository URL
+        docs_list: List of dicts with 'filename' and 'documentation' keys
+    
+    Returns:
+        README markdown content as a string
+    """
+    api_key = os.getenv('OPENROUTER_API_KEY')
+    if not api_key:
+        raise ValueError("OPENROUTER_API_KEY environment variable not set")
+    
+    client = OpenAI(
+        api_key=api_key,
+        base_url='https://openrouter.ai/api/v1'
+    )
+    
+    # Extract project name from repo URL
+    project_name = repo_url.strip('/').split('/')[-1]
+    
+    # Prepare documentation summary
+    docs_summary = "\n".join([
+        f"- {doc.get('filename', 'unknown')}: {doc.get('documentation', '')[:200]}..."
+        for doc in docs_list[:10]  # Limit to first 10 files to stay within token limits
+    ])
+    
+    prompt = f"""You are a technical writer. Create a professional README.md for this Python project based on the documentation:
+
+Project Repository: {repo_url}
+Project Name: {project_name}
+
+Generated File Documentations:
+{docs_summary}
+
+Create a comprehensive README.md that includes:
+1. **Project Title and Description** - 2-3 sentences about what the project does
+2. **Features** - A bulleted list of 5-7 key features
+3. **Installation** - Python-specific installation steps (venv, pip-install pattern)
+4. **Usage** - Example code snippets of how to use the project
+5. **Project Structure** - Brief descriptions of the main files/directories
+6. **Contributing** - Generic contributing guidelines
+7. **License** - Standard license section (MIT suggested)
+
+Format the output as proper Markdown. Make it professional and ready for GitHub."""
+
+    try:
+        stream = client.chat.completions.create(
+            model=MODEL,
+            messages=[
+                {
+                    'role': 'user',
+                    'content': prompt
+                }
+            ],
+            stream=True,
+            max_tokens=2000,
+            timeout=30,
+            extra_headers={
+                'HTTP-Referer': 'http://localhost:3000',
+                'X-Title': 'DocWizard'
+            }
+        )
+        
+        readme_content = ""
+        for chunk in stream:
+            if chunk.choices[0].delta.content:
+                readme_content += chunk.choices[0].delta.content
+        
+        return readme_content.strip()
+    
+    except requests.exceptions.ConnectionError as e:
+        raise ConnectionError(f"Cannot reach OpenRouter: {e}")
+    except requests.exceptions.Timeout as e:
+        raise TimeoutError(f"Request timed out (30s): {e}")
+    except requests.exceptions.HTTPError as e:
+        if e.response and e.response.status_code == 429:
+            raise Exception("Rate limit hit (HTTP 429) - please wait 60 seconds")
+        raise
+
+
+def generate_gitignore_for_repo(repo_url: str, file_extensions: set, imports: set) -> str:
+    """
+    Generates a .gitignore file for a repository based on project type.
+    
+    Args:
+        repo_url: The repository URL
+        file_extensions: Set of file extensions found in the repo (e.g., {'.py', '.js', '.json'})
+        imports: Set of top-level imported modules
+    
+    Returns:
+        .gitignore content as a string
+    """
+    api_key = os.getenv('OPENROUTER_API_KEY')
+    if not api_key:
+        raise ValueError("OPENROUTER_API_KEY environment variable not set")
+    
+    client = OpenAI(
+        api_key=api_key,
+        base_url='https://openrouter.ai/api/v1'
+    )
+    
+    # Detect project type based on file extensions and imports
+    project_types = []
+    if '.py' in file_extensions:
+        project_types.append('Python')
+    if '.js' in file_extensions or '.jsx' in file_extensions:
+        project_types.append('Node.js/JavaScript')
+    if '.ts' in file_extensions or '.tsx' in file_extensions:
+        project_types.append('TypeScript')
+    if '.go' in file_extensions:
+        project_types.append('Go')
+    if 'django' in imports or 'flask' in imports:
+        project_types.append('Web Framework (Django/Flask)')
+    if 'numpy' in imports or 'pandas' in imports or 'sklearn' in imports:
+        project_types.append('Data Science')
+    
+    project_type_str = ', '.join(project_types) if project_types else 'Python'
+    
+    prompt = f"""Generate a professional .gitignore file for this {project_type_str} project at {repo_url}.
+
+Include these REQUIRED entries first:
+.env
+__pycache__/
+*.pyc
+venv/
+node_modules/
+faiss_indexes/
+.DS_Store
+
+Then add appropriate entries for this project type: {project_type_str}
+
+Include entries for:
+- Build artifacts and temporary files
+- IDE and editor files (.vscode/, .idea/, *.swp)
+- OS-specific files
+- Virtual environment and dependency files
+- Cache and database files
+- Any framework-specific directories
+
+Format as a standard .gitignore file with clear comments describing each section.
+Return ONLY the .gitignore content, no explanations."""
+
+    try:
+        stream = client.chat.completions.create(
+            model=MODEL,
+            messages=[
+                {
+                    'role': 'user',
+                    'content': prompt
+                }
+            ],
+            stream=True,
+            max_tokens=1500,
+            timeout=30,
+            extra_headers={
+                'HTTP-Referer': 'http://localhost:3000',
+                'X-Title': 'DocWizard'
+            }
+        )
+        
+        gitignore_content = ""
+        for chunk in stream:
+            if chunk.choices[0].delta.content:
+                gitignore_content += chunk.choices[0].delta.content
+        
+        return gitignore_content.strip()
+    
+    except requests.exceptions.ConnectionError as e:
+        raise ConnectionError(f"Cannot reach OpenRouter: {e}")
+    except requests.exceptions.Timeout as e:
+        raise TimeoutError(f"Request timed out (30s): {e}")
+    except requests.exceptions.HTTPError as e:
+        if e.response and e.response.status_code == 429:
+            raise Exception("Rate limit hit (HTTP 429) - please wait 60 seconds")
+        raise
+    # Test script to debug OpenRouter connection
+    print("🧪 Testing OpenRouter API connection...")
+    print(f"OPENROUTER_API_KEY set: {'Yes' if os.getenv('OPENROUTER_API_KEY') else 'No'}")
+    print(f"MODEL: {MODEL}")
+    print()
+    
+    api_key = os.getenv('OPENROUTER_API_KEY')
+    if not api_key:
+        print("❌ ERROR: OPENROUTER_API_KEY not found in environment!")
+        print("   Make sure .env file exists with OPENROUTER_API_KEY=your_key_here")
+        exit(1)
+    
+    try:
+        print("📤 Sending test request to OpenRouter...")
+        response = requests.post(
+            "https://openrouter.ai/api/v1/chat/completions",
+            headers={
+                "Authorization": f"Bearer {api_key}",
+                "Content-Type": "application/json",
+                "HTTP-Referer": "http://localhost:3000",
+                "X-Title": "DocWizard-Test"
+            },
+            json={
+                "model": MODEL,
+                "messages": [{"role": "user", "content": "say hello"}],
+                "max_tokens": 10
+            },
+            timeout=30
+        )
+        
+        print(f"\n✅ Status Code: {response.status_code}")
+        print(f"Response Headers: {dict(response.headers)}")
+        print(f"\nResponse Body:\n{response.text}\n")
+        
+        if response.status_code == 200:
+            print("✅ Connection successful!")
+        elif response.status_code == 401:
+            print("❌ Unauthorized (401) - Check your OPENROUTER_API_KEY")
+        elif response.status_code == 429:
+            print("❌ Rate limited (429) - Too many requests")
+        else:
+            print(f"⚠️ Unexpected status code: {response.status_code}")
+    
+    except requests.exceptions.ConnectionError as e:
+        print(f"❌ Connection Error: Cannot reach OpenRouter")
+        print(f"   {e}")
+    except requests.exceptions.Timeout as e:
+        print(f"❌ Timeout Error: Request took longer than 30 seconds")
+        print(f"   {e}")
+    except Exception as e:
+        print(f"❌ Error: {type(e).__name__}: {e}")
+        import traceback
+        traceback.print_exc()

backend/github_client.py

@@ -0,0 +1,123 @@
+import os
+import requests
+from typing import List, Dict
+
+
+def _parse_repo_url(repo_url: str) -> tuple:
+    """
+    Parse GitHub URL and return owner and repo.
+    
+    Args:
+        repo_url: GitHub URL in format "https://github.com/user/repo"
+    
+    Returns:
+        Tuple of (owner, repo)
+    """
+    parts = repo_url.rstrip('/').split('/')
+    owner = parts[-2]
+    repo = parts[-1]
+    return owner, repo
+
+
+def _get_github_headers() -> Dict[str, str]:
+    """
+    Get headers for GitHub API requests with authentication.
+    
+    Returns:
+        Dict with Authorization header
+    """
+    github_token = os.getenv('GITHUB_TOKEN')
+    if not github_token:
+        raise ValueError("GITHUB_TOKEN environment variable not set")
+    
+    return {
+        'Authorization': f'token {github_token}',
+        'Accept': 'application/vnd.github.v3.raw'
+    }
+
+
+def fetch_repo_files(repo_url: str) -> List[Dict[str, str]]:
+    """
+    Fetches all Python files from a GitHub repository.
+    
+    Args:
+        repo_url: GitHub URL in format "https://github.com/user/repo"
+    
+    Returns:
+        List of dicts with keys 'filename' and 'content'
+    """
+    owner, repo = _parse_repo_url(repo_url)
+    headers = _get_github_headers()
+    
+    # Fetch the repository tree recursively
+    tree_url = f'https://api.github.com/repos/{owner}/{repo}/git/trees/main?recursive=1'
+    tree_response = requests.get(tree_url, headers=headers)
+    tree_response.raise_for_status()
+    tree_data = tree_response.json()
+    
+    # Filter for Python files
+    py_files = [item for item in tree_data.get('tree', []) 
+                if item['type'] == 'blob' and item['path'].endswith('.py')]
+    
+    # Fetch content for each Python file
+    result = []
+    for file_item in py_files:
+        content_url = f'https://api.github.com/repos/{owner}/{repo}/contents/{file_item["path"]}'
+        content_response = requests.get(content_url, headers=headers)
+        content_response.raise_for_status()
+        
+        result.append({
+            'filename': file_item['path'],
+            'content': content_response.text
+        })
+    
+    return result
+
+
+def get_changed_files(repo_url: str, since_commit: str) -> List[Dict[str, str]]:
+    """
+    Fetches Python files changed since a given commit.
+    
+    Args:
+        repo_url: GitHub URL in format "https://github.com/user/repo"
+        since_commit: Commit SHA to compare from (e.g., "abc123def456")
+    
+    Returns:
+        List of dicts with keys 'filename' and 'content' for changed .py files
+    """
+    owner, repo = _parse_repo_url(repo_url)
+    headers = _get_github_headers()
+    
+    # Get comparison between since_commit and HEAD
+    compare_url = f'https://api.github.com/repos/{owner}/{repo}/compare/{since_commit}...HEAD'
+    compare_response = requests.get(compare_url, headers=headers)
+    compare_response.raise_for_status()
+    compare_data = compare_response.json()
+    
+    # Extract changed files (filter for .py files)
+    files = compare_data.get('files', [])
+    changed_py_files = [
+        f for f in files
+        if f['filename'].endswith('.py') and f['status'] != 'removed'
+    ]
+    
+    if not changed_py_files:
+        return []
+    
+    # Fetch content for each changed Python file
+    result = []
+    for file_item in changed_py_files:
+        content_url = f'https://api.github.com/repos/{owner}/{repo}/contents/{file_item["filename"]}'
+        try:
+            content_response = requests.get(content_url, headers=headers)
+            content_response.raise_for_status()
+            
+            result.append({
+                'filename': file_item['filename'],
+                'content': content_response.text
+            })
+        except requests.exceptions.RequestException:
+            # File might have been deleted, skip it
+            continue
+    
+    return result

backend/main.py

@@ -0,0 +1,427 @@
+import os
+import json
+import time
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+from typing import AsyncGenerator, Dict, Any
+
+from github_client import fetch_repo_files, get_changed_files
+from parser import parse_python_file
+from doc_generator import generate_docs_for_repo, generate_readme_for_repo, generate_gitignore_for_repo
+from vector_store import store_docs, search_docs, update_docs
+from dotenv import load_dotenv
+load_dotenv()
+
+app = FastAPI(title="DocWizard")
+
+# Add CORS middleware for React frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:5173", "http://localhost:3000"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+class GenerateDocsRequest(BaseModel):
+    repo_url: str
+
+
+class AskRequest(BaseModel):
+    repo_url: str
+    question: str
+
+
+class UpdateDocsRequest(BaseModel):
+    repo_url: str
+    since_commit: str
+
+
+class GenerateReadmeRequest(BaseModel):
+    repo_url: str
+
+
+class GenerateGitignoreRequest(BaseModel):
+    repo_url: str
+
+
+@app.post("/generate-docs")
+async def generate_docs(request: GenerateDocsRequest):
+    """
+    Generates documentation for all Python files in a GitHub repository.
+    Makes ONE API call for the entire repository (efficient for free tier).
+    Streams results as newline-delimited JSON.
+    
+    Args:
+        request: Contains repo_url like "https://github.com/user/repo"
+    
+    Yields:
+        JSON objects for each file with filename, parsed_data, and documentation
+    """
+    async def generate() -> AsyncGenerator[str, None]:
+        try:
+            # Fetch all Python files from GitHub
+            repo_files = fetch_repo_files(request.repo_url)
+            total_files = len(repo_files)
+            
+            if total_files == 0:
+                yield json.dumps({
+                    'status': 'error',
+                    'message': 'No Python files found in repository',
+                    'repo_url': request.repo_url
+                }) + '\n'
+                return
+            
+            # Parse all files locally (no API calls)
+            parsed_files_with_names = []
+            for file_info in repo_files:
+                filename = file_info['filename']
+                content = file_info['content']
+                parsed_data = parse_python_file(filename, content)
+                parsed_files_with_names.append({
+                    'filename': filename,
+                    'parsed_data': parsed_data
+                })
+            
+            # Generate documentation for ALL files in ONE API call
+            yield json.dumps({
+                'status': 'generating',
+                'message': 'Generating documentation for all files...',
+                'total_files': total_files
+            }) + '\n'
+            
+            try:
+                docs_by_file = generate_docs_for_repo(parsed_files_with_names)
+            except Exception as e:
+                if '429' in str(e) or 'rate limit' in str(e).lower():
+                    yield json.dumps({
+                        'status': 'rate_limit',
+                        'message': 'Rate limit hit — waiting 60 seconds...',
+                        'total_files': total_files
+                    }) + '\n'
+                    time.sleep(60)
+                    # Retry once
+                    docs_by_file = generate_docs_for_repo(parsed_files_with_names)
+                else:
+                    raise
+            
+            # Stream the results
+            results = []
+            for idx, file_item in enumerate(parsed_files_with_names):
+                filename = file_item['filename']
+                parsed_data = file_item['parsed_data']
+                documentation = docs_by_file.get(filename, 'No documentation generated')
+                
+                result = {
+                    'filename': filename,
+                    'parsed_data': parsed_data,
+                    'documentation': documentation
+                }
+                results.append(result)
+                
+                # Yield progress update with result
+                yield json.dumps({
+                    'status': 'file_processed',
+                    'current': idx + 1,
+                    'total': total_files,
+                    'file': result
+                }) + '\n'
+            
+            # Save all docs to FAISS index BEFORE returning response
+            docs_for_storage = [
+                {'filename': r['filename'], 'documentation': r['documentation']}
+                for r in results
+            ]
+            store_docs(request.repo_url, docs_for_storage)
+            
+            # Final success message
+            yield json.dumps({
+                'status': 'complete',
+                'total_files': total_files,
+                'repo_url': request.repo_url,
+                'message': f'Generated documentation for {total_files} files in 1 API call'
+            }) + '\n'
+        
+        except Exception as e:
+            yield json.dumps({
+                'status': 'error',
+                'message': str(e),
+                'repo_url': request.repo_url
+            }) + '\n'
+    
+    return StreamingResponse(generate(), media_type='application/x-ndjson')
+
+
+@app.post("/ask")
+async def ask_question(request: AskRequest) -> Dict[str, Any]:
+    """
+    Searches stored documentation for answers to a question.
+    
+    Args:
+        request: Contains repo_url and question
+    
+    Returns:
+        Dict with search results containing document chunks and filenames
+    """
+    try:
+        results = search_docs(request.repo_url, request.question)
+        
+        return {
+            'status': 'success',
+            'repo_url': request.repo_url,
+            'question': request.question,
+            'results': results,
+            'count': len(results)
+        }
+    
+    except Exception as e:
+        return {
+            'status': 'error',
+            'message': str(e),
+            'repo_url': request.repo_url
+        }
+
+
+@app.post("/update-docs")
+async def update_docs_endpoint(request: UpdateDocsRequest):
+    """
+    Updates documentation for files changed since a specific commit.
+    Streams results as newline-delimited JSON.
+    
+    Args:
+        request: Contains repo_url and since_commit SHA
+    
+    Yields:
+        JSON objects for each processed file with filename, parsed_data, and documentation
+    """
+    async def generate() -> AsyncGenerator[str, None]:
+        try:
+            # Step 1: Get changed files since commit
+            changed_files = get_changed_files(request.repo_url, request.since_commit)
+            
+            if not changed_files:
+                yield json.dumps({
+                    'status': 'no_changes',
+                    'message': 'No Python files changed since the specified commit',
+                    'repo_url': request.repo_url,
+                    'since_commit': request.since_commit
+                }) + '\n'
+                return
+            
+            total_files = len(changed_files)
+            
+            # Parse all changed files locally
+            parsed_files_with_names = []
+            for file_info in changed_files:
+                filename = file_info['filename']
+                content = file_info['content']
+                parsed_data = parse_python_file(filename, content)
+                parsed_files_with_names.append({
+                    'filename': filename,
+                    'parsed_data': parsed_data
+                })
+            
+            # Generate documentation for ALL changed files in ONE API call
+            yield json.dumps({
+                'status': 'generating',
+                'message': f'Generating documentation for {total_files} changed files...',
+                'total_files': total_files
+            }) + '\n'
+            
+            try:
+                docs_by_file = generate_docs_for_repo(parsed_files_with_names)
+            except Exception as e:
+                if '429' in str(e) or 'rate limit' in str(e).lower():
+                    yield json.dumps({
+                        'status': 'rate_limit',
+                        'message': 'Rate limit hit — waiting 60 seconds...',
+                        'total_files': total_files
+                    }) + '\n'
+                    time.sleep(60)
+                    # Retry once
+                    docs_by_file = generate_docs_for_repo(parsed_files_with_names)
+                else:
+                    raise
+            
+            # Stream the results
+            results = []
+            for idx, file_item in enumerate(parsed_files_with_names):
+                filename = file_item['filename']
+                parsed_data = file_item['parsed_data']
+                documentation = docs_by_file.get(filename, 'No documentation generated')
+                
+                result = {
+                    'filename': filename,
+                    'parsed_data': parsed_data,
+                    'documentation': documentation
+                }
+                results.append(result)
+                
+                # Yield progress update with result
+                yield json.dumps({
+                    'status': 'file_processed',
+                    'current': idx + 1,
+                    'total': total_files,
+                    'file': result
+                }) + '\n'
+            
+            # Update FAISS index with changed files
+            update_docs(request.repo_url, results)
+            
+            # Final success message
+            yield json.dumps({
+                'status': 'complete',
+                'total_files': total_files,
+                'repo_url': request.repo_url,
+                'since_commit': request.since_commit,
+                'message': f'Updated {total_files} changed files in FAISS index (1 API call)'
+            }) + '\n'
+        
+        except Exception as e:
+            yield json.dumps({
+                'status': 'error',
+                'message': str(e),
+                'repo_url': request.repo_url,
+                'since_commit': request.since_commit
+            }) + '\n'
+    
+    return StreamingResponse(generate(), media_type='application/x-ndjson')
+
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint."""
+    return {'status': 'ok'}
+
+
+@app.post("/generate-readme")
+async def generate_readme(request: GenerateReadmeRequest) -> Dict[str, Any]:
+    """
+    Generates a comprehensive README.md for a repository.
+    Uses already-generated documentation from FAISS index.
+    
+    Args:
+        request: Contains repo_url
+    
+    Returns:
+        Dict with status and readme markdown content
+    """
+    try:
+        # Search FAISS for all docs (use a broad query or get all with a dummy search)
+        # For now, we'll search for a generic term that should match most documentation
+        print(f"[GENERATE_README] Fetching docs for {request.repo_url} from FAISS...")
+        results = search_docs(request.repo_url, "overview project structure functions classes", num_results=100)
+        
+        # Convert search results to the format generate_readme_for_repo expects
+        # Extract unique documents
+        seen_docs = set()
+        docs_list = []
+        
+        print(f"[GENERATE_README] Retrieved {len(results)} result chunks, extracting unique docs...")
+        for result in results:
+            filename = result.get('filename', 'unknown')
+            if filename not in seen_docs:
+                docs_list.append({
+                    'filename': filename,
+                    'documentation': result.get('document', '')
+                })
+                seen_docs.add(filename)
+        
+        if not docs_list:
+            print(f"[GENERATE_README] No docs found for {request.repo_url} - generating README anyway")
+            # Fallback: create README with repo info
+            readme_content = f"""# {request.repo_url.split('/')[-1]}
+
+This project needs documentation. Please generate docs first using the /generate-docs endpoint.
+"""
+            return {
+                'status': 'success',
+                'readme': readme_content,
+                'repo_url': request.repo_url,
+                'message': 'Generated README (note: docs not found - please generate docs first)'
+            }
+        
+        print(f"[GENERATE_README] Calling generate_readme_for_repo with {len(docs_list)} docs...")
+        readme_content = generate_readme_for_repo(request.repo_url, docs_list)
+        
+        print(f"[GENERATE_README] README generated successfully ({len(readme_content)} chars)")
+        return {
+            'status': 'success',
+            'readme': readme_content,
+            'repo_url': request.repo_url,
+            'message': 'README generated successfully'
+        }
+    
+    except Exception as e:
+        print(f"[GENERATE_README] Error: {e}")
+        return {
+            'status': 'error',
+            'message': str(e),
+            'repo_url': request.repo_url
+        }
+
+
+@app.post("/generate-gitignore")
+async def generate_gitignore(request: GenerateGitignoreRequest) -> Dict[str, Any]:
+    """
+    Generates a .gitignore file for a repository.
+    Analyzes file extensions and imports to detect project type.
+    
+    Args:
+        request: Contains repo_url
+    
+    Returns:
+        Dict with status and gitignore content
+    """
+    try:
+        print(f"[GENERATE_GITIGNORE] Fetching repo files for {request.repo_url}...")
+        
+        # Fetch repository files
+        repo_files = fetch_repo_files(request.repo_url)
+        
+        # Analyze file extensions and imports
+        file_extensions = set()
+        all_imports = set()
+        
+        for file_info in repo_files:
+            filename = file_info['filename']
+            content = file_info['content']
+            
+            # Extract file extension
+            if '.' in filename:
+                ext = filename[filename.rfind('.'):]
+                file_extensions.add(ext)
+            
+            # Parse file to extract imports
+            if filename.endswith('.py'):
+                parsed_data = parse_python_file(filename, content)
+                for imp in parsed_data.get('imports', []):
+                    # Extract just the module name
+                    module_name = imp.split()[1].split('.')[0] if len(imp.split()) > 1 else imp.split('.')[0]
+                    all_imports.add(module_name.lower())
+        
+        print(f"[GENERATE_GITIGNORE] Found extensions: {file_extensions}")
+        print(f"[GENERATE_GITIGNORE] Found imports: {all_imports}")
+        
+        # Generate gitignore
+        print(f"[GENERATE_GITIGNORE] Calling generate_gitignore_for_repo...")
+        gitignore_content = generate_gitignore_for_repo(request.repo_url, file_extensions, all_imports)
+        
+        print(f"[GENERATE_GITIGNORE] .gitignore generated successfully ({len(gitignore_content)} chars)")
+        return {
+            'status': 'success',
+            'gitignore': gitignore_content,
+            'repo_url': request.repo_url,
+            'message': '.gitignore generated successfully'
+        }
+    
+    except Exception as e:
+        print(f"[GENERATE_GITIGNORE] Error: {e}")
+        return {
+            'status': 'error',
+            'message': str(e),
+            'repo_url': request.repo_url
+        }

backend/parser.py

@@ -0,0 +1,55 @@
+import ast
+from typing import Dict, List, Any
+
+
+def parse_python_file(filename: str, content: str) -> Dict[str, List[Any]]:
+    """
+    Parses a Python file and extracts functions, classes, and imports.
+    
+    Args:
+        filename: The name of the Python file
+        content: The content of the Python file as a string
+    
+    Returns:
+        Dict with keys 'functions', 'classes', and 'imports'.
+        Each function/class dict contains 'name' and 'docstring'.
+    """
+    try:
+        tree = ast.parse(content)
+    except SyntaxError as e:
+        print(f"Syntax error in {filename}: {e}")
+        return {'functions': [], 'classes': [], 'imports': []}
+    
+    functions = []
+    classes = []
+    imports = []
+    
+    for node in ast.walk(tree):
+        if isinstance(node, ast.FunctionDef):
+            docstring = ast.get_docstring(node)
+            functions.append({
+                'name': node.name,
+                'docstring': docstring
+            })
+        elif isinstance(node, ast.ClassDef):
+            docstring = ast.get_docstring(node)
+            classes.append({
+                'name': node.name,
+                'docstring': docstring
+            })
+        elif isinstance(node, ast.Import):
+            for alias in node.names:
+                imports.append(alias.name)
+        elif isinstance(node, ast.ImportFrom):
+            module = node.module or ''
+            for alias in node.names:
+                if module:
+                    imports.append(f"from {module} import {alias.name}")
+                else:
+                    imports.append(f"import {alias.name}")
+    
+    return {
+        'functions': functions,
+        'classes': classes,
+        'imports': imports
+    }

backend/vector_store.py

@@ -0,0 +1,225 @@
+import os
+import json
+import faiss
+import numpy as np
+from pathlib import Path
+from typing import List, Dict, Any
+from sentence_transformers import SentenceTransformer
+
+# Initialize embedding model
+model = SentenceTransformer('all-MiniLM-L6-v2')
+
+# Directory to store FAISS indexes
+INDEXES_DIR = Path('faiss_indexes')
+INDEXES_DIR.mkdir(exist_ok=True)
+
+
+def _sanitize_repo_url(repo_url: str) -> str:
+    """Sanitize repository URL to create a valid filename."""
+    return repo_url.replace('https://', '').replace('http://', '').replace('/', '_').replace('.', '_').replace(':', '_')[:63]
+
+
+def store_docs(repo_url: str, docs_list: List[Dict[str, Any]]) -> None:
+    """
+    Stores generated documentation in FAISS with sentence-transformers embeddings.
+    
+    Args:
+        repo_url: The repository URL (used for index filename)
+        docs_list: List of dicts containing 'filename' and 'documentation'
+    """
+    repo_slug = _sanitize_repo_url(repo_url)
+    print(f"[STORE_DOCS] Starting storage for repo: {repo_url}")
+    print(f"[STORE_DOCS] Repo slug: {repo_slug}")
+    
+    # Extract all documentation text
+    doc_texts = []
+    doc_metadata = []
+    
+    for doc_item in docs_list:
+        text = doc_item['documentation']
+        filename = doc_item['filename']
+        doc_texts.append(text)
+        doc_metadata.append({'filename': filename, 'repo_url': repo_url})
+    
+    print(f"[STORE_DOCS] Extracted {len(doc_texts)} documents")
+    
+    if not doc_texts:
+        print(f"[STORE_DOCS] No documents to store, returning early")
+        return
+    
+    # Generate embeddings for all documents
+    print(f"[STORE_DOCS] Generating embeddings for {len(doc_texts)} documents...")
+    embeddings = model.encode(doc_texts, convert_to_numpy=True)
+    print(f"[STORE_DOCS] Embeddings shape: {embeddings.shape}")
+    
+    # Create FAISS index
+    dimension = embeddings.shape[1]
+    index = faiss.IndexFlatL2(dimension)
+    index.add(embeddings.astype(np.float32))
+    print(f"[STORE_DOCS] FAISS index created with {index.ntotal} vectors")
+    
+    # Save FAISS index
+    index_path = INDEXES_DIR / f'{repo_slug}.index'
+    faiss.write_index(index, str(index_path))
+    print(f"[STORE_DOCS] FAISS index saved to: {index_path}")
+    
+    # Save text chunks and metadata
+    texts_path = INDEXES_DIR / f'{repo_slug}_texts.json'
+    with open(texts_path, 'w') as f:
+        json.dump({
+            'texts': doc_texts,
+            'metadata': doc_metadata,
+            'repo_url': repo_url
+        }, f)
+    print(f"[STORE_DOCS] Metadata saved to: {texts_path}")
+    print(f"[STORE_DOCS] Storage complete!")
+
+
+def update_docs(repo_url: str, updated_docs_list: List[Dict[str, Any]]) -> None:
+    """
+    Updates documentation for specific files in an existing FAISS index.
+    Loads existing index, updates entries for the specified files, and rebuilds.
+    
+    Args:
+        repo_url: The repository URL
+        updated_docs_list: List of dicts with 'filename' and 'documentation' to update
+    """
+    repo_slug = _sanitize_repo_url(repo_url)
+    print(f"[UPDATE_DOCS] Starting update for repo: {repo_url}")
+    print(f"[UPDATE_DOCS] Updating {len(updated_docs_list)} files")
+    
+    index_path = INDEXES_DIR / f'{repo_slug}.index'
+    texts_path = INDEXES_DIR / f'{repo_slug}_texts.json'
+    
+    # Load existing index and texts
+    if not index_path.exists() or not texts_path.exists():
+        print(f"[UPDATE_DOCS] No existing index found, creating new one")
+        # No existing index, create new one with these docs
+        store_docs(repo_url, updated_docs_list)
+        return
+    
+    try:
+        # Load existing data
+        with open(texts_path, 'r') as f:
+            data = json.load(f)
+        
+        existing_texts = data['texts']
+        existing_metadata = data['metadata']
+        print(f"[UPDATE_DOCS] Loaded {len(existing_texts)} existing documents")
+        
+        # Get filenames being updated
+        updated_filenames = {doc['filename'] for doc in updated_docs_list}
+        
+        # Remove entries for files being updated
+        filtered_texts = []
+        filtered_metadata = []
+        for text, meta in zip(existing_texts, existing_metadata):
+            if meta.get('filename') not in updated_filenames:
+                filtered_texts.append(text)
+                filtered_metadata.append(meta)
+        
+        print(f"[UPDATE_DOCS] After filtering: {len(filtered_texts)} documents remain")
+        
+        # Add new entries
+        for doc in updated_docs_list:
+            filtered_texts.append(doc['documentation'])
+            filtered_metadata.append({
+                'filename': doc['filename'],
+                'repo_url': repo_url
+            })
+        
+        print(f"[UPDATE_DOCS] After adding updates: {len(filtered_texts)} documents total")
+        
+        if not filtered_texts:
+            print(f"[UPDATE_DOCS] No documents remaining, returning early")
+            return
+        
+        # Rebuild FAISS index
+        print(f"[UPDATE_DOCS] Rebuilding FAISS index...")
+        embeddings = model.encode(filtered_texts, convert_to_numpy=True)
+        dimension = embeddings.shape[1]
+        index = faiss.IndexFlatL2(dimension)
+        index.add(embeddings.astype(np.float32))
+        print(f"[UPDATE_DOCS] FAISS index rebuilt with {index.ntotal} vectors")
+        
+        # Save updated index
+        faiss.write_index(index, str(index_path))
+        print(f"[UPDATE_DOCS] Updated FAISS index saved to: {index_path}")
+        
+        # Save updated texts
+        with open(texts_path, 'w') as f:
+            json.dump({
+                'texts': filtered_texts,
+                'metadata': filtered_metadata,
+                'repo_url': repo_url
+            }, f)
+        print(f"[UPDATE_DOCS] Updated metadata saved to: {texts_path}")
+        print(f"[UPDATE_DOCS] Update complete!")
+    
+    except Exception as e:
+        print(f"Error updating index for {repo_url}: {e}")
+        raise
+
+
+def search_docs(repo_url: str, question: str, num_results: int = 3) -> List[Dict[str, Any]]:
+    """
+    Searches stored documentation using semantic similarity.
+    
+    Args:
+        repo_url: The repository URL
+        question: Natural language question to search for
+        num_results: Number of top results to return (default: 3)
+    
+    Returns:
+        List of dicts containing 'document', 'filename', and 'distance'
+    """
+    repo_slug = _sanitize_repo_url(repo_url)
+    print(f"[SEARCH_DOCS] Searching for: '{question}' in repo: {repo_url}")
+    
+    # Check if index exists
+    index_path = INDEXES_DIR / f'{repo_slug}.index'
+    texts_path = INDEXES_DIR / f'{repo_slug}_texts.json'
+    
+    if not index_path.exists() or not texts_path.exists():
+        print(f"[SEARCH_DOCS] ERROR: No index found for repo. Please generate documentation first.")
+        print(f"[SEARCH_DOCS] Expected paths: {index_path} and {texts_path}")
+        return []
+    
+    try:
+        # Load FAISS index
+        print(f"[SEARCH_DOCS] Loading FAISS index from: {index_path}")
+        index = faiss.read_index(str(index_path))
+        print(f"[SEARCH_DOCS] FAISS index loaded with {index.ntotal} vectors")
+        
+        # Load text chunks
+        with open(texts_path, 'r') as f:
+            data = json.load(f)
+        
+        texts = data['texts']
+        metadata = data['metadata']
+        print(f"[SEARCH_DOCS] Loaded {len(texts)} text documents and metadata")
+    except Exception as e:
+        print(f"[SEARCH_DOCS] Error loading index for {repo_url}: {e}")
+        return []
+    
+    # Embed the question
+    print(f"[SEARCH_DOCS] Encoding question embedding...")
+    question_embedding = model.encode([question], convert_to_numpy=True)
+    
+    # Search the index
+    print(f"[SEARCH_DOCS] Searching for top {min(num_results, len(texts))} results...")
+    distances, indices = index.search(question_embedding.astype(np.float32), min(num_results, len(texts)))
+    
+    # Format results
+    formatted_results = []
+    for idx, distance in zip(indices[0], distances[0]):
+        if idx == -1:  # No valid result
+            continue
+        formatted_results.append({
+            'document': texts[idx],
+            'filename': metadata[idx].get('filename', 'unknown'),
+            'distance': float(distance)
+        })
+    
+    print(f"[SEARCH_DOCS] Found {len(formatted_results)} results")
+    return formatted_results

frontend/.eslintrc.cjs

@@ -0,0 +1,20 @@
+module.exports = {
+  root: true,
+  env: { browser: true, es2020: true },
+  extends: [
+    'eslint:recommended',
+    'plugin:react/recommended',
+    'plugin:react/jsx-runtime',
+    'plugin:react-hooks/recommended',
+  ],
+  ignorePatterns: ['dist', '.eslintrc.cjs'],
+  parserOptions: { ecmaVersion: 'latest', sourceType: 'module' },
+  settings: { react: { version: '18.2' } },
+  plugins: ['react-refresh'],
+  rules: {
+    'react-refresh/only-export-components': [
+      'warn',
+      { allowConstantExport: true },
+    ],
+  },
+}

frontend/.gitignore

@@ -0,0 +1,24 @@
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+pnpm-debug.log*
+lerna-debug.log*
+
+node_modules
+dist
+dist-ssr
+*.local
+
+# Editor directories and files
+.vscode/*
+!.vscode/extensions.json
+.idea
+.DS_Store
+*.suo
+*.ntvs*
+*.njsproj
+*.sln
+*.sw?

frontend/README.md

@@ -0,0 +1,240 @@
+# DocWizard 🧙‍♂️
+
+> AI-powered code documentation and search agent — paste a GitHub URL, get professional docs in seconds.
+
+---
+
+## What It Does
+
+DocWizard takes any public GitHub repository, reads every Python file, and automatically generates clean human-readable documentation using AI. It also lets developers search the codebase in plain English — no more digging through files manually.
+
+**Core features:**
+- Generates documentation for every file in a repo with one click
+- Answers natural language questions about the codebase
+- Semantic search powered by FAISS vector embeddings
+- Download individual file docs or all docs as a ZIP
+- Auto-generates README.md and .gitignore for any project
+
+---
+
+## Tech Stack
+
+| Layer | Technology |
+|-------|------------|
+| Backend | Python 3.10+, FastAPI, Uvicorn |
+| LLM | OpenRouter API (qwen/qwen3-coder:free) |
+| Embeddings | sentence-transformers (all-MiniLM-L6-v2) |
+| Vector Search | FAISS (faiss-cpu) |
+| Code Parsing | Python AST (built-in) |
+| GitHub Access | GitHub REST API v3 |
+| Frontend | React 18, Vite, Tailwind CSS |
+| File Handling | JSZip (client-side ZIP generation) |
+
+**Total cost to run: $0** — all free tier services, no credit card required.
+
+---
+
+## Project Structure
+
+```
+DocWizard/
+├── backend/
+│   ├── main.py              # FastAPI app, all API endpoints
+│   ├── doc_generator.py     # OpenRouter API calls, doc generation logic
+│   ├── parser.py            # AST-based Python code parser
+│   ├── vector_store.py      # FAISS index creation and semantic search
+│   ├── github_client.py     # GitHub API, repo file fetching
+│   └── requirements.txt     # Python dependencies
+├── frontend/
+│   └── src/
+│       ├── App.jsx          # Main React component, full UI
+│       └── components/      # UI sub-components
+├── faiss_indexes/           # Auto-generated, gitignored
+├── .env                     # Your API keys, gitignored
+├── .env.example             # Template for environment variables
+├── .gitignore
+└── README.md
+```
+
+---
+
+## Prerequisites
+
+Make sure these are installed on your machine before starting:
+
+- [Python 3.10+](https://www.python.org/downloads/)
+- [Node.js 18+](https://nodejs.org/)
+- [Git](https://git-scm.com/)
+
+---
+
+## Installation
+
+### 1. Clone the repository
+
+```bash
+git clone https://github.com/yourusername/docwizard.git
+cd docwizard
+```
+
+### 2. Get your API keys
+
+**OpenRouter API key** (free, no credit card):
+1. Go to [openrouter.ai](https://openrouter.ai)
+2. Sign up → Profile → Keys → Create Key
+3. Copy the key (starts with `sk-or-...`)
+
+**GitHub Personal Access Token** (free):
+1. Go to GitHub → Settings → Developer settings
+2. Personal access tokens → Tokens (classic) → Generate new token
+3. Check only the `repo` scope → Generate → Copy the token (starts with `ghp_...`)
+
+### 3. Set up environment variables
+
+```bash
+cp .env.example .env
+```
+
+Open `.env` and fill in your keys:
+
+```env
+OPENROUTER_API_KEY=sk-or-your-key-here
+GITHUB_TOKEN=ghp_your-token-here
+LLM_MODEL=qwen/qwen3-coder:free
+```
+
+### 4. Install backend dependencies
+
+```bash
+cd backend
+pip install "numpy<2"
+pip install -r requirements.txt
+```
+
+> **Windows note:** If `faiss-cpu` fails to install, run `pip install faiss-cpu --prefer-binary` instead.
+
+### 5. Install frontend dependencies
+
+```bash
+cd ../frontend
+npm install
+```
+
+---
+
+## Running the App
+
+You need two terminals open simultaneously.
+
+**Terminal 1 — Backend:**
+```bash
+cd backend
+uvicorn main:app --reload
+```
+Backend runs at `http://127.0.0.1:8000`
+
+**Terminal 2 — Frontend:**
+```bash
+cd frontend
+npm run dev
+```
+Frontend runs at `http://localhost:5173`
+
+Open `http://localhost:5173` in your browser.
+
+---
+
+## How to Use
+
+1. Paste any public GitHub repository URL into the input field
+   - Example: `https://github.com/tiangolo/fastapi`
+2. Click **Generate Docs** and wait 10–30 seconds
+3. Documentation appears for every Python file in the repo
+4. Click any file card to expand and read its docs
+5. Use the **Copy** or **Download .md** button on each card
+6. Click **Download All as ZIP** to get everything at once
+7. Type a question in the search bar to query the codebase
+   - Example: *"How do I handle authentication?"*
+8. Click **Generate README** to create a README for that repo
+9. Click **Generate .gitignore** for a project-specific gitignore
+
+---
+
+## API Endpoints
+
+| Method | Endpoint | Description |
+|--------|----------|-------------|
+| POST | `/generate-docs` | Generate docs for a GitHub repo |
+| POST | `/ask` | Ask a natural language question |
+| POST | `/generate-readme` | Generate a README.md for the repo |
+| POST | `/generate-gitignore` | Generate a .gitignore for the repo |
+
+**Example request:**
+```bash
+curl -X POST http://localhost:8000/generate-docs \
+  -H "Content-Type: application/json" \
+  -d '{"repo_url": "https://github.com/tiangolo/fastapi"}'
+```
+
+---
+
+## Environment Variables
+
+| Variable | Description | Required |
+|----------|-------------|----------|
+| `OPENROUTER_API_KEY` | Your OpenRouter API key | Yes |
+| `GITHUB_TOKEN` | GitHub personal access token | Yes |
+| `LLM_MODEL` | Model to use (default: `qwen/qwen3-coder:free`) | No |
+
+---
+
+## Known Limitations
+
+- **Free tier rate limits:** OpenRouter free tier allows 50 requests/day and 20 requests/minute. DocWizard batches all files into one request to stay within this limit.
+- **Python only:** The AST parser currently supports Python files only. JavaScript and other languages are planned for a future update.
+- **Public repos only:** Private repositories require additional GitHub token scopes.
+- **Context window:** Very large repos (100+ files) may exceed the model's context window. DocWizard will document as many files as fit.
+
+---
+
+## Troubleshooting
+
+**`uvicorn main:app --reload` gives NumPy error:**
+```bash
+pip install "numpy<2" --force-reinstall
+```
+
+**Search returns 0 results:**
+Generate docs first before searching — the search index is built during doc generation.
+
+**Rate limit error but OpenRouter shows 0 requests:**
+Your `.env` file is not being loaded. Make sure `load_dotenv()` is called at the top of `doc_generator.py` and your `.env` file is in the `backend/` folder.
+
+**`npm run dev` fails:**
+Make sure you ran `npm install` inside the `frontend/` folder first.
+
+---
+
+## Roadmap
+
+- [ ] JavaScript / TypeScript support
+- [ ] Private repository support
+- [ ] GitHub Action for auto-updating docs on push
+- [ ] Change detection — only re-document modified files
+- [ ] Architecture diagram generation
+- [ ] Multi-language support (Java, Go, Rust)
+
+---
+
+## License
+
+MIT License — free to use, modify, and distribute.
+
+---
+
+## Acknowledgements
+
+- [OpenRouter](https://openrouter.ai) for free LLM access
+- [FAISS](https://github.com/facebookresearch/faiss) by Meta for vector search
+- [sentence-transformers](https://www.sbert.net/) for local embeddings
+- [FastAPI](https://fastapi.tiangolo.com/) for the backend framework

frontend/index.html

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <link rel="icon" type="image/svg+xml" href="/vite.svg" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Vite + React</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.jsx"></script>
+  </body>
+</html>

frontend/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "frontend",
+  "private": true,
+  "version": "0.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "vite build",
+    "lint": "eslint . --ext js,jsx --report-unused-disable-directives --max-warnings 0",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@tailwindcss/typography": "^0.5.19",
+    "axios": "^1.14.0",
+    "marked": "^17.0.6",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.2.15",
+    "@types/react-dom": "^18.2.7",
+    "@vitejs/plugin-react": "^4.0.3",
+    "autoprefixer": "^10.4.27",
+    "eslint": "^8.45.0",
+    "eslint-plugin-react": "^7.32.2",
+    "eslint-plugin-react-hooks": "^4.6.0",
+    "eslint-plugin-react-refresh": "^0.4.3",
+    "postcss": "^8.5.8",
+    "tailwindcss": "^3.4.19",
+    "vite": "^4.4.5"
+  }
+}

frontend/postcss.config.js

@@ -0,0 +1,6 @@
+export default {
+  plugins: {
+    tailwindcss: {},
+    autoprefixer: {},
+  },
+}

frontend/src/App.jsx

@@ -0,0 +1,737 @@
+import { useState, useEffect } from 'react';
+import { marked } from 'marked';
+
+export default function App() {
+  // State management
+  const [repoUrl, setRepoUrl] = useState('');
+  const [generatedRepoUrl, setGeneratedRepoUrl] = useState('');
+  const [docs, setDocs] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [progress, setProgress] = useState(null);
+  const [statusMessage, setStatusMessage] = useState('');
+  const [expandedFiles, setExpandedFiles] = useState({}); // Track which files are expanded
+  const [searchQuery, setSearchQuery] = useState('');
+  const [searchResults, setSearchResults] = useState(null);
+  const [searchLoading, setSearchLoading] = useState(false);
+  const [searchError, setSearchError] = useState(null);
+  const [jsZipLoaded, setJsZipLoaded] = useState(false);
+  const [readme, setReadme] = useState(null);
+  const [readmeLoading, setReadmeLoading] = useState(false);
+  const [readmeError, setReadmeError] = useState(null);
+  const [gitignore, setGitignore] = useState(null);
+  const [gitignoreLoading, setGitignoreLoading] = useState(false);
+  const [gitignoreError, setGitignoreError] = useState(null);
+
+  const API_BASE = 'http://localhost:8000';
+
+  // Load JSZip library on mount
+  useEffect(() => {
+    const script = document.createElement('script');
+    script.src = 'https://cdnjs.cloudflare.com/ajax/libs/jszip/3.10.1/jszip.min.js';
+    script.onload = () => setJsZipLoaded(true);
+    document.head.appendChild(script);
+  }, []);
+
+  // Utility: Copy to clipboard
+  const copyToClipboard = (text, filename) => {
+    navigator.clipboard.writeText(text).then(() => {
+      alert(`Copied ${filename} to clipboard!`);
+    }).catch(() => {
+      alert('Failed to copy to clipboard');
+    });
+  };
+
+  // Utility: Download single markdown file
+  const downloadFile = (content, filename) => {
+    const blob = new Blob([content], { type: 'text/markdown' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = `${filename}.md`;
+    document.body.appendChild(a);
+    a.click();
+    document.body.removeChild(a);
+    URL.revokeObjectURL(url);
+  };
+
+  // Utility: Download all docs as ZIP
+  const downloadAllAsZip = async () => {
+    if (!docs || docs.length === 0 || !window.JSZip) {
+      alert('JSZip library not loaded or no docs available');
+      return;
+    }
+
+    try {
+      const zip = new window.JSZip();
+      docs.forEach(file => {
+        zip.file(`${file.filename}.md`, file.documentation);
+      });
+
+      const blob = await zip.generateAsync({ type: 'blob' });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement('a');
+      a.href = url;
+      a.download = `docwizard-${new Date().getTime()}.zip`;
+      document.body.appendChild(a);
+      a.click();
+      document.body.removeChild(a);
+      URL.revokeObjectURL(url);
+    } catch (err) {
+      console.error('Failed to download ZIP:', err);
+      alert('Failed to create ZIP file');
+    }
+  };
+
+  // Toggle accordion
+  const toggleFile = (filename) => {
+    setExpandedFiles(prev => ({
+      ...prev,
+      [filename]: !prev[filename]
+    }));
+  };
+
+  const handleGenerateDocs = async () => {
+    if (!repoUrl.trim()) {
+      setError('Please enter a GitHub repository URL');
+      return;
+    }
+
+    setLoading(true);
+    setError(null);
+    setDocs(null);
+    setProgress(null);
+    setStatusMessage('');
+    setExpandedFiles({});
+
+    try {
+      const response = await fetch(`${API_BASE}/generate-docs`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({ repo_url: repoUrl }),
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to generate documentation');
+      }
+
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder();
+      const processedFiles = [];
+      let buffer = '';
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split('\n');
+
+        for (let i = 0; i < lines.length - 1; i++) {
+          const line = lines[i].trim();
+          if (!line) continue;
+
+          try {
+            const data = JSON.parse(line);
+
+            if (data.status === 'file_processed') {
+              processedFiles.push(data.file);
+              setProgress({
+                current: data.current,
+                total: data.total,
+              });
+              setStatusMessage(`Processed ${data.current}/${data.total} files`);
+            } else if (data.status === 'rate_limit') {
+              setStatusMessage(data.message);
+            } else if (data.status === 'complete') {
+              setProgress(null);
+              setStatusMessage('');
+              setDocs(processedFiles);
+              setGeneratedRepoUrl(repoUrl);
+            } else if (data.status === 'error') {
+              throw new Error(data.message);
+            }
+          } catch (parseError) {
+            console.error('Failed to parse line:', line, parseError);
+          }
+        }
+
+        buffer = lines[lines.length - 1];
+      }
+
+      if (buffer.trim()) {
+        try {
+          const data = JSON.parse(buffer);
+          if (data.status === 'error') {
+            throw new Error(data.message);
+          }
+        } catch (parseError) {
+          console.error('Failed to parse final buffer:', buffer, parseError);
+        }
+      }
+    } catch (err) {
+      setError(err.message || 'An error occurred');
+      setDocs(null);
+      setProgress(null);
+    } finally {
+      setLoading(false);
+      setStatusMessage('');
+    }
+  };
+
+  const handleSearch = async () => {
+    // Validate that docs have been generated
+    if (!generatedRepoUrl) {
+      setSearchError('Please generate documentation for a repository first');
+      return;
+    }
+
+    if (!searchQuery.trim()) {
+      setSearchError('Please enter a search question');
+      return;
+    }
+
+    setSearchLoading(true);
+    setSearchError(null);
+    setSearchResults(null);
+
+    try {
+      const response = await fetch(`${API_BASE}/ask`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          repo_url: generatedRepoUrl,
+          question: searchQuery,
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to search documentation');
+      }
+
+      const data = await response.json();
+      if (data.status === 'success') {
+        setSearchResults(data.results);
+      } else {
+        setSearchError(data.message || 'Error searching documentation');
+      }
+    } catch (err) {
+      setSearchError(err.message || 'An error occurred');
+    } finally {
+      setSearchLoading(false);
+    }
+  };
+
+  const handleGenerateReadme = async () => {
+    if (!generatedRepoUrl) {
+      setReadmeError('Please generate documentation first');
+      return;
+    }
+
+    setReadmeLoading(true);
+    setReadmeError(null);
+    setReadme(null);
+
+    try {
+      const response = await fetch(`${API_BASE}/generate-readme`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          repo_url: generatedRepoUrl,
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to generate README');
+      }
+
+      const data = await response.json();
+      if (data.status === 'success') {
+        setReadme(data.readme);
+      } else {
+        setReadmeError(data.message || 'Error generating README');
+      }
+    } catch (err) {
+      setReadmeError(err.message || 'An error occurred');
+    } finally {
+      setReadmeLoading(false);
+    }
+  };
+
+  const handleGenerateGitignore = async () => {
+    if (!generatedRepoUrl) {
+      setGitignoreError('Please generate documentation first');
+      return;
+    }
+
+    setGitignoreLoading(true);
+    setGitignoreError(null);
+    setGitignore(null);
+
+    try {
+      const response = await fetch(`${API_BASE}/generate-gitignore`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          repo_url: generatedRepoUrl,
+        }),
+      });
+
+      if (!response.ok) {
+        throw new Error('Failed to generate .gitignore');
+      }
+
+      const data = await response.json();
+      if (data.status === 'success') {
+        setGitignore(data.gitignore);
+      } else {
+        setGitignoreError(data.message || 'Error generating .gitignore');
+      }
+    } catch (err) {
+      setGitignoreError(err.message || 'An error occurred');
+    } finally {
+      setGitignoreLoading(false);
+    }
+  };
+
+  return (
+    <div className="min-h-screen bg-white">
+      {/* Header */}
+      <header className="bg-white border-b border-gray-200 sticky top-0 z-50 shadow-sm">
+        <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-6">
+          <div>
+            <h1 className="text-3xl font-bold bg-gradient-to-r from-teal-600 to-teal-500 bg-clip-text text-transparent">
+              DocWizard
+            </h1>
+            <p className="text-gray-600 text-sm mt-1">AI-powered code documentation</p>
+          </div>
+        </div>
+      </header>
+
+      {/* Main Content */}
+      <main className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-12">
+        {/* Input Section */}
+        <div className="mb-12">
+          <div className="bg-white rounded-lg shadow-md hover:shadow-lg transition-shadow duration-300 p-8 border border-gray-100">
+            <h2 className="text-xl font-semibold text-gray-900 mb-6">Generate Documentation</h2>
+            
+            <div className="space-y-4">
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-2">
+                  GitHub Repository URL
+                </label>
+                <input
+                  type="text"
+                  value={repoUrl}
+                  onChange={(e) => setRepoUrl(e.target.value)}
+                  onKeyPress={(e) => e.key === 'Enter' && handleGenerateDocs()}
+                  placeholder="https://github.com/user/repo"
+                  className="w-full px-4 py-3 border border-gray-300 rounded-lg focus:ring-2 focus:ring-teal-500 focus:border-transparent outline-none transition text-gray-900"
+                />
+              </div>
+
+              <button
+                onClick={handleGenerateDocs}
+                disabled={loading}
+                className="w-full bg-gradient-to-r from-teal-600 to-teal-500 hover:from-teal-700 hover:to-teal-600 disabled:from-gray-400 disabled:to-gray-400 text-white font-semibold py-3 px-4 rounded-lg transition duration-200 flex items-center justify-center gap-2"
+              >
+                {loading ? (
+                  <>
+                    <svg className="animate-spin h-5 w-5" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
+                      <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4"></circle>
+                      <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                    </svg>
+                    Generating Docs...
+                  </>
+                ) : (
+                  <>
+                    <svg className="h-5 w-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 4v16m8-8H4" />
+                    </svg>
+                    Generate Docs
+                  </>
+                )}
+              </button>
+
+              {/* Progress Bar */}
+              {progress && (
+                <div className="space-y-3">
+                  <div className="w-full bg-gray-200 rounded-full h-2 overflow-hidden">
+                    <div
+                      className="bg-gradient-to-r from-teal-600 to-teal-500 h-2 rounded-full transition-all duration-300"
+                      style={{ width: `${(progress.current / progress.total) * 100}%` }}
+                    />
+                  </div>
+                  <p className="text-sm text-gray-600 text-center font-medium">
+                    {statusMessage || `Processing ${progress.current}/${progress.total} files...`}
+                  </p>
+                </div>
+              )}
+
+              {/* Error Alert */}
+              {error && (
+                <div className="p-4 bg-red-50 border border-red-200 rounded-lg flex gap-3">
+                  <svg className="h-5 w-5 text-red-600 flex-shrink-0 mt-0.5" fill="currentColor" viewBox="0 0 20 20">
+                    <path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clipRule="evenodd" />
+                  </svg>
+                  <span className="text-sm text-red-800">{error}</span>
+                </div>
+              )}
+            </div>
+          </div>
+        </div>
+
+        {/* Generated Docs Section */}
+        {docs && docs.length > 0 && (
+          <div className="mb-12">
+            <div className="flex items-center justify-between mb-6">
+              <h2 className="text-2xl font-bold text-gray-900">Generated Documentation</h2>
+              <div className="flex gap-3">
+                <button
+                  onClick={handleGenerateReadme}
+                  disabled={readmeLoading || !generatedRepoUrl}
+                  className="flex items-center gap-2 bg-blue-600 hover:bg-blue-700 disabled:bg-gray-400 text-white font-medium py-2 px-4 rounded-lg transition"
+                  title="Generate project README"
+                >
+                  <svg className="h-5 w-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                    <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+                  </svg>
+                  {readmeLoading ? 'Generating...' : 'Generate README'}
+                </button>
+
+                <button
+                  onClick={handleGenerateGitignore}
+                  disabled={gitignoreLoading || !generatedRepoUrl}
+                  className="flex items-center gap-2 bg-purple-600 hover:bg-purple-700 disabled:bg-gray-400 text-white font-medium py-2 px-4 rounded-lg transition"
+                  title="Generate .gitignore"
+                >
+                  <svg className="h-5 w-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                    <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+                  </svg>
+                  {gitignoreLoading ? 'Generating...' : 'Generate .gitignore'}
+                </button>
+
+                <button
+                  onClick={downloadAllAsZip}
+                  disabled={!jsZipLoaded}
+                  className="flex items-center gap-2 bg-teal-600 hover:bg-teal-700 disabled:bg-gray-400 text-white font-medium py-2 px-4 rounded-lg transition"
+                >
+                  <svg className="h-5 w-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                    <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-4l-4 4m0 0l-4-4m4 4V4" />
+                  </svg>
+                  Download All as ZIP
+                </button>
+              </div>
+            </div>
+
+            <div className="space-y-3">
+              {docs.map((file, index) => (
+                <div
+                  key={index}
+                  className="bg-white border border-gray-200 rounded-lg overflow-hidden hover:shadow-md transition-shadow"
+                >
+                  {/* Accordion Header */}
+                  <button
+                    onClick={() => toggleFile(file.filename)}
+                    className="w-full px-6 py-4 flex items-center justify-between hover:bg-gray-50 transition"
+                  >
+                    <div className="flex items-center gap-3 flex-1 text-left">
+                      <svg
+                        className={`h-5 w-5 text-teal-600 transition-transform ${expandedFiles[file.filename] ? 'rotate-180' : ''}`}
+                        fill="currentColor"
+                        viewBox="0 0 20 20"
+                      >
+                        <path fillRule="evenodd" d="M5.293 7.293a1 1 0 011.414 0L10 10.586l3.293-3.293a1 1 0 111.414 1.414l-4 4a1 1 0 01-1.414 0l-4-4a1 1 0 010-1.414z" clipRule="evenodd" />
+                      </svg>
+                      <span className="font-mono text-sm font-semibold text-gray-900">{file.filename}</span>
+                      <span className="ml-auto text-xs bg-teal-100 text-teal-800 px-2 py-1 rounded">
+                        {file.documentation.length} bytes
+                      </span>
+                    </div>
+                  </button>
+
+                  {/* Accordion Content */}
+                  {expandedFiles[file.filename] && (
+                    <div className="border-t border-gray-200 bg-gray-50 px-6 py-4">
+                      {/* Markdown Content */}
+                      <div className="prose prose-sm max-w-none mb-6 bg-white rounded p-4 max-h-96 overflow-y-auto text-gray-900">
+                        <div dangerouslySetInnerHTML={{ __html: marked(file.documentation) }} />
+                      </div>
+
+                      {/* Action Buttons */}
+                      <div className="flex gap-3 pt-4 border-t border-gray-200">
+                        <button
+                          onClick={() => copyToClipboard(file.documentation, file.filename)}
+                          className="flex-1 flex items-center justify-center gap-2 bg-blue-100 hover:bg-blue-200 text-blue-700 font-medium py-2 px-4 rounded-lg transition"
+                        >
+                          <svg className="h-4 w-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z" />
+                          </svg>
+                          Copy
+                        </button>
+                        <button
+                          onClick={() => downloadFile(file.documentation, file.filename)}
+                          className="flex-1 flex items-center justify-center gap-2 bg-green-100 hover:bg-green-200 text-green-700 font-medium py-2 px-4 rounded-lg transition"
+                        >
+                          <svg className="h-4 w-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                            <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 16v-4m0 0V8m0 4h4m-4 0H8m7 4v2a2 2 0 01-2 2H5a2 2 0 01-2-2v-6a2 2 0 012-2h14a2 2 0 012 2v6a2 2 0 01-2 2z" />
+                          </svg>
+                          Download .md
+                        </button>
+                      </div>
+                    </div>
+                  )}
+                </div>
+              ))}
+            </div>
+          </div>
+        )}
+
+        {/* README Section */}
+        {readme && (
+          <div className="mb-12">
+            <div className="bg-white rounded-lg shadow-md hover:shadow-lg transition-shadow duration-300 border border-gray-100 overflow-hidden">
+              {/* README Header */}
+              <div className="bg-gradient-to-r from-blue-600 to-blue-500 px-6 py-4 text-white">
+                <div className="flex items-center justify-between">
+                  <h2 className="text-2xl font-bold flex items-center gap-2">
+                    <svg className="h-6 w-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+                    </svg>
+                    README.md
+                  </h2>
+                </div>
+              </div>
+
+              {/* README Content */}
+              <div className="p-6">
+                <div className="prose prose-sm max-w-none bg-gray-50 rounded-lg p-6 max-h-96 overflow-y-auto">
+                  <div dangerouslySetInnerHTML={{ __html: marked(readme) }} />
+                </div>
+
+                {/* README Actions */}
+                <div className="flex gap-3 mt-6 pt-6 border-t border-gray-200">
+                  <button
+                    onClick={() => copyToClipboard(readme, 'README.md')}
+                    className="flex-1 flex items-center justify-center gap-2 bg-blue-100 hover:bg-blue-200 text-blue-700 font-medium py-2 px-4 rounded-lg transition"
+                  >
+                    <svg className="h-4 w-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z" />
+                    </svg>
+                    Copy to Clipboard
+                  </button>
+                  <button
+                    onClick={() => downloadFile(readme, 'README')}
+                    className="flex-1 flex items-center justify-center gap-2 bg-green-100 hover:bg-green-200 text-green-700 font-medium py-2 px-4 rounded-lg transition"
+                  >
+                    <svg className="h-4 w-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-4l-4 4m0 0l-4-4m4 4V4" />
+                    </svg>
+                    Download README.md
+                  </button>
+                </div>
+
+                {readmeError && (
+                  <div className="mt-4 p-4 bg-red-50 border border-red-200 rounded-lg flex gap-3">
+                    <svg className="h-5 w-5 text-red-600 flex-shrink-0 mt-0.5" fill="currentColor" viewBox="0 0 20 20">
+                      <path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clipRule="evenodd" />
+                    </svg>
+                    <span className="text-sm text-red-800">{readmeError}</span>
+                  </div>
+                )}
+              </div>
+            </div>
+          </div>
+        )}
+
+        {/* .gitignore Section */}
+        {gitignore && (
+          <div className="mb-12">
+            <div className="bg-white rounded-lg shadow-md hover:shadow-lg transition-shadow duration-300 border border-gray-100 overflow-hidden">
+              {/* Gitignore Header */}
+              <div className="bg-gradient-to-r from-purple-600 to-purple-500 px-6 py-4 text-white">
+                <div className="flex items-center justify-between">
+                  <h2 className="text-2xl font-bold flex items-center gap-2">
+                    <svg className="h-6 w-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+                    </svg>
+                    .gitignore
+                  </h2>
+                </div>
+              </div>
+
+              {/* Gitignore Content */}
+              <div className="p-6">
+                <div className="bg-gray-900 text-gray-100 rounded-lg p-6 max-h-96 overflow-y-auto font-mono text-sm whitespace-pre-wrap">
+                  {gitignore}
+                </div>
+
+                {/* Gitignore Actions */}
+                <div className="flex gap-3 mt-6 pt-6 border-t border-gray-200">
+                  <button
+                    onClick={() => copyToClipboard(gitignore, '.gitignore')}
+                    className="flex-1 flex items-center justify-center gap-2 bg-purple-100 hover:bg-purple-200 text-purple-700 font-medium py-2 px-4 rounded-lg transition"
+                  >
+                    <svg className="h-4 w-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z" />
+                    </svg>
+                    Copy to Clipboard
+                  </button>
+                  <button
+                    onClick={() => downloadFile(gitignore, '.gitignore')}
+                    className="flex-1 flex items-center justify-center gap-2 bg-green-100 hover:bg-green-200 text-green-700 font-medium py-2 px-4 rounded-lg transition"
+                  >
+                    <svg className="h-4 w-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M4 16v1a3 3 0 003 3h10a3 3 0 003-3v-1m-4-4l-4 4m0 0l-4-4m4 4V4" />
+                    </svg>
+                    Download .gitignore
+                  </button>
+                </div>
+
+                {gitignoreError && (
+                  <div className="mt-4 p-4 bg-red-50 border border-red-200 rounded-lg flex gap-3">
+                    <svg className="h-5 w-5 text-red-600 flex-shrink-0 mt-0.5" fill="currentColor" viewBox="0 0 20 20">
+                      <path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clipRule="evenodd" />
+                    </svg>
+                    <span className="text-sm text-red-800">{gitignoreError}</span>
+                  </div>
+                )}
+              </div>
+            </div>
+          </div>
+        )}
+
+        {/* Search Section */}
+        <div className="mb-12">
+          <div className="bg-white rounded-lg shadow-md hover:shadow-lg transition-shadow duration-300 p-8 border border-gray-100">
+            <h2 className="text-xl font-semibold text-gray-900 mb-6">Search Documentation</h2>
+
+            <div className="space-y-4">
+              <div>
+                <label className="block text-sm font-medium text-gray-700 mb-2">
+                  Ask a Question
+                </label>
+                <div className="relative">
+                  <textarea
+                    value={searchQuery}
+                    onChange={(e) => setSearchQuery(e.target.value)}
+                    onKeyPress={(e) => {
+                      if (e.key === 'Enter' && e.ctrlKey) {
+                        handleSearch();
+                      }
+                    }}
+                    placeholder="Ask a question about the code... (Press Ctrl+Enter to search)"
+                    rows="3"
+                    className="w-full px-4 py-3 border border-gray-300 rounded-lg focus:ring-2 focus:ring-teal-500 focus:border-transparent outline-none resize-none text-gray-900 placeholder-gray-500"
+                  />
+                </div>
+              </div>
+
+              <button
+                onClick={handleSearch}
+                disabled={searchLoading || !generatedRepoUrl}
+                className="w-full bg-gradient-to-r from-teal-600 to-teal-500 hover:from-teal-700 hover:to-teal-600 disabled:from-gray-400 disabled:to-gray-400 text-white font-semibold py-3 px-4 rounded-lg transition duration-200 flex items-center justify-center gap-2"
+              >
+                {searchLoading ? (
+                  <>
+                    <svg className="animate-spin h-5 w-5" xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24">
+                      <circle className="opacity-25" cx="12" cy="12" r="10" stroke="currentColor" strokeWidth="4"></circle>
+                      <path className="opacity-75" fill="currentColor" d="M4 12a8 8 0 018-8V0C5.373 0 0 5.373 0 12h4zm2 5.291A7.962 7.962 0 014 12H0c0 3.042 1.135 5.824 3 7.938l3-2.647z"></path>
+                    </svg>
+                    Searching...
+                  </>
+                ) : (
+                  <>
+                    <svg className="h-5 w-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M21 21l-6-6m2-5a7 7 0 11-14 0 7 7 0 0114 0z" />
+                    </svg>
+                    Search Docs
+                  </>
+                )}
+              </button>
+
+              {searchError && (
+                <div className="p-4 bg-red-50 border border-red-200 rounded-lg flex gap-3">
+                  <svg className="h-5 w-5 text-red-600 flex-shrink-0 mt-0.5" fill="currentColor" viewBox="0 0 20 20">
+                    <path fillRule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clipRule="evenodd" />
+                  </svg>
+                  <span className="text-sm text-red-800">{searchError}</span>
+                </div>
+              )}
+            </div>
+          </div>
+        </div>
+
+        {/* Search Results Section */}
+        {searchResults && searchResults.length > 0 && (
+          <div className="mb-12">
+            <h2 className="text-2xl font-bold text-gray-900 mb-6">
+              Search Results
+              <span className="ml-3 text-lg font-normal text-gray-500">
+                {searchResults.length} result{searchResults.length !== 1 ? 's' : ''}
+              </span>
+            </h2>
+
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+              {searchResults.map((result, index) => (
+                <div
+                  key={index}
+                  className="bg-white border border-gray-200 rounded-lg p-6 hover:shadow-md transition-shadow"
+                >
+                  <div className="flex items-start justify-between mb-4">
+                    <span className="inline-block bg-teal-100 text-teal-800 text-xs font-semibold px-3 py-1 rounded-full">
+                      {result.filename}
+                    </span>
+                    <span className="text-xs text-gray-500">
+                      Relevance: {(1 / (1 + result.distance)).toFixed(2)}
+                    </span>
+                  </div>
+
+                  <div className="prose prose-sm max-w-none text-gray-700 max-h-48 overflow-y-auto">
+                    <div dangerouslySetInnerHTML={{ __html: marked(result.document) }} />
+                  </div>
+
+                  <button
+                    onClick={() => copyToClipboard(result.document, `${result.filename}-result`)}
+                    className="mt-4 text-sm text-teal-600 hover:text-teal-700 font-medium flex items-center gap-1"
+                  >
+                    <svg className="h-4 w-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                      <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M8 16H6a2 2 0 01-2-2V6a2 2 0 012-2h8a2 2 0 012 2v2m-6 12h8a2 2 0 002-2v-8a2 2 0 00-2-2h-8a2 2 0 00-2 2v8a2 2 0 002 2z" />
+                    </svg>
+                    Copy Result
+                  </button>
+                </div>
+              ))}
+            </div>
+          </div>
+        )}
+
+        {/* Empty State */}
+        {!docs && !searchResults && !loading && (
+          <div className="text-center py-16">
+            <svg className="h-16 w-16 text-gray-400 mx-auto mb-4" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+              <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={1.5} d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+            </svg>
+            <h3 className="text-lg font-medium text-gray-900 mb-2">No documentation yet</h3>
+            <p className="text-gray-600 mb-6">Enter a GitHub repository URL above to get started</p>
+          </div>
+        )}
+      </main>
+
+      {/* Footer */}
+      <footer className="bg-gray-50 border-t border-gray-200 mt-16">
+        <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8 text-center text-sm text-gray-600">
+          <p>DocWizard · AI-powered documentation generator</p>
+        </div>
+      </footer>
+    </div>
+  );
+}

frontend/src/index.css

@@ -0,0 +1,113 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+/* Markdown prose styling */
+.prose table { 
+  border-collapse: collapse; 
+  width: 100%; 
+}
+
+.prose td, .prose th { 
+  border: 1px solid #e5e7eb; 
+  padding: 8px 12px; 
+  text-align: left;
+}
+
+.prose th { 
+  background: #f9fafb; 
+  font-weight: 600; 
+  color: #111827;
+}
+
+.prose code { 
+  background: #f3f4f6; 
+  padding: 2px 6px; 
+  border-radius: 4px;
+  font-size: 0.875em;
+}
+
+.prose pre { 
+  background: #1e293b; 
+  color: #e2e8f0; 
+  padding: 16px; 
+  border-radius: 8px;
+  overflow-x: auto;
+  line-height: 1.5;
+}
+
+.prose pre code {
+  background: transparent;
+  color: inherit;
+  padding: 0;
+}
+
+.prose h2 {
+  font-size: 1.5em;
+  font-weight: 700;
+  margin-top: 1.5em;
+  margin-bottom: 0.5em;
+  color: #111827;
+}
+
+.prose h3 {
+  font-size: 1.25em;
+  font-weight: 600;
+  margin-top: 1.25em;
+  margin-bottom: 0.5em;
+  color: #111827;
+}
+
+.prose h4 {
+  font-size: 1.1em;
+  font-weight: 600;
+  margin-top: 1em;
+  margin-bottom: 0.5em;
+  color: #111827;
+}
+
+.prose p {
+  margin-bottom: 1em;
+  line-height: 1.6;
+}
+
+.prose ul, .prose ol {
+  margin-bottom: 1em;
+  padding-left: 1.5em;
+}
+
+.prose li {
+  margin-bottom: 0.5em;
+}
+
+.prose strong, .prose b {
+  font-weight: 700;
+  color: #111827;
+}
+
+.prose em, .prose i {
+  font-style: italic;
+  color: #374151;
+}
+
+.prose a {
+  color: #0ea5e9;
+  text-decoration: underline;
+}
+
+.prose a:hover {
+  color: #0284c7;
+}
+
+.prose blockquote {
+  border-left: 4px solid #e5e7eb;
+  padding-left: 1em;
+  color: #6b7280;
+  font-style: italic;
+  margin: 1em 0;
+}
+
+.prose hr {
+  border-color: #e5e7eb;
+  margin: 2em 0;
+}

frontend/src/main.jsx

@@ -0,0 +1,10 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App.jsx'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)

frontend/tailwind.config.js

@@ -0,0 +1,8 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+  content: ["./index.html", "./src/**/*.{js,jsx}"],
+  theme: {
+    extend: {},
+  },
+  plugins: [require('@tailwindcss/typography')],
+}

frontend/vite.config.js

@@ -0,0 +1,7 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [react()],
+})

requirements.txt

@@ -0,0 +1,10 @@
+fastapi==0.104.1
+uvicorn==0.24.0
+anthropic==0.7.1
+gitpython==3.1.40
+requests==2.31.0
+python-dotenv==1.0.0
+openai==1.3.0
+faiss-cpu==1.7.4
+sentence-transformers==2.2.2
+httpx==0.27.0