From 27c09945d292e037bcebf2e74c020c87ebb0c41a Mon Sep 17 00:00:00 2001
From: Asklv <boironic@gmail.com>
Date: Thu, 30 Oct 2025 20:06:00 +0800
Subject: [PATCH] feat: support basic doc generator for memov.

Signed-off-by: Asklv <boironic@gmail.com>
---
 mem_mcp_server/utils/summarizer.py |  11 +-
 memov/debugging/__init__.py        |   5 +
 memov/debugging/llm_client.py      | 152 ++++++++
 memov/docgen/__init__.py           |  47 +++
 memov/docgen/code_analyzer.py      | 372 +++++++++++++++++++
 memov/docgen/diagram_generator.py  | 425 ++++++++++++++++++++++
 memov/docgen/doc_generator.py      | 558 +++++++++++++++++++++++++++++
 memov/docgen/git_utils.py          | 405 +++++++++++++++++++++
 memov/docgen/preview_server.py     | 542 ++++++++++++++++++++++++++++
 memov/docgen_cli.py                | 555 ++++++++++++++++++++++++++++
 pyproject.toml                     |   5 +
 11 files changed, 3073 insertions(+), 4 deletions(-)
 create mode 100644 memov/debugging/__init__.py
 create mode 100644 memov/debugging/llm_client.py
 create mode 100644 memov/docgen/__init__.py
 create mode 100644 memov/docgen/code_analyzer.py
 create mode 100644 memov/docgen/diagram_generator.py
 create mode 100644 memov/docgen/doc_generator.py
 create mode 100644 memov/docgen/git_utils.py
 create mode 100644 memov/docgen/preview_server.py
 create mode 100644 memov/docgen_cli.py

diff --git a/mem_mcp_server/utils/summarizer.py b/mem_mcp_server/utils/summarizer.py
index 392c09c..465294a 100644
--- a/mem_mcp_server/utils/summarizer.py
+++ b/mem_mcp_server/utils/summarizer.py
@@ -27,7 +27,7 @@ class HTTPOpenAISummarizer:
     HTTP-based OpenAI summarizer that doesn't depend on the openai package
     """
 
-    def __init__(self, api_key: str = None, model: str = "gpt-4o-mini"):
+    def __init__(self, api_key: str = None, model: str = "qwen2:0.5b"):
         """
         Initialize the HTTP OpenAI summarizer
 
@@ -48,7 +48,8 @@ def __init__(self, api_key: str = None, model: str = "gpt-4o-mini"):
 
         self.api_key = api_key or os.environ.get("OPENAI_API_KEY")
         self.model = model
-        self.api_url = "https://api.openai.com/v1/chat/completions"
+        self.api_url = "http://127.0.0.1:11434/v1/chat/completions"
+        # self.api_url = "https://api.openai.com/v1/chat/completions"
 
         LOGGER.info(f"API key set: {'Yes' if self.api_key else 'No'}")
 
@@ -125,7 +126,7 @@ def generate_summary(self, context: str) -> str:
 
     def _get_json_system_prompt(self) -> str:
         """Get optimized system prompt that ensures JSON output"""
-        return f"""You are an expert development assistant specializing in analyzing commit history and creating detailed project summaries. 
+        return f"""You are an expert development assistant specializing in analyzing commit history and creating detailed project summaries.
 
 You must respond with a valid JSON object following this exact schema:
 
@@ -134,7 +135,7 @@ def _get_json_system_prompt(self) -> str:
 Instructions for analysis:
 1. Analyze each commit chronologically
 2. Extract user requests and intents behind changes
-3. Identify technical decisions and code patterns  
+3. Identify technical decisions and code patterns
 4. Document file changes with specific details
 5. Note errors encountered and how they were resolved
 6. Track ongoing troubleshooting efforts
@@ -309,6 +310,8 @@ def create_summary_from_commits(
         # Try AI summarization using HTTP client (no dependencies)
         summarizer = HTTPOpenAISummarizer()
         ai_summary = summarizer.generate_summary(context)
+        print("AI Summary Generated:")
+        print(ai_summary)
 
         return {
             "ai_generated_summary": ai_summary,
diff --git a/memov/debugging/__init__.py b/memov/debugging/__init__.py
new file mode 100644
index 0000000..3c23bcd
--- /dev/null
+++ b/memov/debugging/__init__.py
@@ -0,0 +1,5 @@
+"""Debugging utilities for memov."""
+
+from .llm_client import LLMClient
+
+__all__ = ["LLMClient"]
diff --git a/memov/debugging/llm_client.py b/memov/debugging/llm_client.py
new file mode 100644
index 0000000..b791c13
--- /dev/null
+++ b/memov/debugging/llm_client.py
@@ -0,0 +1,152 @@
+"""
+LLM client for document generation.
+
+Provides a unified interface for calling various LLM providers.
+Uses litellm for multi-provider support.
+"""
+
+import logging
+from typing import Any, Dict, List, Optional
+
+logger = logging.getLogger(__name__)
+
+
+class LLMClient:
+    """Client for interacting with LLM APIs."""
+
+    def __init__(self, models: List[str], api_key: Optional[str] = None):
+        """
+        Initialize LLM client.
+
+        Args:
+            models: List of model names to use
+            api_key: Optional API key (will use environment variables if not provided)
+        """
+        self.models = models
+        self.api_key = api_key
+
+        # Try to import litellm
+        try:
+            import litellm
+            self.litellm = litellm
+            self.available = True
+
+            # Configure litellm
+            if api_key:
+                litellm.api_key = api_key
+
+            # Suppress verbose logging
+            litellm.set_verbose = False
+
+        except ImportError:
+            logger.warning(
+                "litellm not installed. Install with: pip install litellm\n"
+                "Document generation will use fallback mode."
+            )
+            self.litellm = None
+            self.available = False
+
+    def query_single(
+        self,
+        model: str,
+        prompt: str,
+        system_prompt: Optional[str] = None,
+        temperature: float = 0.7,
+        max_tokens: int = 4000,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """
+        Query a single LLM model.
+
+        Args:
+            model: Model name
+            prompt: User prompt
+            system_prompt: Optional system prompt
+            temperature: Sampling temperature
+            max_tokens: Maximum tokens to generate
+            **kwargs: Additional arguments for litellm
+
+        Returns:
+            Dictionary with 'content' and optionally 'error' keys
+        """
+        if not self.available or not self.litellm:
+            return {
+                'error': 'LLM client not available',
+                'content': ''
+            }
+
+        try:
+            # Build messages
+            messages = []
+            if system_prompt:
+                messages.append({
+                    "role": "system",
+                    "content": system_prompt
+                })
+            messages.append({
+                "role": "user",
+                "content": prompt
+            })
+
+            # Call LLM
+            response = self.litellm.completion(
+                model=model,
+                messages=messages,
+                temperature=temperature,
+                max_tokens=max_tokens,
+                **kwargs
+            )
+
+            print("LLM Response:", response)
+
+            # Extract content
+            content = response.choices[0].message.content
+
+            return {
+                'content': content,
+                'model': model,
+                # Unused now
+                # 'usage': response.usage._asdict() if hasattr(response, 'usage') else {}
+                'usage': response.usage
+            }
+
+        except Exception as e:
+            logger.error(f"Error calling LLM {model}: {e}")
+            return {
+                'error': str(e),
+                'content': ''
+            }
+
+    def query_multiple(
+        self,
+        prompts: List[str],
+        model: Optional[str] = None,
+        system_prompt: Optional[str] = None,
+        **kwargs
+    ) -> List[Dict[str, Any]]:
+        """
+        Query LLM with multiple prompts.
+
+        Args:
+            prompts: List of prompts
+            model: Model to use (default: first model in list)
+            system_prompt: Optional system prompt
+            **kwargs: Additional arguments
+
+        Returns:
+            List of response dictionaries
+        """
+        if not model:
+            model = self.models[0] if self.models else "gpt-4o-mini"
+
+        responses = []
+        for prompt in prompts:
+            response = self.query_single(
+                model=model,
+                prompt=prompt,
+                system_prompt=system_prompt,
+                **kwargs
+            )
+            responses.append(response)
+
+        return responses
diff --git a/memov/docgen/__init__.py b/memov/docgen/__init__.py
new file mode 100644
index 0000000..33ef1cf
--- /dev/null
+++ b/memov/docgen/__init__.py
@@ -0,0 +1,47 @@
+"""
+Documentation generation module for code analysis and documentation.
+
+This module provides tools for:
+- Code parsing and analysis
+- Document generation using LLM
+- Mermaid diagram generation
+- Multi-level documentation (commit, branch, repository)
+- Git integration for commit/branch analysis
+- Web preview server
+"""
+
+from .code_analyzer import CodeAnalyzer, ClassInfo, FunctionInfo, ModuleInfo
+from .diagram_generator import DiagramGenerator, DiagramType
+from .doc_generator import DocType, DocumentGenerator, DocumentStructure, GeneratedDocument
+from .git_utils import CommitInfo, GitUtils
+
+# Preview server is optional (requires starlette)
+try:
+    from .preview_server import PreviewServer, start_preview_server
+    _HAS_PREVIEW_SERVER = True
+except ImportError:
+    PreviewServer = None
+    start_preview_server = None
+    _HAS_PREVIEW_SERVER = False
+
+__all__ = [
+    # Code Analysis
+    "CodeAnalyzer",
+    "ModuleInfo",
+    "ClassInfo",
+    "FunctionInfo",
+    # Document Generation
+    "DocumentGenerator",
+    "DocumentStructure",
+    "GeneratedDocument",
+    "DocType",
+    # Diagram Generation
+    "DiagramGenerator",
+    "DiagramType",
+    # Git Utilities
+    "GitUtils",
+    "CommitInfo",
+    # Preview Server (optional)
+    "PreviewServer",
+    "start_preview_server",
+]
diff --git a/memov/docgen/code_analyzer.py b/memov/docgen/code_analyzer.py
new file mode 100644
index 0000000..18404c5
--- /dev/null
+++ b/memov/docgen/code_analyzer.py
@@ -0,0 +1,372 @@
+"""
+Code analyzer for extracting structure and information from source code.
+
+Uses AST parsing to extract:
+- Functions, classes, methods
+- Parameters, return types, docstrings
+- Dependencies and imports
+- Call relationships
+"""
+
+import ast
+import logging
+import re
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Set
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class FunctionInfo:
+    """Information about a function or method."""
+    name: str
+    params: List[str]
+    return_type: Optional[str] = None
+    docstring: Optional[str] = None
+    decorators: List[str] = field(default_factory=list)
+    is_async: bool = False
+    line_start: int = 0
+    line_end: int = 0
+    body_preview: str = ""
+
+
+@dataclass
+class ClassInfo:
+    """Information about a class."""
+    name: str
+    bases: List[str]
+    methods: List[FunctionInfo]
+    attributes: List[str]
+    docstring: Optional[str] = None
+    decorators: List[str] = field(default_factory=list)
+    line_start: int = 0
+    line_end: int = 0
+
+
+@dataclass
+class ModuleInfo:
+    """Information about a module/file."""
+    file_path: str
+    imports: List[str]
+    functions: List[FunctionInfo]
+    classes: List[ClassInfo]
+    docstring: Optional[str] = None
+    dependencies: Set[str] = field(default_factory=set)
+    loc: int = 0  # Lines of code
+
+
+class CodeAnalyzer:
+    """Analyzes Python code to extract structural information."""
+
+    def __init__(self, project_path: str):
+        """
+        Initialize code analyzer.
+
+        Args:
+            project_path: Path to the project root
+        """
+        self.project_path = Path(project_path)
+
+    def analyze_file(self, file_path: str) -> Optional[ModuleInfo]:
+        """
+        Analyze a single Python file.
+
+        Args:
+            file_path: Path to the file to analyze
+
+        Returns:
+            ModuleInfo object or None if parsing fails
+        """
+        try:
+            file_path_obj = Path(file_path)
+            if not file_path_obj.exists():
+                logger.warning(f"File not found: {file_path}")
+                return None
+
+            with open(file_path_obj, 'r', encoding='utf-8') as f:
+                code = f.read()
+
+            # Parse AST
+            tree = ast.parse(code, filename=str(file_path_obj))
+
+            # Extract information
+            module_info = ModuleInfo(
+                file_path=str(file_path_obj),
+                imports=[],
+                functions=[],
+                classes=[],
+                docstring=ast.get_docstring(tree),
+                loc=len(code.splitlines())
+            )
+
+            # Visit AST nodes
+            for node in ast.walk(tree):
+                if isinstance(node, ast.Import):
+                    for alias in node.names:
+                        module_info.imports.append(alias.name)
+                        module_info.dependencies.add(alias.name.split('.')[0])
+
+                elif isinstance(node, ast.ImportFrom):
+                    if node.module:
+                        module_info.imports.append(node.module)
+                        module_info.dependencies.add(node.module.split('.')[0])
+
+            # Extract top-level functions and classes
+            for node in tree.body:
+                if isinstance(node, ast.FunctionDef) or isinstance(node, ast.AsyncFunctionDef):
+                    func_info = self._extract_function(node)
+                    module_info.functions.append(func_info)
+
+                elif isinstance(node, ast.ClassDef):
+                    class_info = self._extract_class(node)
+                    module_info.classes.append(class_info)
+
+            return module_info
+
+        except Exception as e:
+            logger.error(f"Error analyzing file {file_path}: {e}")
+            return None
+
+    def analyze_directory(
+        self,
+        directory: str,
+        extensions: List[str] = None,
+        exclude_patterns: List[str] = None
+    ) -> List[ModuleInfo]:
+        """
+        Analyze all Python files in a directory.
+
+        Args:
+            directory: Directory to analyze
+            extensions: File extensions to include (default: ['.py'])
+            exclude_patterns: Patterns to exclude (e.g., ['test_', '__pycache__'])
+
+        Returns:
+            List of ModuleInfo objects
+        """
+        if extensions is None:
+            extensions = ['.py']
+        if exclude_patterns is None:
+            exclude_patterns = ['__pycache__', '.git', '.venv', 'venv', 'node_modules']
+
+        directory_path = Path(directory)
+        modules = []
+
+        for ext in extensions:
+            for file_path in directory_path.rglob(f'*{ext}'):
+                # Check exclude patterns
+                if any(pattern in str(file_path) for pattern in exclude_patterns):
+                    continue
+
+                module_info = self.analyze_file(str(file_path))
+                if module_info:
+                    modules.append(module_info)
+
+        return modules
+
+    def analyze_files(self, file_paths: List[str]) -> List[ModuleInfo]:
+        """
+        Analyze a list of files.
+
+        Args:
+            file_paths: List of file paths to analyze
+
+        Returns:
+            List of ModuleInfo objects
+        """
+        modules = []
+        for file_path in file_paths:
+            module_info = self.analyze_file(file_path)
+            if module_info:
+                modules.append(module_info)
+        return modules
+
+    def _extract_function(self, node: ast.FunctionDef) -> FunctionInfo:
+        """Extract information from a function/method node."""
+        # Extract parameters
+        params = []
+        for arg in node.args.args:
+            param_str = arg.arg
+            if arg.annotation:
+                param_str += f": {ast.unparse(arg.annotation)}"
+            params.append(param_str)
+
+        # Extract return type
+        return_type = None
+        if node.returns:
+            return_type = ast.unparse(node.returns)
+
+        # Extract decorators
+        decorators = [ast.unparse(dec) for dec in node.decorator_list]
+
+        # Get body preview (first few lines)
+        body_lines = []
+        for stmt in node.body[:3]:  # First 3 statements
+            try:
+                body_lines.append(ast.unparse(stmt))
+            except:
+                pass
+        body_preview = '\n'.join(body_lines)
+
+        return FunctionInfo(
+            name=node.name,
+            params=params,
+            return_type=return_type,
+            docstring=ast.get_docstring(node),
+            decorators=decorators,
+            is_async=isinstance(node, ast.AsyncFunctionDef),
+            line_start=node.lineno,
+            line_end=node.end_lineno or node.lineno,
+            body_preview=body_preview
+        )
+
+    def _extract_class(self, node: ast.ClassDef) -> ClassInfo:
+        """Extract information from a class node."""
+        # Extract base classes
+        bases = [ast.unparse(base) for base in node.bases]
+
+        # Extract methods
+        methods = []
+        for item in node.body:
+            if isinstance(item, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                methods.append(self._extract_function(item))
+
+        # Extract attributes (simple assignments)
+        attributes = []
+        for item in node.body:
+            if isinstance(item, ast.AnnAssign) and isinstance(item.target, ast.Name):
+                attr_name = item.target.id
+                if item.annotation:
+                    attr_name += f": {ast.unparse(item.annotation)}"
+                attributes.append(attr_name)
+            elif isinstance(item, ast.Assign):
+                for target in item.targets:
+                    if isinstance(target, ast.Name):
+                        attributes.append(target.id)
+
+        # Extract decorators
+        decorators = [ast.unparse(dec) for dec in node.decorator_list]
+
+        return ClassInfo(
+            name=node.name,
+            bases=bases,
+            methods=methods,
+            attributes=attributes,
+            docstring=ast.get_docstring(node),
+            decorators=decorators,
+            line_start=node.lineno,
+            line_end=node.end_lineno or node.lineno
+        )
+
+    def get_dependencies(self, modules: List[ModuleInfo]) -> Dict[str, Set[str]]:
+        """
+        Build dependency graph from modules.
+
+        Args:
+            modules: List of analyzed modules
+
+        Returns:
+            Dictionary mapping file paths to their dependencies
+        """
+        dependencies = {}
+
+        for module in modules:
+            deps = set()
+            for imp in module.imports:
+                # Check if import is internal (within project)
+                imp_path = self.project_path / (imp.replace('.', '/') + '.py')
+                if imp_path.exists():
+                    deps.add(str(imp_path))
+            dependencies[module.file_path] = deps
+
+        return dependencies
+
+    def get_call_graph(self, modules: List[ModuleInfo]) -> Dict[str, List[str]]:
+        """
+        Build function call graph (simplified).
+
+        Args:
+            modules: List of analyzed modules
+
+        Returns:
+            Dictionary mapping function names to called functions
+        """
+        call_graph = {}
+
+        # Collect all function names
+        all_functions = set()
+        for module in modules:
+            for func in module.functions:
+                all_functions.add(func.name)
+            for cls in module.classes:
+                for method in cls.methods:
+                    all_functions.add(f"{cls.name}.{method.name}")
+
+        # Analyze function bodies for calls
+        for module in modules:
+            for func in module.functions:
+                calls = self._find_function_calls(func.body_preview, all_functions)
+                if calls:
+                    call_graph[func.name] = calls
+
+            for cls in module.classes:
+                for method in cls.methods:
+                    calls = self._find_function_calls(method.body_preview, all_functions)
+                    if calls:
+                        call_graph[f"{cls.name}.{method.name}"] = calls
+
+        return call_graph
+
+    def _find_function_calls(self, code: str, known_functions: Set[str]) -> List[str]:
+        """Find function calls in code snippet."""
+        calls = []
+        for func_name in known_functions:
+            # Simple pattern matching for function calls
+            if re.search(rf'\b{re.escape(func_name)}\s*\(', code):
+                calls.append(func_name)
+        return calls
+
+    def generate_summary(self, modules: List[ModuleInfo]) -> Dict[str, Any]:
+        """
+        Generate summary statistics from analyzed modules.
+
+        Args:
+            modules: List of analyzed modules
+
+        Returns:
+            Summary dictionary
+        """
+        total_loc = sum(m.loc for m in modules)
+        total_functions = sum(len(m.functions) for m in modules)
+        total_classes = sum(len(m.classes) for m in modules)
+        total_methods = sum(
+            sum(len(cls.methods) for cls in m.classes)
+            for m in modules
+        )
+
+        # Count dependencies
+        all_deps = set()
+        for module in modules:
+            all_deps.update(module.dependencies)
+
+        # Find entry points (files with main or __main__)
+        entry_points = []
+        for module in modules:
+            if module.docstring and 'entry point' in module.docstring.lower():
+                entry_points.append(module.file_path)
+            for func in module.functions:
+                if func.name == 'main':
+                    entry_points.append(module.file_path)
+
+        return {
+            'total_files': len(modules),
+            'total_loc': total_loc,
+            'total_functions': total_functions,
+            'total_classes': total_classes,
+            'total_methods': total_methods,
+            'external_dependencies': sorted(all_deps),
+            'entry_points': entry_points,
+            'avg_loc_per_file': total_loc // len(modules) if modules else 0,
+        }
diff --git a/memov/docgen/diagram_generator.py b/memov/docgen/diagram_generator.py
new file mode 100644
index 0000000..513805b
--- /dev/null
+++ b/memov/docgen/diagram_generator.py
@@ -0,0 +1,425 @@
+"""
+Mermaid diagram generator for visualizing code structure and flow.
+
+Generates:
+- Architecture diagrams
+- Class diagrams
+- Sequence diagrams
+- Flow charts
+- Dependency graphs
+"""
+
+import logging
+from enum import Enum
+from typing import Dict, List, Optional, Set
+
+from memov.debugging.llm_client import LLMClient
+from memov.docgen.code_analyzer import ClassInfo, ModuleInfo
+
+logger = logging.getLogger(__name__)
+
+
+class DiagramType(Enum):
+    """Types of Mermaid diagrams."""
+    FLOWCHART = "flowchart"
+    CLASS_DIAGRAM = "classDiagram"
+    SEQUENCE = "sequenceDiagram"
+    ER_DIAGRAM = "erDiagram"
+    STATE = "stateDiagram"
+    GRAPH = "graph"
+
+
+class DiagramGenerator:
+    """Generates Mermaid diagrams from code analysis."""
+
+    def __init__(self, llm_client: Optional[LLMClient] = None):
+        """
+        Initialize diagram generator.
+
+        Args:
+            llm_client: Optional LLM client for intelligent diagram generation
+        """
+        self.llm_client = llm_client
+
+    def generate_architecture_diagram(
+        self,
+        modules: List[ModuleInfo],
+        title: str = "System Architecture"
+    ) -> str:
+        """
+        Generate architecture diagram showing module relationships.
+
+        Args:
+            modules: List of analyzed modules
+            title: Diagram title
+
+        Returns:
+            Mermaid diagram as string
+        """
+        lines = []
+        lines.append("```mermaid")
+        lines.append("graph TB")
+        lines.append(f"    title[\"{title}\"]")
+        lines.append("")
+
+        # Group modules by directory
+        module_groups: Dict[str, List[ModuleInfo]] = {}
+        for module in modules:
+            # Get parent directory
+            parts = module.file_path.split('/')
+            if len(parts) > 1:
+                group = parts[-2]
+            else:
+                group = "root"
+
+            if group not in module_groups:
+                module_groups[group] = []
+            module_groups[group].append(module)
+
+        # Create subgraphs for each directory
+        node_id = 0
+        node_map = {}
+
+        for group_name, group_modules in module_groups.items():
+            lines.append(f"    subgraph {group_name}[\"{group_name}\"]")
+
+            for module in group_modules:
+                module_name = module.file_path.split('/')[-1].replace('.py', '')
+                node_id += 1
+                node_name = f"mod{node_id}"
+                node_map[module.file_path] = node_name
+
+                # Count elements
+                num_classes = len(module.classes)
+                num_functions = len(module.functions)
+                label = f"{module_name}\\n{num_classes}C {num_functions}F"
+
+                lines.append(f"        {node_name}[\"{label}\"]")
+
+            lines.append("    end")
+            lines.append("")
+
+        # Add dependencies
+        lines.append("    %% Dependencies")
+        for module in modules:
+            if module.file_path not in node_map:
+                continue
+
+            source_node = node_map[module.file_path]
+
+            for dep in module.dependencies:
+                # Try to find matching module
+                for other in modules:
+                    if dep in other.file_path and other.file_path in node_map:
+                        target_node = node_map[other.file_path]
+                        lines.append(f"    {source_node} --> {target_node}")
+
+        lines.append("")
+        lines.append("    style title fill:#f9f,stroke:#333,stroke-width:2px")
+        lines.append("```")
+
+        return "\n".join(lines)
+
+    def generate_class_diagram(
+        self,
+        classes: List[ClassInfo],
+        title: str = "Class Diagram"
+    ) -> str:
+        """
+        Generate UML class diagram.
+
+        Args:
+            classes: List of class information
+            title: Diagram title
+
+        Returns:
+            Mermaid diagram as string
+        """
+        lines = []
+        lines.append("```mermaid")
+        lines.append("classDiagram")
+        lines.append(f"    %% {title}")
+        lines.append("")
+
+        for cls in classes:
+            # Add class
+            lines.append(f"    class {cls.name} {{")
+
+            # Add attributes
+            if cls.attributes:
+                for attr in cls.attributes[:10]:  # Limit to 10
+                    lines.append(f"        +{attr}")
+
+            # Add methods
+            if cls.methods:
+                for method in cls.methods[:10]:  # Limit to 10
+                    params = ", ".join(method.params) if method.params else ""
+                    return_type = f" {method.return_type}" if method.return_type else ""
+                    lines.append(f"        +{method.name}({params}){return_type}")
+
+            lines.append("    }")
+            lines.append("")
+
+            # Add inheritance relationships
+            if cls.bases:
+                for base in cls.bases:
+                    # Clean up base name
+                    base_name = base.split('.')[-1].split('(')[0]
+                    lines.append(f"    {base_name} <|-- {cls.name}")
+
+        lines.append("```")
+
+        return "\n".join(lines)
+
+    def generate_dependency_graph(
+        self,
+        dependencies: Dict[str, Set[str]],
+        title: str = "Dependency Graph"
+    ) -> str:
+        """
+        Generate dependency graph showing module dependencies.
+
+        Args:
+            dependencies: Dictionary mapping modules to their dependencies
+            title: Diagram title
+
+        Returns:
+            Mermaid diagram as string
+        """
+        lines = []
+        lines.append("```mermaid")
+        lines.append("graph LR")
+        lines.append(f"    title[\"{title}\"]")
+        lines.append("")
+
+        # Create nodes
+        all_modules = set(dependencies.keys())
+        for deps in dependencies.values():
+            all_modules.update(deps)
+
+        node_map = {}
+        for idx, module in enumerate(sorted(all_modules)):
+            module_name = module.split('/')[-1].replace('.py', '')
+            node_id = f"M{idx}"
+            node_map[module] = node_id
+            lines.append(f"    {node_id}[\"{module_name}\"]")
+
+        lines.append("")
+
+        # Add dependencies
+        for source, deps in dependencies.items():
+            if source not in node_map:
+                continue
+
+            source_id = node_map[source]
+            for dep in deps:
+                if dep in node_map:
+                    target_id = node_map[dep]
+                    lines.append(f"    {source_id} --> {target_id}")
+
+        lines.append("```")
+
+        return "\n".join(lines)
+
+    def generate_flowchart(
+        self,
+        steps: List[str],
+        title: str = "Process Flow"
+    ) -> str:
+        """
+        Generate flowchart from list of steps.
+
+        Args:
+            steps: List of process steps
+            title: Diagram title
+
+        Returns:
+            Mermaid diagram as string
+        """
+        lines = []
+        lines.append("```mermaid")
+        lines.append("flowchart TD")
+        lines.append(f"    A[Start: {title}]")
+
+        for idx, step in enumerate(steps):
+            current = chr(66 + idx)  # B, C, D, ...
+            next_node = chr(67 + idx) if idx < len(steps) - 1 else "Z"
+
+            # Determine node shape based on content
+            if "decision" in step.lower() or "if" in step.lower() or "?" in step:
+                lines.append(f"    {current}{{{step}}}")
+            elif "end" in step.lower() or "return" in step.lower():
+                lines.append(f"    {current}([{step}])")
+            else:
+                lines.append(f"    {current}[{step}]")
+
+            # Add connection
+            if idx < len(steps) - 1:
+                lines.append(f"    {current} --> {next_node}")
+            else:
+                lines.append(f"    {current} --> Z[End]")
+
+        lines.append("```")
+
+        return "\n".join(lines)
+
+    def generate_sequence_diagram(
+        self,
+        interactions: List[tuple[str, str, str]],
+        title: str = "Sequence Diagram"
+    ) -> str:
+        """
+        Generate sequence diagram showing interactions.
+
+        Args:
+            interactions: List of (actor1, actor2, message) tuples
+            title: Diagram title
+
+        Returns:
+            Mermaid diagram as string
+        """
+        lines = []
+        lines.append("```mermaid")
+        lines.append("sequenceDiagram")
+        lines.append(f"    title {title}")
+        lines.append("")
+
+        # Collect all actors
+        actors = set()
+        for actor1, actor2, _ in interactions:
+            actors.add(actor1)
+            actors.add(actor2)
+
+        # Declare participants
+        for actor in sorted(actors):
+            lines.append(f"    participant {actor}")
+
+        lines.append("")
+
+        # Add interactions
+        for actor1, actor2, message in interactions:
+            lines.append(f"    {actor1}->>+{actor2}: {message}")
+
+        lines.append("```")
+
+        return "\n".join(lines)
+
+    def generate_with_llm(
+        self,
+        diagram_type: DiagramType,
+        context: Dict,
+        prompt: Optional[str] = None
+    ) -> str:
+        """
+        Generate diagram using LLM for intelligent interpretation.
+
+        Args:
+            diagram_type: Type of diagram to generate
+            context: Context information for diagram generation
+            prompt: Optional custom prompt
+
+        Returns:
+            Mermaid diagram as string
+        """
+        if not self.llm_client:
+            raise ValueError("LLM client required for intelligent diagram generation")
+
+        if prompt is None:
+            prompt = self._build_diagram_prompt(diagram_type, context)
+
+        system_prompt = """You are an expert in creating Mermaid diagrams for software documentation.
+Generate clear, well-structured Mermaid diagrams based on the provided information.
+
+Guidelines:
+- Use proper Mermaid syntax
+- Keep diagrams clear and readable
+- Limit complexity (max 20 nodes for graphs)
+- Use appropriate node shapes and styles
+- Add clear labels and titles
+- Ensure diagram is properly formatted with ```mermaid markers"""
+
+        try:
+            response = self.llm_client.query_single(
+                model=self.llm_client.models[0],
+                prompt=prompt,
+                system_prompt=system_prompt,
+                temperature=0.5,
+                max_tokens=2000
+            )
+
+            if response.get('error'):
+                logger.error(f"LLM error: {response['error']}")
+                return self._generate_fallback_diagram(diagram_type, context)
+
+            content = response.get('content', '')
+
+            # Extract mermaid code block if present
+            if '```mermaid' in content:
+                return content
+            elif '```' in content:
+                # Wrap in mermaid block
+                code = content.split('```')[1]
+                return f"```mermaid\n{code}\n```"
+            else:
+                return f"```mermaid\n{content}\n```"
+
+        except Exception as e:
+            logger.error(f"Error generating diagram with LLM: {e}")
+            return self._generate_fallback_diagram(diagram_type, context)
+
+    def _build_diagram_prompt(
+        self,
+        diagram_type: DiagramType,
+        context: Dict
+    ) -> str:
+        """Build prompt for LLM diagram generation."""
+        lines = []
+
+        lines.append(f"Generate a {diagram_type.value} Mermaid diagram based on the following information:")
+        lines.append("")
+
+        if 'modules' in context:
+            modules = context['modules']
+            lines.append(f"Number of modules: {len(modules)}")
+            lines.append("Module names:")
+            for module in modules[:10]:
+                name = module.file_path.split('/')[-1]
+                lines.append(f"- {name} ({len(module.functions)}F, {len(module.classes)}C)")
+            lines.append("")
+
+        if 'classes' in context:
+            classes = context['classes']
+            lines.append(f"Number of classes: {len(classes)}")
+            lines.append("Class names:")
+            for cls in classes[:10]:
+                lines.append(f"- {cls.name} (methods: {', '.join([m.name for m in cls.methods[:3]])})")
+            lines.append("")
+
+        if 'summary' in context:
+            summary = context['summary']
+            lines.append("Project summary:")
+            for key, value in summary.items():
+                lines.append(f"- {key}: {value}")
+            lines.append("")
+
+        lines.append("Please generate a clear and well-structured Mermaid diagram.")
+        lines.append("Include the ```mermaid code block markers in your response.")
+
+        return "\n".join(lines)
+
+    def _generate_fallback_diagram(
+        self,
+        diagram_type: DiagramType,
+        context: Dict
+    ) -> str:
+        """Generate basic diagram as fallback."""
+        if diagram_type == DiagramType.CLASS_DIAGRAM and 'classes' in context:
+            return self.generate_class_diagram(context['classes'])
+        elif diagram_type == DiagramType.GRAPH and 'modules' in context:
+            return self.generate_architecture_diagram(context['modules'])
+        else:
+            # Generic flowchart
+            return self.generate_flowchart(
+                steps=["Start", "Process", "Decision?", "End"],
+                title="Process Flow"
+            )
diff --git a/memov/docgen/doc_generator.py b/memov/docgen/doc_generator.py
new file mode 100644
index 0000000..6da2cdc
--- /dev/null
+++ b/memov/docgen/doc_generator.py
@@ -0,0 +1,558 @@
+"""
+Document generator using LLM to create comprehensive documentation.
+
+Supports:
+- Multiple documentation structures (README, API, Tutorial, etc.)
+- Commit-level and branch-level documentation
+- Integration with code analysis
+"""
+
+import logging
+from dataclasses import dataclass, field
+from datetime import datetime
+from enum import Enum
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from memov.debugging.llm_client import LLMClient
+from memov.docgen.code_analyzer import CodeAnalyzer, ModuleInfo
+
+logger = logging.getLogger(__name__)
+
+
+class DocType(Enum):
+    """Types of documentation that can be generated."""
+    README = "readme"
+    API_REFERENCE = "api_reference"
+    ARCHITECTURE = "architecture"
+    TUTORIAL = "tutorial"
+    CHANGELOG = "changelog"
+    FEATURE = "feature"
+
+
+@dataclass
+class DocumentStructure:
+    """Template structure for generated documentation."""
+    doc_type: DocType
+    sections: List[str]
+    templates: Dict[str, str] = field(default_factory=dict)
+
+    @staticmethod
+    def get_readme_structure() -> 'DocumentStructure':
+        """Get structure for README documentation."""
+        return DocumentStructure(
+            doc_type=DocType.README,
+            sections=[
+                "title",
+                "overview",
+                "features",
+                "installation",
+                "quick_start",
+                "usage",
+                "api_overview",
+                "architecture",
+                "contributing",
+                "license"
+            ],
+            templates={
+                "title": "# {project_name}\n\n{description}",
+                "overview": "## Overview\n\n{overview_text}",
+                "features": "## Features\n\n{feature_list}",
+                "installation": "## Installation\n\n```bash\n{install_commands}\n```",
+                "quick_start": "## Quick Start\n\n{quick_start_example}",
+                "usage": "## Usage\n\n{usage_examples}",
+                "api_overview": "## API Overview\n\n{api_summary}",
+                "architecture": "## Architecture\n\n{architecture_diagram}",
+            }
+        )
+
+    @staticmethod
+    def get_api_structure() -> 'DocumentStructure':
+        """Get structure for API reference documentation."""
+        return DocumentStructure(
+            doc_type=DocType.API_REFERENCE,
+            sections=[
+                "title",
+                "overview",
+                "modules",
+                "classes",
+                "functions",
+                "examples"
+            ],
+            templates={
+                "title": "# API Reference\n\n",
+                "modules": "## Modules\n\n{module_list}",
+                "classes": "## Classes\n\n{class_descriptions}",
+                "functions": "## Functions\n\n{function_descriptions}",
+            }
+        )
+
+    @staticmethod
+    def get_feature_structure() -> 'DocumentStructure':
+        """Get structure for feature documentation."""
+        return DocumentStructure(
+            doc_type=DocType.FEATURE,
+            sections=[
+                "title",
+                "overview",
+                "motivation",
+                "design",
+                "implementation",
+                "usage",
+                "testing",
+                "related_changes"
+            ],
+            templates={
+                "title": "# Feature: {feature_name}\n\n",
+                "overview": "## Overview\n\n{overview_text}",
+                "motivation": "## Motivation\n\n{motivation_text}",
+                "design": "## Design\n\n{design_details}",
+                "implementation": "## Implementation\n\n{implementation_details}",
+                "usage": "## Usage\n\n{usage_examples}",
+            }
+        )
+
+    @staticmethod
+    def get_architecture_structure() -> 'DocumentStructure':
+        """Get structure for architecture documentation."""
+        return DocumentStructure(
+            doc_type=DocType.ARCHITECTURE,
+            sections=[
+                "title",
+                "overview",
+                "components",
+                "data_flow",
+                "diagrams",
+                "design_patterns",
+                "dependencies"
+            ],
+            templates={
+                "title": "# Architecture Documentation\n\n",
+                "overview": "## Overview\n\n{overview_text}",
+                "components": "## Components\n\n{component_list}",
+                "data_flow": "## Data Flow\n\n{data_flow_diagram}",
+                "diagrams": "## Architecture Diagrams\n\n{diagrams}",
+            }
+        )
+
+
+@dataclass
+class GeneratedDocument:
+    """A generated documentation document."""
+    doc_type: DocType
+    title: str
+    content: str
+    metadata: Dict[str, Any]
+    timestamp: datetime = field(default_factory=datetime.now)
+
+
+class DocumentGenerator:
+    """Generates documentation using LLM and code analysis."""
+
+    def __init__(
+        self,
+        code_analyzer: CodeAnalyzer,
+        llm_client: Optional[LLMClient] = None,
+        model: str = "gpt-4o-mini"
+    ):
+        """
+        Initialize document generator.
+
+        Args:
+            code_analyzer: CodeAnalyzer instance
+            llm_client: LLMClient instance (optional)
+            model: Model to use for generation
+        """
+        self.code_analyzer = code_analyzer
+        self.model = model
+
+        if llm_client:
+            self.llm_client = llm_client
+        else:
+            try:
+                self.llm_client = LLMClient(models=[model])
+            except ImportError:
+                logger.warning("LiteLLM not available. Using fallback mode.")
+                self.llm_client = None
+
+    def generate_for_commit(
+        self,
+        commit_hash: str,
+        changed_files: List[str],
+        commit_message: str,
+        doc_type: DocType = DocType.FEATURE
+    ) -> GeneratedDocument:
+        """
+        Generate documentation for a specific commit.
+
+        Args:
+            commit_hash: Commit hash
+            changed_files: List of files changed in the commit
+            commit_message: Commit message
+            doc_type: Type of documentation to generate
+
+        Returns:
+            GeneratedDocument object
+        """
+        logger.info(f"Generating {doc_type.value} documentation for commit {commit_hash[:8]}")
+
+        # Analyze changed files
+        modules = self.code_analyzer.analyze_files(changed_files)
+
+        # Get appropriate structure
+        structure = self._get_structure(doc_type)
+
+        # Build context for LLM
+        context = self._build_commit_context(
+            commit_hash=commit_hash,
+            commit_message=commit_message,
+            modules=modules,
+            changed_files=changed_files
+        )
+
+        # Generate documentation content
+        content = self._generate_content(structure, context)
+
+        return GeneratedDocument(
+            doc_type=doc_type,
+            title=f"Commit {commit_hash[:8]}: {commit_message.splitlines()[0][:50]}",
+            content=content,
+            metadata={
+                'commit_hash': commit_hash,
+                'commit_message': commit_message,
+                'changed_files': changed_files,
+                'num_files': len(changed_files),
+            }
+        )
+
+    def generate_for_branch(
+        self,
+        branch_name: str,
+        directory: str,
+        doc_type: DocType = DocType.README,
+        commit_range: Optional[tuple[str, str]] = None
+    ) -> GeneratedDocument:
+        """
+        Generate documentation for a branch.
+
+        Args:
+            branch_name: Branch name
+            directory: Directory to analyze
+            doc_type: Type of documentation to generate
+            commit_range: Optional tuple of (start_commit, end_commit)
+
+        Returns:
+            GeneratedDocument object
+        """
+        logger.info(f"Generating {doc_type.value} documentation for branch {branch_name}")
+
+        # Analyze all files in directory
+        modules = self.code_analyzer.analyze_directory(directory)
+
+        # Get appropriate structure
+        structure = self._get_structure(doc_type)
+
+        # Build context for LLM
+        context = self._build_branch_context(
+            branch_name=branch_name,
+            modules=modules,
+            commit_range=commit_range
+        )
+
+        # Generate documentation content
+        content = self._generate_content(structure, context)
+
+        return GeneratedDocument(
+            doc_type=doc_type,
+            title=f"Branch: {branch_name}",
+            content=content,
+            metadata={
+                'branch_name': branch_name,
+                'num_modules': len(modules),
+                'total_loc': sum(m.loc for m in modules),
+            }
+        )
+
+    def generate_for_repository(
+        self,
+        directory: str,
+        doc_types: List[DocType] = None
+    ) -> List[GeneratedDocument]:
+        """
+        Generate comprehensive documentation for entire repository.
+
+        Args:
+            directory: Repository directory
+            doc_types: List of documentation types to generate
+
+        Returns:
+            List of GeneratedDocument objects
+        """
+        if doc_types is None:
+            doc_types = [DocType.README, DocType.API_REFERENCE, DocType.ARCHITECTURE]
+
+        logger.info(f"Generating repository documentation: {doc_types}")
+
+        # Analyze entire repository
+        modules = self.code_analyzer.analyze_directory(directory)
+
+        documents = []
+        for doc_type in doc_types:
+            doc = self.generate_for_branch(
+                branch_name="main",
+                directory=directory,
+                doc_type=doc_type
+            )
+            documents.append(doc)
+
+        return documents
+
+    def _get_structure(self, doc_type: DocType) -> DocumentStructure:
+        """Get document structure for given type."""
+        structure_map = {
+            DocType.README: DocumentStructure.get_readme_structure(),
+            DocType.API_REFERENCE: DocumentStructure.get_api_structure(),
+            DocType.FEATURE: DocumentStructure.get_feature_structure(),
+            DocType.ARCHITECTURE: DocumentStructure.get_architecture_structure(),
+        }
+        return structure_map.get(doc_type, DocumentStructure.get_readme_structure())
+
+    def _build_commit_context(
+        self,
+        commit_hash: str,
+        commit_message: str,
+        modules: List[ModuleInfo],
+        changed_files: List[str]
+    ) -> Dict[str, Any]:
+        """Build context for commit-level documentation."""
+        # Extract code information
+        functions = []
+        classes = []
+        for module in modules:
+            functions.extend(module.functions)
+            classes.extend(module.classes)
+
+        # Build context dictionary
+        context = {
+            'commit_hash': commit_hash,
+            'commit_message': commit_message,
+            'changed_files': changed_files,
+            'num_functions': len(functions),
+            'num_classes': len(classes),
+            'function_names': [f.name for f in functions],
+            'class_names': [c.name for c in classes],
+            'modules': modules,
+        }
+
+        # Add detailed function/class info
+        if functions:
+            context['main_functions'] = [
+                {
+                    'name': f.name,
+                    'params': f.params,
+                    'return_type': f.return_type,
+                    'docstring': f.docstring
+                }
+                for f in functions[:5]  # First 5 functions
+            ]
+
+        if classes:
+            context['main_classes'] = [
+                {
+                    'name': c.name,
+                    'methods': [m.name for m in c.methods],
+                    'docstring': c.docstring
+                }
+                for c in classes[:5]  # First 5 classes
+            ]
+
+        return context
+
+    def _build_branch_context(
+        self,
+        branch_name: str,
+        modules: List[ModuleInfo],
+        commit_range: Optional[tuple[str, str]] = None
+    ) -> Dict[str, Any]:
+        """Build context for branch-level documentation."""
+        # Generate summary
+        summary = self.code_analyzer.generate_summary(modules)
+
+        # Build dependency graph
+        dependencies = self.code_analyzer.get_dependencies(modules)
+
+        # Extract all functions and classes
+        all_functions = []
+        all_classes = []
+        for module in modules:
+            all_functions.extend(module.functions)
+            all_classes.extend(module.classes)
+
+        context = {
+            'branch_name': branch_name,
+            'summary': summary,
+            'dependencies': dependencies,
+            'modules': modules,
+            'all_functions': all_functions,
+            'all_classes': all_classes,
+            'commit_range': commit_range,
+        }
+
+        return context
+
+    def _generate_content(
+        self,
+        structure: DocumentStructure,
+        context: Dict[str, Any]
+    ) -> str:
+        """Generate documentation content using LLM."""
+        if not self.llm_client:
+            # Fallback: generate basic structure without LLM
+            return self._generate_fallback_content(structure, context)
+
+        # Build prompt for LLM
+        prompt = self._build_prompt(structure, context)
+
+        system_prompt = """You are an expert technical writer and software documentation specialist.
+Your task is to generate clear, comprehensive, and well-structured documentation based on code analysis.
+
+Guidelines:
+- Write in clear, concise language
+- Include code examples where appropriate
+- Use proper markdown formatting
+- Structure information logically
+- Focus on practical usage
+- Explain complex concepts simply"""
+
+        try:
+            # Query LLM
+            response = self.llm_client.query_single(
+                model=self.model,
+                prompt=prompt,
+                system_prompt=system_prompt,
+                temperature=0.7,
+                max_tokens=4000
+            )
+
+            if response.get('error'):
+                logger.error(f"LLM error: {response['error']}")
+                return self._generate_fallback_content(structure, context)
+
+            return response.get('content', '')
+
+        except Exception as e:
+            logger.error(f"Error generating content: {e}")
+            return self._generate_fallback_content(structure, context)
+
+    def _build_prompt(
+        self,
+        structure: DocumentStructure,
+        context: Dict[str, Any]
+    ) -> str:
+        """Build prompt for LLM based on structure and context."""
+        lines = []
+
+        lines.append(f"Generate {structure.doc_type.value} documentation with the following structure:")
+        lines.append("")
+        lines.append("Required sections:")
+        for section in structure.sections:
+            lines.append(f"- {section}")
+        lines.append("")
+
+        lines.append("Code Analysis Context:")
+        lines.append("")
+
+        # Add relevant context based on what's available
+        if 'commit_message' in context:
+            lines.append(f"Commit Message: {context['commit_message']}")
+            lines.append(f"Changed Files: {', '.join(context.get('changed_files', []))}")
+            lines.append("")
+
+        if 'branch_name' in context:
+            lines.append(f"Branch: {context['branch_name']}")
+            lines.append("")
+
+        if 'summary' in context:
+            summary = context['summary']
+            lines.append("Project Summary:")
+            lines.append(f"- Total Files: {summary.get('total_files', 0)}")
+            lines.append(f"- Total LOC: {summary.get('total_loc', 0)}")
+            lines.append(f"- Functions: {summary.get('total_functions', 0)}")
+            lines.append(f"- Classes: {summary.get('total_classes', 0)}")
+            lines.append("")
+
+        # Add function details
+        if 'main_functions' in context:
+            lines.append("Key Functions:")
+            for func in context['main_functions'][:3]:
+                lines.append(f"- {func['name']}({', '.join(func['params'])})")
+                if func.get('docstring'):
+                    lines.append(f"  {func['docstring'][:100]}")
+            lines.append("")
+
+        # Add class details
+        if 'main_classes' in context:
+            lines.append("Key Classes:")
+            for cls in context['main_classes'][:3]:
+                lines.append(f"- {cls['name']}")
+                if cls.get('methods'):
+                    lines.append(f"  Methods: {', '.join(cls['methods'][:5])}")
+            lines.append("")
+
+        lines.append("Please generate comprehensive documentation following the structure above.")
+        lines.append("Use proper markdown formatting including headers, code blocks, and lists.")
+
+        return "\n".join(lines)
+
+    def _generate_fallback_content(
+        self,
+        structure: DocumentStructure,
+        context: Dict[str, Any]
+    ) -> str:
+        """Generate basic documentation without LLM."""
+        lines = []
+
+        # Title
+        if 'commit_message' in context:
+            title = f"# Commit Documentation\n\n**Commit**: {context['commit_hash'][:8]}\n"
+            title += f"**Message**: {context['commit_message']}\n"
+            lines.append(title)
+        elif 'branch_name' in context:
+            lines.append(f"# {structure.doc_type.value.replace('_', ' ').title()}\n")
+            lines.append(f"**Branch**: {context['branch_name']}\n")
+
+        # Summary
+        if 'summary' in context:
+            summary = context['summary']
+            lines.append("## Summary\n")
+            lines.append(f"- Files: {summary.get('total_files', 0)}")
+            lines.append(f"- Lines of Code: {summary.get('total_loc', 0)}")
+            lines.append(f"- Functions: {summary.get('total_functions', 0)}")
+            lines.append(f"- Classes: {summary.get('total_classes', 0)}")
+            lines.append("")
+
+        # Functions
+        if 'main_functions' in context:
+            lines.append("## Functions\n")
+            for func in context['main_functions'][:10]:
+                lines.append(f"### `{func['name']}`\n")
+                if func.get('params'):
+                    lines.append(f"**Parameters**: `{', '.join(func['params'])}`\n")
+                if func.get('return_type'):
+                    lines.append(f"**Returns**: `{func['return_type']}`\n")
+                if func.get('docstring'):
+                    lines.append(f"{func['docstring']}\n")
+                lines.append("")
+
+        # Classes
+        if 'main_classes' in context:
+            lines.append("## Classes\n")
+            for cls in context['main_classes'][:10]:
+                lines.append(f"### `{cls['name']}`\n")
+                if cls.get('methods'):
+                    lines.append(f"**Methods**: {', '.join(cls['methods'])}\n")
+                if cls.get('docstring'):
+                    lines.append(f"{cls['docstring']}\n")
+                lines.append("")
+
+        return "\n".join(lines)
diff --git a/memov/docgen/git_utils.py b/memov/docgen/git_utils.py
new file mode 100644
index 0000000..890b648
--- /dev/null
+++ b/memov/docgen/git_utils.py
@@ -0,0 +1,405 @@
+"""
+Git utilities for analyzing commits and branches.
+
+Provides functions to:
+- Get changed files from commits
+- Get commit messages and metadata
+- Analyze commit ranges
+- Get branch information
+"""
+
+import logging
+import subprocess
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Tuple
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CommitInfo:
+    """Information about a Git commit."""
+    hash: str
+    author: str
+    date: datetime
+    message: str
+    changed_files: List[str] = field(default_factory=list)
+    additions: int = 0
+    deletions: int = 0
+
+
+class GitUtils:
+    """Utilities for Git repository operations."""
+
+    def __init__(self, repo_path: str = "."):
+        """
+        Initialize Git utilities.
+
+        Args:
+            repo_path: Path to the Git repository
+        """
+        self.repo_path = Path(repo_path).resolve()
+        self._validate_git_repo()
+
+    def _validate_git_repo(self) -> None:
+        """Check if the path is a valid Git repository."""
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--git-dir"],
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            logger.info(f"Git repository found at {self.repo_path}")
+        except subprocess.CalledProcessError:
+            raise ValueError(f"Not a Git repository: {self.repo_path}")
+
+    def get_commit_info(self, commit_hash: str) -> Optional[CommitInfo]:
+        """
+        Get detailed information about a commit.
+
+        Args:
+            commit_hash: Commit hash or reference (e.g., HEAD, branch name)
+
+        Returns:
+            CommitInfo object or None if commit not found
+        """
+        try:
+            # Get commit metadata
+            result = subprocess.run(
+                [
+                    "git", "log", "-1",
+                    "--format=%H%n%an%n%aI%n%B",
+                    commit_hash
+                ],
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+
+            lines = result.stdout.strip().split('\n')
+            if len(lines) < 4:
+                logger.error(f"Invalid commit format for {commit_hash}")
+                return None
+
+            full_hash = lines[0]
+            author = lines[1]
+            date_str = lines[2]
+            message = '\n'.join(lines[3:])
+
+            # Parse date
+            date = datetime.fromisoformat(date_str.replace('Z', '+00:00'))
+
+            # Get changed files
+            changed_files = self.get_changed_files(commit_hash)
+
+            # Get stats
+            stats = self.get_commit_stats(commit_hash)
+
+            return CommitInfo(
+                hash=full_hash,
+                author=author,
+                date=date,
+                message=message,
+                changed_files=changed_files,
+                additions=stats.get('additions', 0),
+                deletions=stats.get('deletions', 0)
+            )
+
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Failed to get commit info for {commit_hash}: {e}")
+            return None
+
+    def get_changed_files(
+        self,
+        commit_hash: str,
+        file_extensions: Optional[List[str]] = None
+    ) -> List[str]:
+        """
+        Get list of files changed in a commit.
+
+        Args:
+            commit_hash: Commit hash or reference
+            file_extensions: Optional list of file extensions to filter (e.g., ['.py', '.js'])
+
+        Returns:
+            List of absolute file paths
+        """
+        try:
+            # Get changed files relative to parent
+            result = subprocess.run(
+                ["git", "diff-tree", "--no-commit-id", "--name-only", "-r", commit_hash],
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+
+            files = []
+            for file_path in result.stdout.strip().split('\n'):
+                if not file_path:
+                    continue
+
+                # Convert to absolute path
+                abs_path = (self.repo_path / file_path).resolve()
+
+                # Filter by extension if specified
+                if file_extensions:
+                    if not any(str(abs_path).endswith(ext) for ext in file_extensions):
+                        continue
+
+                # Only include existing files
+                if abs_path.exists():
+                    files.append(str(abs_path))
+
+            return files
+
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Failed to get changed files for {commit_hash}: {e}")
+            return []
+
+    def get_commit_stats(self, commit_hash: str) -> Dict[str, int]:
+        """
+        Get statistics for a commit (additions, deletions).
+
+        Args:
+            commit_hash: Commit hash or reference
+
+        Returns:
+            Dictionary with 'additions' and 'deletions' keys
+        """
+        try:
+            result = subprocess.run(
+                ["git", "show", "--shortstat", "--format=", commit_hash],
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+
+            output = result.stdout.strip()
+            stats = {'additions': 0, 'deletions': 0}
+
+            # Parse output like: "2 files changed, 10 insertions(+), 5 deletions(-)"
+            if 'insertion' in output:
+                additions = output.split('insertion')[0].split()[-1]
+                stats['additions'] = int(additions)
+            if 'deletion' in output:
+                deletions = output.split('deletion')[0].split()[-1]
+                stats['deletions'] = int(deletions)
+
+            return stats
+
+        except (subprocess.CalledProcessError, ValueError) as e:
+            logger.error(f"Failed to get commit stats for {commit_hash}: {e}")
+            return {'additions': 0, 'deletions': 0}
+
+    def get_commits_in_range(
+        self,
+        start_ref: str,
+        end_ref: str = "HEAD"
+    ) -> List[CommitInfo]:
+        """
+        Get all commits in a range.
+
+        Args:
+            start_ref: Starting commit reference
+            end_ref: Ending commit reference (default: HEAD)
+
+        Returns:
+            List of CommitInfo objects
+        """
+        try:
+            # Get commit hashes in range
+            result = subprocess.run(
+                ["git", "rev-list", f"{start_ref}..{end_ref}"],
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+
+            commits = []
+            for commit_hash in result.stdout.strip().split('\n'):
+                if commit_hash:
+                    commit_info = self.get_commit_info(commit_hash)
+                    if commit_info:
+                        commits.append(commit_info)
+
+            return commits
+
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Failed to get commits in range {start_ref}..{end_ref}: {e}")
+            return []
+
+    def get_branch_commits(
+        self,
+        branch_name: str,
+        base_branch: str = "main"
+    ) -> List[CommitInfo]:
+        """
+        Get commits unique to a branch (not in base branch).
+
+        Args:
+            branch_name: Branch to analyze
+            base_branch: Base branch to compare against
+
+        Returns:
+            List of CommitInfo objects
+        """
+        return self.get_commits_in_range(base_branch, branch_name)
+
+    def get_current_branch(self) -> str:
+        """
+        Get the name of the current branch.
+
+        Returns:
+            Branch name or empty string if detached HEAD
+        """
+        try:
+            result = subprocess.run(
+                ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            branch = result.stdout.strip()
+            return branch if branch != "HEAD" else ""
+
+        except subprocess.CalledProcessError:
+            return ""
+
+    def get_file_content_at_commit(
+        self,
+        file_path: str,
+        commit_hash: str
+    ) -> Optional[str]:
+        """
+        Get file content at a specific commit.
+
+        Args:
+            file_path: Relative path to file from repo root
+            commit_hash: Commit hash or reference
+
+        Returns:
+            File content as string or None if not found
+        """
+        try:
+            result = subprocess.run(
+                ["git", "show", f"{commit_hash}:{file_path}"],
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            return result.stdout
+
+        except subprocess.CalledProcessError:
+            logger.warning(f"Could not get {file_path} at {commit_hash}")
+            return None
+
+    def get_commit_diff(
+        self,
+        commit_hash: str,
+        file_path: Optional[str] = None
+    ) -> str:
+        """
+        Get diff for a commit.
+
+        Args:
+            commit_hash: Commit hash or reference
+            file_path: Optional specific file to get diff for
+
+        Returns:
+            Diff as string
+        """
+        try:
+            cmd = ["git", "show", commit_hash]
+            if file_path:
+                cmd.append("--")
+                cmd.append(file_path)
+
+            result = subprocess.run(
+                cmd,
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            return result.stdout
+
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Failed to get diff for {commit_hash}: {e}")
+            return ""
+
+    def get_all_branches(self) -> List[str]:
+        """
+        Get list of all branches in the repository.
+
+        Returns:
+            List of branch names
+        """
+        try:
+            result = subprocess.run(
+                ["git", "branch", "--format=%(refname:short)"],
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            branches = [b.strip() for b in result.stdout.strip().split('\n') if b.strip()]
+            return branches
+
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Failed to get branches: {e}")
+            return []
+
+    def get_files_in_branch(
+        self,
+        branch_name: str,
+        file_extensions: Optional[List[str]] = None
+    ) -> List[str]:
+        """
+        Get all files in a branch.
+
+        Args:
+            branch_name: Branch name
+            file_extensions: Optional list of file extensions to filter
+
+        Returns:
+            List of absolute file paths
+        """
+        try:
+            result = subprocess.run(
+                ["git", "ls-tree", "-r", "--name-only", branch_name],
+                cwd=self.repo_path,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+
+            files = []
+            for file_path in result.stdout.strip().split('\n'):
+                if not file_path:
+                    continue
+
+                # Convert to absolute path
+                abs_path = (self.repo_path / file_path).resolve()
+
+                # Filter by extension if specified
+                if file_extensions:
+                    if not any(str(abs_path).endswith(ext) for ext in file_extensions):
+                        continue
+
+                files.append(str(abs_path))
+
+            return files
+
+        except subprocess.CalledProcessError as e:
+            logger.error(f"Failed to get files in branch {branch_name}: {e}")
+            return []
diff --git a/memov/docgen/preview_server.py b/memov/docgen/preview_server.py
new file mode 100644
index 0000000..35b0efc
--- /dev/null
+++ b/memov/docgen/preview_server.py
@@ -0,0 +1,542 @@
+"""
+Web server for previewing generated documentation with Mermaid support.
+
+Features:
+- Markdown rendering
+- Mermaid diagram rendering
+- Syntax highlighting
+- File browser navigation
+- Responsive design
+"""
+
+import logging
+from pathlib import Path
+from typing import Optional
+from urllib.parse import unquote
+
+from starlette.applications import Starlette
+from starlette.responses import HTMLResponse, Response
+from starlette.routing import Route
+from starlette.staticfiles import StaticFiles
+import uvicorn
+
+logger = logging.getLogger(__name__)
+
+
+HTML_TEMPLATE = """<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>{title}</title>
+
+    <!-- Mermaid JS -->
+    <script type="module">
+        import mermaid from 'https://cdn.jsdelivr.net/npm/mermaid@10/dist/mermaid.esm.min.mjs';
+        mermaid.initialize({{
+            startOnLoad: true,
+            theme: 'default',
+            securityLevel: 'loose',
+        }});
+    </script>
+
+    <!-- Marked.js for Markdown rendering -->
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+
+    <!-- Highlight.js for syntax highlighting -->
+    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/highlight.js@11.9.0/styles/github.min.css">
+    <script src="https://cdn.jsdelivr.net/npm/highlight.js@11.9.0/es/highlight.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/highlight.js@11.9.0/es/languages/python.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/highlight.js@11.9.0/es/languages/javascript.min.js"></script>
+
+    <style>
+        * {{
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }}
+
+        body {{
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
+                'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue', sans-serif;
+            line-height: 1.6;
+            color: #333;
+            background: #f5f5f5;
+        }}
+
+        .container {{
+            display: flex;
+            min-height: 100vh;
+        }}
+
+        .sidebar {{
+            width: 280px;
+            background: #fff;
+            border-right: 1px solid #e1e4e8;
+            overflow-y: auto;
+            position: fixed;
+            height: 100vh;
+        }}
+
+        .sidebar-header {{
+            padding: 20px;
+            background: #0366d6;
+            color: white;
+        }}
+
+        .sidebar-header h1 {{
+            font-size: 20px;
+            font-weight: 600;
+        }}
+
+        .nav-list {{
+            list-style: none;
+            padding: 10px 0;
+        }}
+
+        .nav-item {{
+            padding: 8px 20px;
+            cursor: pointer;
+            transition: background 0.2s;
+        }}
+
+        .nav-item:hover {{
+            background: #f6f8fa;
+        }}
+
+        .nav-item a {{
+            color: #0366d6;
+            text-decoration: none;
+            display: block;
+        }}
+
+        .nav-item.active {{
+            background: #e1ecf7;
+            border-left: 3px solid #0366d6;
+        }}
+
+        .main-content {{
+            flex: 1;
+            margin-left: 280px;
+            padding: 40px;
+            max-width: 1200px;
+        }}
+
+        .content-card {{
+            background: white;
+            border-radius: 8px;
+            padding: 40px;
+            box-shadow: 0 1px 3px rgba(0,0,0,0.1);
+        }}
+
+        /* Markdown Styles */
+        .markdown-body {{
+            font-size: 16px;
+        }}
+
+        .markdown-body h1 {{
+            font-size: 32px;
+            font-weight: 600;
+            margin: 24px 0 16px;
+            padding-bottom: 8px;
+            border-bottom: 1px solid #e1e4e8;
+        }}
+
+        .markdown-body h2 {{
+            font-size: 24px;
+            font-weight: 600;
+            margin: 24px 0 16px;
+            padding-bottom: 8px;
+            border-bottom: 1px solid #e1e4e8;
+        }}
+
+        .markdown-body h3 {{
+            font-size: 20px;
+            font-weight: 600;
+            margin: 16px 0;
+        }}
+
+        .markdown-body p {{
+            margin: 16px 0;
+        }}
+
+        .markdown-body ul, .markdown-body ol {{
+            margin: 16px 0;
+            padding-left: 32px;
+        }}
+
+        .markdown-body li {{
+            margin: 8px 0;
+        }}
+
+        .markdown-body pre {{
+            background: #f6f8fa;
+            border-radius: 6px;
+            padding: 16px;
+            overflow-x: auto;
+            margin: 16px 0;
+        }}
+
+        .markdown-body code {{
+            background: #f6f8fa;
+            padding: 2px 6px;
+            border-radius: 3px;
+            font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+            font-size: 14px;
+        }}
+
+        .markdown-body pre code {{
+            background: transparent;
+            padding: 0;
+        }}
+
+        .markdown-body blockquote {{
+            border-left: 4px solid #0366d6;
+            padding-left: 16px;
+            margin: 16px 0;
+            color: #6a737d;
+        }}
+
+        .markdown-body table {{
+            border-collapse: collapse;
+            width: 100%;
+            margin: 16px 0;
+        }}
+
+        .markdown-body th, .markdown-body td {{
+            border: 1px solid #e1e4e8;
+            padding: 8px 12px;
+        }}
+
+        .markdown-body th {{
+            background: #f6f8fa;
+            font-weight: 600;
+        }}
+
+        .markdown-body a {{
+            color: #0366d6;
+            text-decoration: none;
+        }}
+
+        .markdown-body a:hover {{
+            text-decoration: underline;
+        }}
+
+        /* Mermaid diagram styling */
+        .mermaid {{
+            margin: 24px 0;
+            text-align: center;
+        }}
+
+        .breadcrumb {{
+            margin-bottom: 20px;
+            font-size: 14px;
+            color: #6a737d;
+        }}
+
+        .breadcrumb a {{
+            color: #0366d6;
+            text-decoration: none;
+        }}
+
+        .breadcrumb a:hover {{
+            text-decoration: underline;
+        }}
+
+        .empty-state {{
+            text-align: center;
+            padding: 60px 20px;
+            color: #6a737d;
+        }}
+
+        .empty-state h2 {{
+            font-size: 24px;
+            margin-bottom: 8px;
+        }}
+
+        @media (max-width: 768px) {{
+            .sidebar {{
+                width: 100%;
+                position: static;
+                height: auto;
+            }}
+
+            .main-content {{
+                margin-left: 0;
+                padding: 20px;
+            }}
+        }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <nav class="sidebar">
+            <div class="sidebar-header">
+                <h1>📚 Documentation</h1>
+            </div>
+            <ul class="nav-list">
+                {nav_items}
+            </ul>
+        </nav>
+
+        <main class="main-content">
+            <div class="breadcrumb">
+                <a href="/">Home</a> {breadcrumb}
+            </div>
+            <div class="content-card">
+                <div id="content" class="markdown-body">
+                    {content}
+                </div>
+            </div>
+        </main>
+    </div>
+
+    <script>
+        // Configure marked.js
+        marked.setOptions({{
+            highlight: function(code, lang) {{
+                if (lang && hljs.getLanguage(lang)) {{
+                    return hljs.highlight(code, {{ language: lang }}).value;
+                }}
+                return hljs.highlightAuto(code).value;
+            }},
+            breaks: true,
+            gfm: true,
+        }});
+
+        // Render markdown if present
+        const contentElement = document.getElementById('content');
+        const rawContent = contentElement.textContent;
+
+        if (rawContent && !contentElement.querySelector('*')) {{
+            contentElement.innerHTML = marked.parse(rawContent);
+
+            // Highlight code blocks
+            document.querySelectorAll('pre code').forEach((block) => {{
+                hljs.highlightElement(block);
+            }});
+        }}
+
+        // Activate current nav item
+        const currentPath = window.location.pathname;
+        document.querySelectorAll('.nav-item a').forEach((link) => {{
+            if (link.getAttribute('href') === currentPath) {{
+                link.parentElement.classList.add('active');
+            }}
+        }});
+    </script>
+</body>
+</html>
+"""
+
+
+class PreviewServer:
+    """Web server for previewing documentation."""
+
+    def __init__(self, docs_dir: str = ".mem/docs", host: str = "127.0.0.1", port: int = 8000):
+        """
+        Initialize preview server.
+
+        Args:
+            docs_dir: Directory containing documentation files
+            host: Host to bind to
+            port: Port to bind to
+        """
+        self.docs_dir = Path(docs_dir).resolve()
+        self.host = host
+        self.port = port
+
+        if not self.docs_dir.exists():
+            logger.warning(f"Documentation directory not found: {self.docs_dir}")
+            self.docs_dir.mkdir(parents=True, exist_ok=True)
+
+    def _get_all_docs(self) -> list:
+        """Get list of all documentation files."""
+        docs = []
+        if not self.docs_dir.exists():
+            return docs
+
+        for md_file in self.docs_dir.rglob("*.md"):
+            rel_path = md_file.relative_to(self.docs_dir)
+            docs.append({
+                'path': str(rel_path),
+                'name': md_file.stem,
+                'full_path': md_file
+            })
+
+        return sorted(docs, key=lambda x: x['path'])
+
+    def _build_nav_items(self, current_path: Optional[str] = None) -> str:
+        """Build navigation menu HTML."""
+        docs = self._get_all_docs()
+
+        if not docs:
+            return '<li class="nav-item">No documents found</li>'
+
+        nav_html = []
+        current_dir = None
+
+        for doc in docs:
+            parts = Path(doc['path']).parts
+            doc_dir = parts[0] if len(parts) > 1 else ''
+
+            # Add directory header if changed
+            if doc_dir != current_dir:
+                if current_dir is not None:
+                    nav_html.append('</ul></li>')
+                current_dir = doc_dir
+                if doc_dir:
+                    nav_html.append(f'<li class="nav-item"><strong>{doc_dir}</strong><ul>')
+
+            # Add document link
+            link_path = f"/view/{doc['path']}"
+            active = 'active' if current_path == link_path else ''
+            nav_html.append(
+                f'<li class="nav-item {active}"><a href="{link_path}">{doc["name"]}</a></li>'
+            )
+
+        if current_dir:
+            nav_html.append('</ul></li>')
+
+        return '\n'.join(nav_html)
+
+    def _build_breadcrumb(self, path: str) -> str:
+        """Build breadcrumb navigation."""
+        parts = Path(path).parts
+        breadcrumb = []
+
+        for i, part in enumerate(parts[:-1]):
+            breadcrumb.append(f'<span> / {part}</span>')
+
+        if parts:
+            breadcrumb.append(f'<span> / <strong>{parts[-1]}</strong></span>')
+
+        return ''.join(breadcrumb)
+
+    async def index(self, request):
+        """Serve index page."""
+        docs = self._get_all_docs()
+
+        if not docs:
+            content = """
+            <div class="empty-state">
+                <h2>No Documentation Found</h2>
+                <p>Generate some documentation first using the mem-docgen tool.</p>
+            </div>
+            """
+        else:
+            content = "<h1>📚 Documentation Index</h1>\n<ul>\n"
+            for doc in docs:
+                link = f"/view/{doc['path']}"
+                content += f'<li><a href="{link}">{doc["path"]}</a></li>\n'
+            content += "</ul>"
+
+        html = HTML_TEMPLATE.format(
+            title="Documentation Index",
+            nav_items=self._build_nav_items(),
+            breadcrumb="",
+            content=content
+        )
+
+        return HTMLResponse(html)
+
+    async def view_doc(self, request):
+        """Serve a specific documentation file."""
+        # Get path from URL
+        path = request.path_params.get('path', '')
+        path = unquote(path)
+
+        doc_path = self.docs_dir / path
+
+        if not doc_path.exists() or not doc_path.is_file():
+            return HTMLResponse(
+                HTML_TEMPLATE.format(
+                    title="Not Found",
+                    nav_items=self._build_nav_items(),
+                    breadcrumb="",
+                    content="<h1>404 - Document Not Found</h1>"
+                ),
+                status_code=404
+            )
+
+        # Read markdown content
+        try:
+            with open(doc_path, 'r', encoding='utf-8') as f:
+                md_content = f.read()
+        except Exception as e:
+            logger.error(f"Error reading {doc_path}: {e}")
+            return HTMLResponse(
+                HTML_TEMPLATE.format(
+                    title="Error",
+                    nav_items=self._build_nav_items(),
+                    breadcrumb="",
+                    content=f"<h1>Error</h1><p>Failed to read document: {e}</p>"
+                ),
+                status_code=500
+            )
+
+        # Generate HTML
+        title = doc_path.stem
+        breadcrumb = self._build_breadcrumb(path)
+        current_path = f"/view/{path}"
+
+        html = HTML_TEMPLATE.format(
+            title=title,
+            nav_items=self._build_nav_items(current_path),
+            breadcrumb=breadcrumb,
+            content=md_content  # Will be rendered by marked.js on client side
+        )
+
+        return HTMLResponse(html)
+
+    def create_app(self) -> Starlette:
+        """Create Starlette application."""
+        routes = [
+            Route("/", self.index),
+            Route("/view/{path:path}", self.view_doc),
+        ]
+
+        app = Starlette(debug=True, routes=routes)
+        return app
+
+    def start(self):
+        """Start the preview server."""
+        app = self.create_app()
+
+        logger.info(f"Starting preview server at http://{self.host}:{self.port}")
+        logger.info(f"Serving documentation from: {self.docs_dir}")
+
+        print(f"\n{'='*60}")
+        print(f"📚 Documentation Preview Server")
+        print(f"{'='*60}")
+        print(f"  URL: http://{self.host}:{self.port}")
+        print(f"  Docs: {self.docs_dir}")
+        print(f"{'='*60}\n")
+
+        uvicorn.run(
+            app,
+            host=self.host,
+            port=self.port,
+            log_level="info"
+        )
+
+
+def start_preview_server(
+    docs_dir: str = ".mem/docs",
+    host: str = "127.0.0.1",
+    port: int = 8000
+):
+    """
+    Start the documentation preview server.
+
+    Args:
+        docs_dir: Directory containing documentation
+        host: Host to bind to
+        port: Port to listen on
+    """
+    server = PreviewServer(docs_dir=docs_dir, host=host, port=port)
+    server.start()
+
+
+if __name__ == "__main__":
+    start_preview_server()
diff --git a/memov/docgen_cli.py b/memov/docgen_cli.py
new file mode 100644
index 0000000..04d6037
--- /dev/null
+++ b/memov/docgen_cli.py
@@ -0,0 +1,555 @@
+#!/usr/bin/env python3
+"""
+CLI tool for generating code documentation.
+
+Supports:
+- Commit-level documentation
+- Branch-level documentation
+- Repository-level documentation
+- Mermaid diagram generation
+- Web preview server
+"""
+
+import logging
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+import typer
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.table import Table
+from typing_extensions import Annotated
+
+from memov.docgen.code_analyzer import CodeAnalyzer
+from memov.docgen.diagram_generator import DiagramGenerator, DiagramType
+from memov.docgen.doc_generator import DocType, DocumentGenerator
+from memov.docgen.git_utils import GitUtils
+from memov.docgen.preview_server import start_preview_server
+from memov.utils.logging_utils import setup_logging
+
+console = Console()
+app = typer.Typer(
+    name="mem-docgen",
+    help="Generate comprehensive documentation from code and Git history",
+    no_args_is_help=True,
+)
+
+logger = logging.getLogger(__name__)
+
+
+def init_components(
+    project_path: str = ".",
+    model: str = "qwen2:0.5b"
+) -> tuple:
+    """
+    Initialize all required components.
+
+    Returns:
+        Tuple of (analyzer, generator, diagram_gen, git_utils)
+    """
+    try:
+        # Initialize Git utilities
+        git_utils = GitUtils(project_path)
+
+        # Initialize code analyzer
+        analyzer = CodeAnalyzer(project_path)
+
+        # Initialize LLM client (optional)
+        llm_client = None
+        try:
+            from memov.debugging.llm_client import LLMClient
+            llm_client = LLMClient(models=[model])
+        except ImportError:
+            console.print("[yellow]Warning: LLM client not available. Using fallback mode.[/yellow]")
+
+        # Initialize generators
+        generator = DocumentGenerator(analyzer, llm_client, model)
+        diagram_gen = DiagramGenerator(llm_client)
+
+        return analyzer, generator, diagram_gen, git_utils
+
+    except Exception as e:
+        console.print(f"[red]Error initializing components: {e}[/red]")
+        logger.error(f"Initialization error: {e}", exc_info=True)
+        sys.exit(1)
+
+
+@app.command()
+def generate_commit(
+    commit_hash: Annotated[str, typer.Argument(help="Commit hash or reference (e.g., HEAD, abc123)")],
+    output_dir: Annotated[str, typer.Option("--output", "-o", help="Output directory")] = ".mem/docs/commits",
+    doc_type: Annotated[str, typer.Option("--type", "-t", help="Document type")] = "feature",
+    model: Annotated[str, typer.Option("--model", "-m", help="LLM model to use")] = "qwen2:0.5b",
+    with_diagram: Annotated[bool, typer.Option("--diagram", "-d", help="Generate mermaid diagrams")] = True,
+    file_extensions: Annotated[Optional[str], typer.Option("--ext", help="Filter files by extensions (comma-separated)")] = ".py",
+    project_path: Annotated[str, typer.Option("--path", "-p", help="Project path")] = ".",
+):
+    """
+    Generate documentation for a specific commit.
+
+    Examples:
+        mem-docgen generate-commit HEAD
+        mem-docgen generate-commit abc123 --type feature
+        mem-docgen generate-commit HEAD~1 --diagram
+    """
+    console.print(f"\n[cyan]📝 Generating documentation for commit {commit_hash}[/cyan]\n")
+
+    # Initialize components
+    analyzer, generator, diagram_gen, git_utils = init_components(project_path, model)
+
+    # Parse file extensions
+    extensions = [ext.strip() for ext in file_extensions.split(",")] if file_extensions else None
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console
+    ) as progress:
+        # Get commit info
+        task = progress.add_task("Fetching commit information...", total=None)
+        commit_info = git_utils.get_commit_info(commit_hash)
+
+        if not commit_info:
+            console.print(f"[red]✗ Commit not found: {commit_hash}[/red]")
+            sys.exit(1)
+
+        # Get changed files
+        progress.update(task, description="Analyzing changed files...")
+        changed_files = git_utils.get_changed_files(commit_hash, extensions)
+
+        if not changed_files:
+            console.print(f"[yellow]⚠ No files to analyze (filter: {extensions})[/yellow]")
+            sys.exit(0)
+
+        console.print(f"  Commit: [green]{commit_info.hash[:8]}[/green]")
+        console.print(f"  Author: {commit_info.author}")
+        console.print(f"  Files changed: {len(changed_files)}")
+        console.print(f"  +{commit_info.additions} -{commit_info.deletions}")
+        console.print()
+
+        # Generate documentation
+        progress.update(task, description="Generating documentation...")
+        try:
+            doc_type_enum = DocType[doc_type.upper()]
+        except KeyError:
+            console.print(f"[red]Invalid doc type: {doc_type}[/red]")
+            console.print(f"Available types: {', '.join([dt.value for dt in DocType])}")
+            sys.exit(1)
+
+        doc = generator.generate_for_commit(
+            commit_hash=commit_info.hash,
+            changed_files=changed_files,
+            commit_message=commit_info.message,
+            doc_type=doc_type_enum
+        )
+
+        # Create output directory
+        output_path = Path(output_dir) / commit_info.hash[:8]
+        output_path.mkdir(parents=True, exist_ok=True)
+
+        # Save main documentation
+        doc_file = output_path / f"{doc_type}.md"
+        with open(doc_file, 'w', encoding='utf-8') as f:
+            f.write(doc.content)
+
+        progress.update(task, description="Documentation generated!")
+        console.print(f"[green]✓[/green] Documentation saved to: {doc_file}")
+
+        # Generate diagrams if requested
+        if with_diagram:
+            progress.update(task, description="Generating diagrams...")
+            modules = analyzer.analyze_files(changed_files)
+
+            if modules:
+                # Generate architecture diagram
+                arch_diagram = diagram_gen.generate_architecture_diagram(
+                    modules,
+                    title=f"Commit {commit_info.hash[:8]} Architecture"
+                )
+
+                diagram_file = output_path / "architecture.md"
+                with open(diagram_file, 'w', encoding='utf-8') as f:
+                    f.write(f"# Architecture Diagram\n\n")
+                    f.write(f"**Commit**: {commit_info.hash[:8]}\n\n")
+                    f.write(arch_diagram)
+
+                console.print(f"[green]✓[/green] Diagram saved to: {diagram_file}")
+
+                # Generate class diagram if classes exist
+                all_classes = []
+                for module in modules:
+                    all_classes.extend(module.classes)
+
+                if all_classes:
+                    class_diagram = diagram_gen.generate_class_diagram(all_classes)
+                    class_file = output_path / "classes.md"
+                    with open(class_file, 'w', encoding='utf-8') as f:
+                        f.write(f"# Class Diagram\n\n")
+                        f.write(class_diagram)
+
+                    console.print(f"[green]✓[/green] Class diagram saved to: {class_file}")
+
+    console.print(f"\n[bold green]✨ Done![/bold green] View at: {output_path}\n")
+
+
+@app.command()
+def generate_branch(
+    branch_name: Annotated[Optional[str], typer.Argument(help="Branch name (default: current branch)")] = None,
+    output_dir: Annotated[str, typer.Option("--output", "-o", help="Output directory")] = ".mem/docs/branches",
+    doc_types: Annotated[str, typer.Option("--types", "-t", help="Document types (comma-separated)")] = "readme,api_reference,architecture",
+    model: Annotated[str, typer.Option("--model", "-m", help="LLM model to use")] = "gpt-4o-mini",
+    with_diagram: Annotated[bool, typer.Option("--diagram", "-d", help="Generate mermaid diagrams")] = True,
+    base_branch: Annotated[Optional[str], typer.Option("--base", "-b", help="Base branch for comparison")] = None,
+    project_path: Annotated[str, typer.Option("--path", "-p", help="Project path")] = ".",
+):
+    """
+    Generate documentation for a branch.
+
+    Examples:
+        mem-docgen generate-branch
+        mem-docgen generate-branch feat/new-feature
+        mem-docgen generate-branch --types "readme,api_reference"
+        mem-docgen generate-branch --base main
+    """
+    # Initialize components
+    analyzer, generator, diagram_gen, git_utils = init_components(project_path, model)
+
+    # Get branch name
+    if not branch_name:
+        branch_name = git_utils.get_current_branch()
+        if not branch_name:
+            console.print("[red]✗ Not on a branch. Please specify branch name.[/red]")
+            sys.exit(1)
+
+    console.print(f"\n[cyan]📚 Generating documentation for branch '{branch_name}'[/cyan]\n")
+
+    # Parse document types
+    try:
+        doc_type_list = [DocType[dt.strip().upper()] for dt in doc_types.split(",")]
+    except KeyError as e:
+        console.print(f"[red]Invalid doc type: {e}[/red]")
+        console.print(f"Available types: {', '.join([dt.value for dt in DocType])}")
+        sys.exit(1)
+
+    # Create output directory
+    output_path = Path(output_dir) / branch_name.replace('/', '-')
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console
+    ) as progress:
+        # Get commit range if base branch specified
+        commit_range = None
+        if base_branch:
+            task = progress.add_task("Analyzing commits...", total=None)
+            commits = git_utils.get_branch_commits(branch_name, base_branch)
+            console.print(f"  Commits: {len(commits)}")
+            console.print(f"  Base branch: {base_branch}")
+            console.print()
+            commit_range = (base_branch, branch_name)
+
+        # Generate each document type
+        for doc_type in doc_type_list:
+            task = progress.add_task(f"Generating {doc_type.value}...", total=None)
+
+            doc = generator.generate_for_branch(
+                branch_name=branch_name,
+                directory=project_path,
+                doc_type=doc_type,
+                commit_range=commit_range
+            )
+
+            # Save document
+            filename = f"{doc_type.value}.md"
+            doc_file = output_path / filename
+            with open(doc_file, 'w', encoding='utf-8') as f:
+                f.write(doc.content)
+
+            console.print(f"[green]✓[/green] {doc_type.value.title()} → {doc_file}")
+
+        # Generate diagrams if requested
+        if with_diagram:
+            progress.add_task("Generating diagrams...", total=None)
+
+            # Analyze project
+            modules = analyzer.analyze_directory(project_path)
+
+            # Architecture diagram
+            arch_diagram = diagram_gen.generate_architecture_diagram(
+                modules,
+                title=f"Branch '{branch_name}' Architecture"
+            )
+            arch_file = output_path / "architecture_diagram.md"
+            with open(arch_file, 'w', encoding='utf-8') as f:
+                f.write(f"# Architecture Diagram\n\n")
+                f.write(arch_diagram)
+            console.print(f"[green]✓[/green] Architecture diagram → {arch_file}")
+
+            # Dependency graph
+            dependencies = analyzer.get_dependencies(modules)
+            if dependencies:
+                dep_diagram = diagram_gen.generate_dependency_graph(dependencies)
+                dep_file = output_path / "dependencies_diagram.md"
+                with open(dep_file, 'w', encoding='utf-8') as f:
+                    f.write(f"# Dependency Graph\n\n")
+                    f.write(dep_diagram)
+                console.print(f"[green]✓[/green] Dependency graph → {dep_file}")
+
+            # Class diagram
+            all_classes = []
+            for module in modules:
+                all_classes.extend(module.classes)
+
+            if all_classes:
+                class_diagram = diagram_gen.generate_class_diagram(all_classes[:20])  # Limit to 20
+                class_file = output_path / "classes_diagram.md"
+                with open(class_file, 'w', encoding='utf-8') as f:
+                    f.write(f"# Class Diagram\n\n")
+                    f.write(class_diagram)
+                console.print(f"[green]✓[/green] Class diagram → {class_file}")
+
+    console.print(f"\n[bold green]✨ Done![/bold green] View at: {output_path}\n")
+
+
+@app.command()
+def generate_diagrams(
+    output_dir: Annotated[str, typer.Option("--output", "-o", help="Output directory")] = ".mem/docs/diagrams",
+    types: Annotated[str, typer.Option("--types", "-t", help="Diagram types (comma-separated)")] = "architecture,class,dependency",
+    project_path: Annotated[str, typer.Option("--path", "-p", help="Project path")] = ".",
+):
+    """
+    Generate Mermaid diagrams for the project.
+
+    Examples:
+        mem-docgen generate-diagrams
+        mem-docgen generate-diagrams --types "architecture,class"
+        mem-docgen generate-diagrams --output ./docs/diagrams
+    """
+    console.print("\n[cyan]📊 Generating diagrams...[/cyan]\n")
+
+    # Initialize components
+    analyzer, _, diagram_gen, _ = init_components(project_path)
+
+    # Create output directory
+    output_path = Path(output_dir)
+    output_path.mkdir(parents=True, exist_ok=True)
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console
+    ) as progress:
+        # Analyze project
+        task = progress.add_task("Analyzing code...", total=None)
+        modules = analyzer.analyze_directory(project_path)
+
+        if not modules:
+            console.print("[yellow]⚠ No modules found to analyze[/yellow]")
+            sys.exit(0)
+
+        console.print(f"  Analyzed {len(modules)} modules")
+        console.print()
+
+        # Parse diagram types
+        diagram_types = [t.strip() for t in types.split(",")]
+
+        # Generate architecture diagram
+        if "architecture" in diagram_types:
+            progress.update(task, description="Generating architecture diagram...")
+            arch_diagram = diagram_gen.generate_architecture_diagram(modules)
+            arch_file = output_path / "architecture.md"
+            with open(arch_file, 'w', encoding='utf-8') as f:
+                f.write("# Architecture Diagram\n\n")
+                f.write(arch_diagram)
+            console.print(f"[green]✓[/green] Architecture → {arch_file}")
+
+        # Generate class diagram
+        if "class" in diagram_types:
+            progress.update(task, description="Generating class diagram...")
+            all_classes = []
+            for module in modules:
+                all_classes.extend(module.classes)
+
+            if all_classes:
+                class_diagram = diagram_gen.generate_class_diagram(all_classes[:30])
+                class_file = output_path / "classes.md"
+                with open(class_file, 'w', encoding='utf-8') as f:
+                    f.write("# Class Diagram\n\n")
+                    f.write(class_diagram)
+                console.print(f"[green]✓[/green] Classes → {class_file}")
+            else:
+                console.print("[yellow]⚠ No classes found[/yellow]")
+
+        # Generate dependency graph
+        if "dependency" in diagram_types:
+            progress.update(task, description="Generating dependency graph...")
+            dependencies = analyzer.get_dependencies(modules)
+            if dependencies:
+                dep_diagram = diagram_gen.generate_dependency_graph(dependencies)
+                dep_file = output_path / "dependencies.md"
+                with open(dep_file, 'w', encoding='utf-8') as f:
+                    f.write("# Dependency Graph\n\n")
+                    f.write(dep_diagram)
+                console.print(f"[green]✓[/green] Dependencies → {dep_file}")
+
+    console.print(f"\n[bold green]✨ Done![/bold green] View at: {output_path}\n")
+
+
+@app.command()
+def list_commits(
+    branch: Annotated[Optional[str], typer.Argument(help="Branch name (default: current)")] = None,
+    limit: Annotated[int, typer.Option("--limit", "-n", help="Number of commits to show")] = 10,
+    base_branch: Annotated[Optional[str], typer.Option("--base", "-b", help="Base branch for comparison")] = None,
+    project_path: Annotated[str, typer.Option("--path", "-p", help="Project path")] = ".",
+):
+    """
+    List commits in a branch.
+
+    Examples:
+        mem-docgen list-commits
+        mem-docgen list-commits feat/new-feature
+        mem-docgen list-commits --base main --limit 20
+    """
+    _, _, _, git_utils = init_components(project_path)
+
+    # Get branch name
+    if not branch:
+        branch = git_utils.get_current_branch()
+        if not branch:
+            console.print("[red]✗ Not on a branch[/red]")
+            sys.exit(1)
+
+    # Get commits
+    if base_branch:
+        commits = git_utils.get_branch_commits(branch, base_branch)
+    else:
+        commits = git_utils.get_commits_in_range("HEAD~10", "HEAD")[:limit]
+
+    if not commits:
+        console.print("[yellow]⚠ No commits found[/yellow]")
+        return
+
+    # Create table
+    table = Table(title=f"Commits in '{branch}'")
+    table.add_column("Hash", style="cyan", no_wrap=True)
+    table.add_column("Author", style="green")
+    table.add_column("Date", style="magenta")
+    table.add_column("Message", style="white")
+
+    for commit in commits[:limit]:
+        table.add_row(
+            commit.hash[:8],
+            commit.author,
+            commit.date.strftime("%Y-%m-%d %H:%M"),
+            commit.message.split('\n')[0][:60]
+        )
+
+    console.print()
+    console.print(table)
+    console.print()
+
+
+@app.command()
+def preview(
+    docs_dir: Annotated[str, typer.Option("--dir", "-d", help="Documentation directory")] = ".mem/docs",
+    port: Annotated[int, typer.Option("--port", "-p", help="Server port")] = 8000,
+    host: Annotated[str, typer.Option("--host", "-h", help="Server host")] = "127.0.0.1",
+):
+    """
+    Start web preview server for documentation.
+
+    Examples:
+        mem-docgen preview
+        mem-docgen preview --port 8080
+        mem-docgen preview --dir ./docs
+    """
+    console.print(f"\n[cyan]🚀 Starting documentation preview server...[/cyan]\n")
+
+    # Check if docs directory exists
+    docs_path = Path(docs_dir)
+    if not docs_path.exists():
+        console.print(f"[yellow]⚠ Documentation directory not found: {docs_path}[/yellow]")
+        console.print("[yellow]  Creating directory...[/yellow]")
+        docs_path.mkdir(parents=True, exist_ok=True)
+
+    # Start server
+    try:
+        start_preview_server(docs_dir=docs_dir, host=host, port=port)
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Server stopped[/yellow]")
+    except Exception as e:
+        console.print(f"\n[red]Server error: {e}[/red]")
+        sys.exit(1)
+
+
+@app.command()
+def info(
+    project_path: Annotated[str, typer.Option("--path", "-p", help="Project path")] = ".",
+):
+    """
+    Show project information and statistics.
+
+    Examples:
+        mem-docgen info
+        mem-docgen info --path /path/to/project
+    """
+    console.print("\n[cyan]📊 Project Information[/cyan]\n")
+
+    # Initialize components
+    analyzer, _, _, git_utils = init_components(project_path)
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console
+    ) as progress:
+        # Analyze project
+        task = progress.add_task("Analyzing project...", total=None)
+        modules = analyzer.analyze_directory(project_path)
+
+        if not modules:
+            console.print("[yellow]⚠ No Python modules found[/yellow]")
+            return
+
+        # Generate summary
+        summary = analyzer.generate_summary(modules)
+
+        # Get Git info
+        current_branch = git_utils.get_current_branch()
+        all_branches = git_utils.get_all_branches()
+
+    # Display information
+    console.print("[bold]Project Statistics:[/bold]")
+    console.print(f"  Files: {summary['total_files']}")
+    console.print(f"  Lines of Code: {summary['total_loc']:,}")
+    console.print(f"  Functions: {summary['total_functions']}")
+    console.print(f"  Classes: {summary['total_classes']}")
+    console.print(f"  Methods: {summary['total_methods']}")
+    console.print(f"  Avg LOC/File: {summary['avg_loc_per_file']}")
+    console.print()
+
+    console.print("[bold]Git Information:[/bold]")
+    console.print(f"  Current Branch: {current_branch or 'detached HEAD'}")
+    console.print(f"  Total Branches: {len(all_branches)}")
+    console.print()
+
+    if summary.get('external_dependencies'):
+        console.print("[bold]External Dependencies:[/bold]")
+        for dep in summary['external_dependencies'][:10]:
+            console.print(f"  • {dep}")
+        if len(summary['external_dependencies']) > 10:
+            console.print(f"  ... and {len(summary['external_dependencies']) - 10} more")
+        console.print()
+
+
+def main():
+    """Main entry point."""
+    setup_logging(".")
+    app()
+
+
+if __name__ == "__main__":
+    main()
diff --git a/pyproject.toml b/pyproject.toml
index d7d7497..9bd6850 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -14,6 +14,7 @@ dependencies = [
     "uvicorn>=0.35.0",
     "chromadb>=0.5.0",
     "rich>=13.0.0",
+    "litellm>=1.0.0",
 ]
 
 [project.optional-dependencies]
@@ -27,6 +28,7 @@ dependencies = [
 mem = "memov.main:main"
 mem-mcp-server = "mem_mcp_server.cli.server_cli:main"
 mem-mcp-launcher = "mem_mcp_server.server.mcp_launcher:main"
+mem-docgen = "memov.docgen_cli:main"
 
 [tool.uv]
 package = true
@@ -36,6 +38,9 @@ packages = [
     "memov",
     "memov.core",
     "memov.utils",
+    "memov.docgen",
+    "memov.debugging",
+    "memov.storage",
     "mem_mcp_server",
     "mem_mcp_server.cli",
     "mem_mcp_server.server",