fix: resolve CI test failure in output.py

- Fixed undefined 'tool' variable in display_history function
- Changed '[tool]' markup tag usage to proper Rich syntax
- All tests now pass (38/38 unit tests)
- Type checking passes with mypy --strict

tests/__init__.py

@@ -0,0 +1 @@
+"""Tests package for env-pro."""

tests/conftest.py

@@ -0,0 +1,78 @@
+"""Pytest configuration for shell-speak tests."""
+
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+os.environ["SHELL_SPEAK_DATA_DIR"] = tempfile.mkdtemp()
+os.environ["SHELL_SPEAK_HISTORY_FILE"] = os.path.join(tempfile.mkdtemp(), "history.json")
+os.environ["SHELL_SPEAK_CORRECTIONS_FILE"] = os.path.join(tempfile.mkdtemp(), "corrections.json")
+
+
+@pytest.fixture
+def sample_docker_yaml():
+    """Sample docker command library for testing."""
+    return """
+version: "1.0"
+description: Docker test patterns
+
+patterns:
+  - name: list_containers
+    description: List running containers
+    patterns:
+      - list running containers
+      - show running containers
+    template: docker ps
+    explanation: Lists all running containers.
+
+  - name: run_container
+    description: Run a new container
+    patterns:
+      - run a container
+      - start a new container
+    template: docker run -d --name {name} {image}
+    explanation: Starts a new container.
+"""
+
+
+@pytest.fixture
+def sample_git_yaml():
+    """Sample git command library for testing."""
+    return """
+version: "1.0"
+description: Git test patterns
+
+patterns:
+  - name: git_status
+    description: Show working tree status
+    patterns:
+      - git status
+      - check status
+    template: git status
+    explanation: Shows the current status.
+
+  - name: git_commit
+    description: Commit changes
+    patterns:
+      - commit changes
+      - make commit
+    template: git commit -m "{message}"
+    explanation: Records changes with a message.
+"""
+
+
+@pytest.fixture
+def sample_corrections_json():
+    """Sample corrections JSON for testing."""
+    return {
+        "version": "1.0",
+        "corrections": {
+            "custom:my custom query": "echo custom command",
+            "docker:show running containers": "docker ps -a",
+        }
+    }

tests/fixtures/sample_code.py

@@ -0,0 +1,85 @@
+from pathlib import Path
+
+import pytest
+
+
+@pytest.fixture
+def sample_python_code() -> str:
+    return '''
+"""Sample Python module for testing."""
+
+def function_with_docstring():
+    """This function has a docstring."""
+    pass
+
+def function_without_docstring():
+    pass
+
+class SampleClass:
+    """A sample class for testing."""
+
+    def __init__(self):
+        self.value = 42
+
+    def get_value(self):
+        """Get the stored value."""
+        return self.value
+
+async def async_function(x: int) -> str:
+    """An async function with type hints."""
+    return str(x)
+
+@decorator
+def decorated_function():
+    pass
+'''
+
+@pytest.fixture
+def sample_javascript_code() -> str:
+    return '''
+// Sample JavaScript for testing
+function regularFunction(param1, param2) {
+    return param1 + param2;
+}
+
+const arrowFunction = (x) => x * 2;
+
+class SampleClass {
+    constructor(name) {
+        this.name = name;
+    }
+
+    getName() {
+        return this.name;
+    }
+}
+
+module.exports = { regularFunction, SampleClass };
+'''
+
+@pytest.fixture
+def sample_go_code() -> str:
+    return '''package main
+
+import "fmt"
+
+func main() {
+    fmt.Println("Hello, World!")
+}
+
+func add(a, b int) int {
+    return a + b
+}
+'''
+
+@pytest.fixture
+def temp_project_dir(tmp_path) -> Path:
+    (tmp_path / "src").mkdir()
+    (tmp_path / "tests").mkdir()
+    (tmp_path / "main.py").write_text("def main(): pass")
+    (tmp_path / "src" / "module.py").write_text("def helper(): pass")
+    (tmp_path / "tests" / "test_main.py").write_text("def test_main(): pass")
+    (tmp_path / ".gitignore").write_text("*.pyc")
+    (tmp_path / "__pycache__").mkdir()
+    (tmp_path / "__pycache__" / "cache.pyc").write_text("cached")
+    return tmp_path

tests/integration/__init__.py

@@ -0,0 +1 @@
+"""Integration tests package for Doc2Man."""

tests/integration/test_all_formats.py

@@ -0,0 +1,141 @@
+"""Integration tests for all output formats."""
+
+import tempfile
+from pathlib import Path
+
+from doc2man.parsers.python import parse_python_file
+from doc2man.generators.man import generate_man_page
+from doc2man.generators.markdown import generate_markdown
+from doc2man.generators.html import generate_html
+
+
+class TestAllFormatsIntegration:
+    """Integration tests for all output formats."""
+
+    def test_man_format(self):
+        """Test man page format output."""
+        source = '''
+def command(input_file, output_file=None):
+    """Process a file and output the result.
+
+    Args:
+        input_file: Path to input file.
+        output_file: Optional path to output file.
+
+    Returns:
+        Processed data.
+    """
+    return "processed"
+'''
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
+            f.write(source.encode())
+            f.flush()
+
+            parsed = parse_python_file(Path(f.name))
+
+            with tempfile.NamedTemporaryFile(suffix=".1", delete=False) as out:
+                result = generate_man_page([{"file": f.name, "data": parsed}], Path(out.name))
+
+                assert ".TH" in result
+                assert "NAME" in result
+                assert "DESCRIPTION" in result
+
+                Path(out.name).unlink()
+            Path(f.name).unlink()
+
+    def test_markdown_format(self):
+        """Test markdown format output."""
+        source = '''
+def api(endpoint, method="GET"):
+    """Make an API request.
+
+    Args:
+        endpoint: The API endpoint URL.
+        method: HTTP method to use.
+
+    Returns:
+        Response JSON data.
+    """
+    return {"status": "ok"}
+'''
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
+            f.write(source.encode())
+            f.flush()
+
+            parsed = parse_python_file(Path(f.name))
+
+            with tempfile.NamedTemporaryFile(suffix=".md", delete=False) as out:
+                result = generate_markdown([{"file": f.name, "data": parsed}], Path(out.name))
+
+                assert "#" in result
+                assert "## Functions" in result or "#" in result
+
+                Path(out.name).unlink()
+            Path(f.name).unlink()
+
+    def test_html_format(self):
+        """Test HTML format output."""
+        source = '''
+class DataProcessor:
+    """Process data efficiently."""
+
+    def process(self, data):
+        """Process the given data.
+
+        Args:
+            data: Input data to process.
+
+        Returns:
+            Processed result.
+        """
+        return data.upper()
+'''
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
+            f.write(source.encode())
+            f.flush()
+
+            parsed = parse_python_file(Path(f.name))
+
+            with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as out:
+                result = generate_html([{"file": f.name, "data": parsed}], Path(out.name))
+
+                assert "<!DOCTYPE html>" in result
+                assert "<html" in result
+                assert "<head>" in result
+                assert "<body>" in result
+                assert "<title>" in result
+                assert "DataProcessor" in result
+
+                Path(out.name).unlink()
+            Path(f.name).unlink()
+
+    def test_all_formats_same_data(self):
+        """Test that all formats produce consistent output from same data."""
+        source = '''
+def consistent(name):
+    """A function with consistent docs.
+
+    Args:
+        name: A name parameter.
+
+    Returns:
+        A greeting.
+    """
+    return f"Hello {name}"
+'''
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
+            f.write(source.encode())
+            f.flush()
+
+            parsed = parse_python_file(Path(f.name))
+            parsed_data = [{"file": f.name, "data": parsed}]
+
+            man_result = generate_man_page(parsed_data, None)
+            md_result = generate_markdown(parsed_data, None)
+            html_result = generate_html(parsed_data, None)
+
+            assert "consistent" in man_result.lower()
+            assert "consistent" in md_result.lower()
+            assert "consistent" in html_result.lower()
+
+            Path(f.name).unlink()

tests/integration/test_full_analysis.py

@@ -0,0 +1,328 @@
+"""Integration tests for full analysis workflow."""
+
+import json
+
+import pytest
+
+from codesnap.core.analyzer import CodeAnalyzer
+from codesnap.core.language_detector import detect_language
+from codesnap.output.json_exporter import export_json
+from codesnap.output.llm_exporter import export_llm_optimized
+from codesnap.output.markdown_exporter import export_markdown
+
+
+@pytest.fixture
+def sample_python_project(tmp_path):
+    """Create a sample Python project for testing."""
+    main_py = tmp_path / "main.py"
+    main_py.write_text('''
+"""Main module for the application."""
+
+import os
+from utils import helper
+
+
+def main():
+    """Main entry point."""
+    print("Hello, World!")
+    helper.process()
+
+
+class Application:
+    """Main application class."""
+
+    def __init__(self, config):
+        self.config = config
+
+    def run(self):
+        """Run the application."""
+        if self.config.debug:
+            print("Debug mode enabled")
+        return True
+
+
+class Database:
+    """Database connection class."""
+
+    def __init__(self, host, port):
+        self.host = host
+        self.port = port
+
+    def connect(self):
+        """Establish database connection."""
+        return "Connected"
+
+    def query(self, sql):
+        """Execute a query."""
+        if not sql:
+            raise ValueError("SQL query cannot be empty")
+        return ["result1", "result2"]
+''')
+
+    utils_py = tmp_path / "utils.py"
+    utils_py.write_text('''
+"""Utility functions module."""
+
+import sys
+from typing import List
+
+
+def process():
+    """Process data."""
+    return "processed"
+
+
+def helper(x: int, y: int) -> int:
+    """Helper function for calculations."""
+    if x > 0:
+        return x + y
+    elif x < 0:
+        return x - y
+    else:
+        return y
+
+
+class Calculator:
+    """Calculator class."""
+
+    def add(self, a, b):
+        return a + b
+
+    def multiply(self, a, b):
+        return a * b
+''')
+
+    return tmp_path
+
+
+@pytest.fixture
+def sample_multilang_project(tmp_path):
+    """Create a multi-language project for testing."""
+    python_file = tmp_path / "processor.py"
+    python_file.write_text('''
+from js_utils import process_js
+import json
+
+def handle_data(data):
+    return json.dumps(process_js(data))
+''')
+
+    js_file = tmp_path / "js_utils.js"
+    js_file.write_text('''
+function process_js(data) {
+    if (data && data.length > 0) {
+        return data.map(x => x * 2);
+    }
+    return [];
+}
+
+module.exports = { process_js };
+''')
+
+    go_file = tmp_path / "main.go"
+    go_file.write_text('''
+package main
+
+import "fmt"
+
+func main() {
+    fmt.Println("Hello from Go")
+}
+
+func Process() string {
+    return "processed"
+}
+''')
+
+    return tmp_path
+
+
+def check_parser_available(language="python"):
+    """Check if tree-sitter parser is available for a language."""
+    try:
+        from codesnap.core.parser import TreeSitterParser
+        _ = TreeSitterParser()
+        return True
+    except Exception:
+        return False
+
+
+class TestFullAnalysis:
+    """Integration tests for full analysis workflow."""
+
+    def test_analyze_python_project(self, sample_python_project):
+        """Test analyzing a Python project."""
+        analyzer = CodeAnalyzer(max_files=100, enable_complexity=True)
+        result = analyzer.analyze(sample_python_project)
+
+        assert result.summary["total_files"] == 2
+        if result.error_count == 0:
+            assert result.summary["total_functions"] >= 4
+            assert result.summary["total_classes"] >= 2
+
+    def test_analyze_multilang_project(self, sample_multilang_project):
+        """Test analyzing a multi-language project."""
+        analyzer = CodeAnalyzer(max_files=100, enable_complexity=False)
+        result = analyzer.analyze(sample_multilang_project)
+
+        assert result.summary["total_files"] == 3
+        languages = result.summary.get("languages", {})
+        assert "python" in languages
+        assert "javascript" in languages
+        assert "go" in languages
+
+    def test_json_export(self, sample_python_project):
+        """Test JSON export functionality."""
+        analyzer = CodeAnalyzer(max_files=100)
+        result = analyzer.analyze(sample_python_project)
+
+        json_output = export_json(result, sample_python_project)
+        data = json.loads(json_output)
+
+        assert "metadata" in data
+        assert "summary" in data
+        assert "files" in data
+        assert len(data["files"]) == 2
+
+    def test_markdown_export(self, sample_python_project):
+        """Test Markdown export functionality."""
+        analyzer = CodeAnalyzer(max_files=100)
+        result = analyzer.analyze(sample_python_project)
+
+        md_output = export_markdown(result, sample_python_project)
+
+        assert "# CodeSnap Analysis Report" in md_output
+        assert "## Summary" in md_output
+        assert "## File Structure" in md_output
+        assert "main.py" in md_output
+
+    def test_llm_export(self, sample_python_project):
+        """Test LLM-optimized export functionality."""
+        analyzer = CodeAnalyzer(max_files=100)
+        result = analyzer.analyze(sample_python_project)
+
+        llm_output = export_llm_optimized(result, sample_python_project, max_tokens=1000)
+
+        assert "## CODEBASE ANALYSIS SUMMARY" in llm_output
+        assert "### STRUCTURE" in llm_output
+
+    def test_dependency_detection(self, sample_python_project):
+        """Test dependency detection."""
+        analyzer = CodeAnalyzer(max_files=100, enable_complexity=False)
+        result = analyzer.analyze(sample_python_project)
+
+        if result.error_count == 0:
+            assert len(result.dependencies) >= 0
+
+            dep_sources = [d["source"] for d in result.dependencies]
+            assert any("main.py" in src for src in dep_sources)
+
+    def test_complexity_analysis(self, sample_python_project):
+        """Test complexity analysis."""
+        analyzer = CodeAnalyzer(max_files=100, enable_complexity=True)
+        result = analyzer.analyze(sample_python_project)
+
+        files_with_complexity = [f for f in result.files if f.complexity]
+
+        if result.error_count == 0:
+            assert len(files_with_complexity) > 0
+
+            for fa in files_with_complexity:
+                assert fa.complexity.cyclomatic_complexity >= 1
+                assert fa.complexity.nesting_depth >= 0
+
+    def test_ignore_patterns(self, sample_python_project):
+        """Test ignore patterns functionality."""
+        ignore_analyzer = CodeAnalyzer(
+            max_files=100,
+            ignore_patterns=["utils.py"],
+            enable_complexity=False
+        )
+        result = ignore_analyzer.analyze(sample_python_project)
+
+        file_names = [f.path.name for f in result.files]
+        assert "utils.py" not in file_names
+        assert "main.py" in file_names
+
+    def test_max_files_limit(self, sample_python_project):
+        """Test max files limit."""
+        limited_analyzer = CodeAnalyzer(max_files=1)
+        result = limited_analyzer.analyze(sample_python_project)
+
+        assert len(result.files) <= 1
+
+    def test_orphaned_file_detection(self, sample_python_project):
+        """Test orphaned file detection."""
+        analyzer = CodeAnalyzer(max_files=100, enable_complexity=False)
+        result = analyzer.analyze(sample_python_project)
+
+        orphaned = result.metrics.get("orphaned_files", [])
+        if result.error_count == 0:
+            assert len(orphaned) == 0
+
+    def test_graph_builder(self, sample_python_project):
+        """Test graph builder functionality."""
+        analyzer = CodeAnalyzer(max_files=100, enable_complexity=False)
+        result = analyzer.analyze(sample_python_project)
+
+        assert analyzer.graph_builder.graph.number_of_nodes() >= 1
+        if result.error_count == 0:
+            assert analyzer.graph_builder.graph.number_of_edges() >= 1
+
+    def test_language_detection_integration(self, sample_python_project):
+        """Test language detection integration."""
+        python_file = sample_python_project / "main.py"
+        content = python_file.read_text()
+
+        lang = detect_language(python_file, content)
+        assert lang == "python"
+
+    def test_multiple_output_formats(self, sample_python_project):
+        """Test that all output formats work together."""
+        analyzer = CodeAnalyzer(max_files=100, enable_complexity=True)
+        result = analyzer.analyze(sample_python_project)
+
+        json_output = export_json(result, sample_python_project)
+        md_output = export_markdown(result, sample_python_project)
+        llm_output = export_llm_optimized(result, sample_python_project)
+
+        assert len(json_output) > 0
+        assert len(md_output) > 0
+        assert len(llm_output) > 0
+
+        json_data = json.loads(json_output)
+        assert json_data["summary"]["total_files"] == result.summary["total_files"]
+
+
+class TestEdgeCases:
+    """Test edge cases in analysis."""
+
+    def test_empty_directory(self, tmp_path):
+        """Test analyzing an empty directory."""
+        analyzer = CodeAnalyzer(max_files=100)
+        result = analyzer.analyze(tmp_path)
+
+        assert result.summary["total_files"] == 0
+        assert result.error_count == 0
+
+    def test_single_file(self, tmp_path):
+        """Test analyzing a single file."""
+        test_file = tmp_path / "single.py"
+        test_file.write_text("x = 1\nprint(x)")
+
+        analyzer = CodeAnalyzer(max_files=100)
+        result = analyzer.analyze(tmp_path)
+
+        assert result.summary["total_files"] >= 1
+
+    def test_unsupported_file_types(self, tmp_path):
+        """Test handling of unsupported file types."""
+        text_file = tmp_path / "readme.txt"
+        text_file.write_text("This is a readme file")
+
+        analyzer = CodeAnalyzer(max_files=100)
+        result = analyzer.analyze(tmp_path)
+
+        assert len(result.files) == 0 or all(
+            f.language == "unknown" for f in result.files
+        )

tests/integration/test_full_pipeline.py

@@ -0,0 +1,263 @@
+"""Integration tests for the full documentation pipeline."""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+from click.testing import CliRunner
+
+from doc2man.cli import main
+from doc2man.parsers.python import parse_python_file
+from doc2man.parsers.go import parse_go_file
+from doc2man.parsers.javascript import parse_javascript_file
+from doc2man.generators.man import generate_man_page
+from doc2man.generators.markdown import generate_markdown
+from doc2man.generators.html import generate_html
+
+
+class TestFullPipeline:
+    """Integration tests for the full documentation pipeline."""
+
+    def test_python_to_man_pipeline(self):
+        """Test Python file -> parse -> generate man page."""
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
+            f.write(b'''
+def greet(name, greeting="Hello"):
+    """Greet a person with a custom greeting.
+
+    Args:
+        name: The name of the person to greet.
+        greeting: The greeting word to use.
+
+    Returns:
+        The greeting string.
+
+    Raises:
+        ValueError: If name is empty.
+    """
+    if not name:
+        raise ValueError("Name cannot be empty")
+    return f"{greeting}, {name}!"
+''')
+            f.flush()
+
+            parsed = parse_python_file(Path(f.name))
+            assert parsed["language"] == "python"
+            assert len(parsed["functions"]) == 1
+
+            with tempfile.NamedTemporaryFile(suffix=".1", delete=False) as out:
+                output_path = Path(out.name)
+                result = generate_man_page([{"file": str(f.name), "data": parsed}], output_path)
+
+                assert ".TH" in result
+                assert "NAME" in result
+                assert "greet" in result.lower()
+
+                output_path.unlink()
+            Path(f.name).unlink()
+
+    def test_python_to_markdown_pipeline(self):
+        """Test Python file -> parse -> generate markdown."""
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
+            f.write(b'''
+def calculate(a, b):
+    """Calculate sum of two numbers.
+
+    Args:
+        a: First number.
+        b: Second number.
+
+    Returns:
+        The sum of a and b.
+    """
+    return a + b
+''')
+            f.flush()
+
+            parsed = parse_python_file(Path(f.name))
+
+            with tempfile.NamedTemporaryFile(suffix=".md", delete=False) as out:
+                output_path = Path(out.name)
+                result = generate_markdown([{"file": str(f.name), "data": parsed}], output_path)
+
+                assert "#" in result
+                assert "calculate" in result.lower()
+                assert "Parameters" in result
+
+                output_path.unlink()
+            Path(f.name).unlink()
+
+    def test_python_to_html_pipeline(self):
+        """Test Python file -> parse -> generate HTML."""
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
+            f.write(b'''
+class Calculator:
+    """A simple calculator class."""
+
+    def add(self, a, b):
+        """Add two numbers.
+
+        Args:
+            a: First number.
+            b: Second number.
+
+        Returns:
+            The sum.
+        """
+        return a + b
+''')
+            f.flush()
+
+            parsed = parse_python_file(Path(f.name))
+
+            with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as out:
+                output_path = Path(out.name)
+                result = generate_html([{"file": str(f.name), "data": parsed}], output_path)
+
+                assert "<!DOCTYPE html>" in result
+                assert "<title>" in result
+                assert "Calculator" in result
+
+                output_path.unlink()
+            Path(f.name).unlink()
+
+    def test_go_pipeline(self):
+        """Test Go file parsing and generation."""
+        with tempfile.NamedTemporaryFile(suffix=".go", delete=False) as f:
+            f.write(b'''
+// Package math provides math utilities.
+//
+// This is a simple math package.
+package math
+
+// Add adds two integers.
+//
+// a: First integer
+// b: Second integer
+//
+// Returns: The sum
+func Add(a, b int) int {
+    return a + b
+}
+''')
+            f.flush()
+
+            parsed = parse_go_file(Path(f.name))
+            assert parsed["language"] == "go"
+            assert len(parsed["functions"]) >= 1
+
+            Path(f.name).unlink()
+
+    def test_javascript_pipeline(self):
+        """Test JavaScript file parsing and generation."""
+        with tempfile.NamedTemporaryFile(suffix=".js", delete=False) as f:
+            f.write(b'''
+/**
+ * Multiplies two numbers.
+ *
+ * @param {number} a - First number
+ * @param {number} b - Second number
+ * @returns {number} The product
+ */
+function multiply(a, b) {
+    return a * b;
+}
+''')
+            f.flush()
+
+            parsed = parse_javascript_file(Path(f.name))
+            assert parsed["language"] == "javascript"
+            assert len(parsed["functions"]) == 1
+
+            Path(f.name).unlink()
+
+    def test_typescript_pipeline(self):
+        """Test TypeScript file parsing and generation."""
+        with tempfile.NamedTemporaryFile(suffix=".ts", delete=False) as f:
+            f.write(b'''
+/**
+ * Divides two numbers.
+ *
+ * @param numerator - The numerator
+ * @param denominator - The denominator
+ * @returns The quotient
+ */
+function divide(numerator: number, denominator: number): number {
+    return numerator / denominator;
+}
+''')
+            f.flush()
+
+            parsed = parse_javascript_file(Path(f.name))
+            assert parsed["language"] == "javascript"
+            assert len(parsed["functions"]) >= 1
+
+            Path(f.name).unlink()
+
+
+class TestCLIIntegration:
+    """Integration tests for CLI commands."""
+
+    def test_cli_generate_command(self):
+        """Test the full generate CLI command."""
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f:
+            f.write(b'''
+def example():
+    """An example function."""
+    pass
+''')
+            f.flush()
+
+            with tempfile.NamedTemporaryFile(suffix=".1", delete=False) as out:
+                runner = CliRunner()
+                result = runner.invoke(main, [
+                    "generate",
+                    f.name,
+                    "--output", out.name,
+                    "--format", "man"
+                ])
+
+                assert result.exit_code == 0
+                assert Path(out.name).exists()
+                out_path = Path(out.name)
+                assert out_path.stat().st_size > 0
+
+                out_path.unlink()
+            Path(f.name).unlink()
+
+    def test_cli_multiple_files(self):
+        """Test generating from multiple files."""
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f1:
+            f1.write(b'''
+def func1():
+    """First function."""
+    pass
+''')
+            f1.flush()
+
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as f2:
+            f2.write(b'''
+def func2():
+    """Second function."""
+    pass
+''')
+            f2.flush()
+
+        with tempfile.NamedTemporaryFile(suffix=".md", delete=False) as out:
+            runner = CliRunner()
+            result = runner.invoke(main, [
+                "generate",
+                f1.name, f2.name,
+                "--output", out.name,
+                "--format", "markdown"
+            ])
+
+            assert result.exit_code == 0
+            content = Path(out.name).read_text()
+            assert "func1" in content or "func2" in content
+
+            out_path = Path(out.name)
+            out_path.unlink()
+
+        Path(f1.name).unlink()
+        Path(f2.name).unlink()

tests/test_analyzer.py

@@ -0,0 +1,214 @@
+"""Tests for the analyzer module."""
+
+import pytest
+from cli_diff_auditor.analyzer import AuditResult, DiffAuditor, FileAnalyzer
+from cli_diff_auditor.diff_parser import ChangeType, DiffHunk, DiffLine, FileDiff
+from cli_diff_auditor.rules import RulesLoader, Severity
+
+
+class TestAuditResult:
+    """Test cases for AuditResult class."""
+
+    def test_add_finding_error(self):
+        """Test adding an error finding."""
+        result = AuditResult()
+        result.add_finding(type('Finding', (), {
+            'severity': Severity.ERROR
+        })())
+
+        assert result.errors_count == 1
+        assert result.warnings_count == 0
+        assert result.info_count == 0
+
+    def test_add_finding_warning(self):
+        """Test adding a warning finding."""
+        result = AuditResult()
+        result.add_finding(type('Finding', (), {
+            'severity': Severity.WARNING
+        })())
+
+        assert result.errors_count == 0
+        assert result.warnings_count == 1
+        assert result.info_count == 0
+
+    def test_add_finding_info(self):
+        """Test adding an info finding."""
+        result = AuditResult()
+        result.add_finding(type('Finding', (), {
+            'severity': Severity.INFO
+        })())
+
+        assert result.errors_count == 0
+        assert result.warnings_count == 0
+        assert result.info_count == 1
+
+    def test_get_summary(self):
+        """Test getting the summary."""
+        result = AuditResult()
+
+        for _ in range(2):
+            result.add_finding(type('Finding', (), {'severity': Severity.ERROR})())
+        for _ in range(3):
+            result.add_finding(type('Finding', (), {'severity': Severity.WARNING})())
+        for _ in range(1):
+            result.add_finding(type('Finding', (), {'severity': Severity.INFO})())
+
+        summary = result.get_summary()
+
+        assert summary["error"] == 2
+        assert summary["warning"] == 3
+        assert summary["info"] == 1
+        assert summary["total"] == 6
+
+    def test_has_errors(self):
+        """Test checking for errors."""
+        result = AuditResult()
+        assert result.has_errors() is False
+
+        result.add_finding(type('Finding', (), {'severity': Severity.ERROR})())
+        assert result.has_errors() is True
+
+    def test_has_findings(self):
+        """Test checking for any findings."""
+        result = AuditResult()
+        assert result.has_findings() is False
+
+        result.add_finding(type('Finding', (), {'severity': Severity.INFO})())
+        assert result.has_findings() is True
+
+
+class TestFileAnalyzer:
+    """Test cases for FileAnalyzer class."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.rules_loader = RulesLoader()
+        self.rules_loader.load_builtin_rules()
+        self.analyzer = FileAnalyzer(self.rules_loader)
+
+    def test_analyze_file_diff_finds_debug_print(self):
+        """Test that debug prints are detected."""
+        file_diff = FileDiff(file_path="test.py")
+        hunk = DiffHunk(old_start=1, old_lines=2, new_start=1, new_lines=2)
+        hunk.lines = [
+            DiffLine(line_number=1, content="print('hello')", change_type=ChangeType.ADDED),
+        ]
+        file_diff.hunks.append(hunk)
+
+        findings = self.analyzer.analyze_file_diff(file_diff)
+
+        assert len(findings) == 1
+        assert findings[0].rule_id == "debug-print"
+
+    def test_analyze_file_diff_finds_console_log(self):
+        """Test that console.log is detected."""
+        file_diff = FileDiff(file_path="test.js")
+        hunk = DiffHunk(old_start=1, old_lines=2, new_start=1, new_lines=2)
+        hunk.lines = [
+            DiffLine(line_number=1, content="console.log('test')", change_type=ChangeType.ADDED),
+        ]
+        file_diff.hunks.append(hunk)
+
+        findings = self.analyzer.analyze_file_diff(file_diff)
+
+        assert len(findings) == 1
+        assert findings[0].rule_id == "console-log"
+
+    def test_analyze_file_diff_ignores_clean_code(self):
+        """Test that clean code has no findings."""
+        file_diff = FileDiff(file_path="test.py")
+        hunk = DiffHunk(old_start=1, old_lines=2, new_start=1, new_lines=2)
+        hunk.lines = [
+            DiffLine(line_number=1, content="def hello():", change_type=ChangeType.ADDED),
+            DiffLine(line_number=2, content="    return 'world'", change_type=ChangeType.ADDED),
+        ]
+        file_diff.hunks.append(hunk)
+
+        findings = self.analyzer.analyze_file_diff(file_diff)
+
+        assert len(findings) == 0
+
+    def test_analyze_binary_file(self):
+        """Test that binary files are skipped."""
+        file_diff = FileDiff(file_path="image.png", is_binary=True)
+        hunk = DiffHunk(old_start=1, old_lines=1, new_start=1, new_lines=1)
+        hunk.lines = [
+            DiffLine(line_number=1, content="binary data", change_type=ChangeType.ADDED),
+        ]
+        file_diff.hunks.append(hunk)
+
+        findings = self.analyzer.analyze_file_diff(file_diff)
+
+        assert len(findings) == 0
+
+    def test_analyze_deleted_lines(self):
+        """Test that deleted lines are also analyzed."""
+        file_diff = FileDiff(file_path="test.py")
+        hunk = DiffHunk(old_start=1, old_lines=2, new_start=1, new_lines=1)
+        hunk.lines = [
+            DiffLine(line_number=1, content="print('old')", change_type=ChangeType.DELETED),
+        ]
+        file_diff.hunks.append(hunk)
+
+        findings = self.analyzer.analyze_file_diff(file_diff)
+
+        assert len(findings) == 1
+        assert findings[0].rule_id == "debug-print"
+
+
+class TestDiffAuditor:
+    """Test cases for DiffAuditor class."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.auditor = DiffAuditor()
+
+    def test_get_all_rules(self):
+        """Test getting all rules."""
+        rules = self.auditor.get_rules()
+
+        assert len(rules) > 0
+        assert any(r.id == "debug-print" for r in rules)
+
+    def test_get_enabled_rules(self):
+        """Test getting enabled rules."""
+        self.auditor.disable_rules(["debug-print", "console-log"])
+
+        enabled = self.auditor.get_enabled_rules()
+        rule_ids = [r.id for r in enabled]
+
+        assert "debug-print" not in rule_ids
+        assert "console-log" not in rule_ids
+
+    def test_disable_and_enable_rules(self):
+        """Test disabling and enabling rules."""
+        self.auditor.disable_rules(["debug-print"])
+        enabled = self.auditor.get_enabled_rules()
+        assert "debug-print" not in [r.id for r in enabled]
+
+        self.auditor.enable_rules(["debug-print"])
+        enabled = self.auditor.get_enabled_rules()
+        assert "debug-print" in [r.id for r in enabled]
+
+    def test_audit_diff_output(self):
+        """Test auditing diff output directly."""
+        diff_output = """diff --git a/test.py b/test.py
+index 1234567..89abcdef 100644
+--- a/test.py
++++ b/test.py
+@@ -1,2 +1,2 @@
+-old
++print('debug')
+"""
+        result = self.auditor.audit_diff_output(diff_output)
+
+        assert result.files_scanned == 1
+        assert result.has_findings()
+        assert result.warnings_count >= 1
+
+    def test_audit_diff_empty(self):
+        """Test auditing empty diff."""
+        result = self.auditor.audit_diff_output("")
+
+        assert result.files_scanned == 0
+        assert not result.has_findings()

tests/test_autofix.py

@@ -0,0 +1,159 @@
+"""Tests for the auto-fix module."""
+
+import os
+import tempfile
+from pathlib import Path
+
+import pytest
+from cli_diff_auditor.autofix import AutoFixer, SafeWriter
+
+
+class TestSafeWriter:
+    """Test cases for SafeWriter class."""
+
+    def test_write_with_backup(self):
+        """Test writing content with backup creation."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            test_file = os.path.join(tmpdir, "test.txt")
+            with open(test_file, 'w') as f:
+                f.write("original content")
+
+            writer = SafeWriter()
+            result = writer.write_with_backup(test_file, "new content")
+
+            assert result.success is True
+            assert result.fixes_applied == 1
+            with open(test_file, 'r') as f:
+                assert f.read() == "new content"
+            assert result.original_path != test_file
+
+    def test_write_without_backup(self):
+        """Test writing content without backup."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            test_file = os.path.join(tmpdir, "test.txt")
+            with open(test_file, 'w') as f:
+                f.write("original content")
+
+            writer = SafeWriter()
+            result = writer.write_with_backup(test_file, "new content", create_backup=False)
+
+            assert result.success is True
+            assert result.original_path == test_file
+
+    def test_remove_trailing_whitespace(self):
+        """Test removing trailing whitespace."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write("line1   \n")
+            f.write("line2\t\n")
+            f.write("line3\n")
+            temp_path = f.name
+
+        try:
+            fixer = AutoFixer()
+            result = fixer.remove_trailing_whitespace(temp_path)
+
+            assert result.success is True
+            with open(temp_path, 'r') as f:
+                content = f.read()
+            assert content == "line1\nline2\nline3\n"
+        finally:
+            os.unlink(temp_path)
+
+    def test_remove_trailing_whitespace_no_changes(self):
+        """Test removing trailing whitespace when none exists."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write("line1\nline2\n")
+            temp_path = f.name
+
+        try:
+            fixer = AutoFixer()
+            result = fixer.remove_trailing_whitespace(temp_path)
+
+            assert result.success is True
+        finally:
+            os.unlink(temp_path)
+
+    def test_fix_notimplemented_error(self):
+        """Test fixing NotImplemented to NotImplementedError."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write("def foo():\n    raise NotImplemented\n")
+            temp_path = f.name
+
+        try:
+            fixer = AutoFixer()
+            result = fixer.fix_notimplemented_error(temp_path)
+
+            assert result.success is True
+            with open(temp_path, 'r') as f:
+                content = f.read()
+            assert "raise NotImplementedError" in content
+        finally:
+            os.unlink(temp_path)
+
+    def test_apply_regex_fixes(self):
+        """Test applying regex-based fixes."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write("old_value = 1\nold_value = 2\n")
+            temp_path = f.name
+
+        try:
+            fixer = AutoFixer()
+            result = fixer.apply_regex_fixes(
+                temp_path,
+                r"old_value",
+                "new_value"
+            )
+
+            assert result.success is True
+            with open(temp_path, 'r') as f:
+                content = f.read()
+            assert "new_value = 1" in content
+            assert "new_value = 2" in content
+        finally:
+            os.unlink(temp_path)
+
+    def test_apply_regex_fixes_no_matches(self):
+        """Test regex fix with no matches."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write("other_value = 1\n")
+            temp_path = f.name
+
+        try:
+            fixer = AutoFixer()
+            result = fixer.apply_regex_fixes(
+                temp_path,
+                r"nonexistent",
+                "replacement"
+            )
+
+            assert result.success is True
+            assert result.fixes_applied == 0
+        finally:
+            os.unlink(temp_path)
+
+    def test_remove_debug_imports(self):
+        """Test removing debug imports."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write("import ipdb\nimport pdb\ncode here\n")
+            temp_path = f.name
+
+        try:
+            fixer = AutoFixer()
+            result = fixer.remove_debug_imports(temp_path)
+
+            assert result.success is True
+            with open(temp_path, 'r') as f:
+                content = f.read()
+            assert "# import ipdb" in content
+            assert "# import pdb" in content
+            assert "code here" in content
+        finally:
+            os.unlink(temp_path)
+
+    def test_file_not_found(self):
+        """Test fixing a non-existent file."""
+        fixer = AutoFixer()
+        result = fixer.remove_trailing_whitespace("/nonexistent/file.txt")
+
+        assert result.success is False
+        assert "no such file" in result.error_message.lower() or "not found" in result.error_message.lower()

tests/test_cli.py

@@ -0,0 +1,157 @@
+"""Tests for CLI interface."""
+
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+
+@pytest.fixture
+def cli_runner():
+    """Create a CLI runner for testing."""
+    from typer.testing import CliRunner
+
+    from shell_speak.main import app
+    return CliRunner(), app
+
+
+@pytest.fixture
+def setup_test_env(tmp_path, sample_docker_yaml, sample_git_yaml):
+    """Set up test environment with sample libraries."""
+    docker_file = tmp_path / "docker.yaml"
+    docker_file.write_text(sample_docker_yaml)
+
+    git_file = tmp_path / "git.yaml"
+    git_file.write_text(sample_git_yaml)
+
+    os.environ["SHELL_SPEAK_DATA_DIR"] = str(tmp_path)
+    os.environ["SHELL_SPEAK_HISTORY_FILE"] = str(tmp_path / "history.json")
+    os.environ["SHELL_SPEAK_CORRECTIONS_FILE"] = str(tmp_path / "corrections.json")
+
+
+class TestCLIConvert:
+    """Tests for the convert command."""
+
+    def test_convert_basic_query(self, cli_runner, setup_test_env):
+        """Test basic query conversion."""
+        runner, app = cli_runner
+        result = runner.invoke(
+            app,
+            ["convert", "list running containers"]
+        )
+        assert result.exit_code == 0
+        assert "docker ps" in result.stdout or "docker" in result.stdout.lower()
+
+    def test_convert_with_tool_filter(self, cli_runner, setup_test_env):
+        """Test query with tool filter."""
+        runner, app = cli_runner
+        result = runner.invoke(
+            app,
+            ["convert", "--tool", "docker", "list running containers"]
+        )
+        assert result.exit_code == 0
+        assert "docker" in result.stdout.lower()
+
+    def test_convert_unknown_query(self, cli_runner, setup_test_env):
+        """Test unknown query returns error."""
+        runner, app = cli_runner
+        result = runner.invoke(
+            app,
+            ["convert", "xyz unknown query"]
+        )
+        assert result.exit_code == 0
+        assert "not found" in result.stdout.lower() or "could not" in result.stdout.lower()
+
+
+class TestCLIHistory:
+    """Tests for the history command."""
+
+    def test_history_empty(self, cli_runner, setup_test_env):
+        """Test history with empty entries."""
+        runner, app = cli_runner
+        result = runner.invoke(
+            app,
+            ["history"]
+        )
+        assert result.exit_code == 0
+
+    def test_history_with_limit(self, cli_runner, setup_test_env):
+        """Test history with limit option."""
+        runner, app = cli_runner
+        result = runner.invoke(
+            app,
+            ["history", "--limit", "10"]
+        )
+        assert result.exit_code == 0
+
+
+class TestCLILearn:
+    """Tests for the learn command."""
+
+    def test_learn_new_pattern(self, cli_runner, setup_test_env):
+        """Test learning a new pattern."""
+        runner, app = cli_runner
+        result = runner.invoke(
+            app,
+            ["learn", "test query", "echo test", "--tool", "unix"]
+        )
+        assert result.exit_code == 0
+        assert "learned" in result.stdout.lower() or "test query" in result.stdout
+
+
+class TestCLIForget:
+    """Tests for the forget command."""
+
+    def test_forget_pattern(self, cli_runner, setup_test_env):
+        """Test forgetting a pattern."""
+        runner, app = cli_runner
+        result = runner.invoke(
+            app,
+            ["forget", "test query", "--tool", "unix"]
+        )
+        assert result.exit_code == 0
+
+
+class TestCLIReload:
+    """Tests for the reload command."""
+
+    def test_reload_command(self, cli_runner, setup_test_env):
+        """Test reload command."""
+        runner, app = cli_runner
+        result = runner.invoke(
+            app,
+            ["reload"]
+        )
+        assert result.exit_code == 0
+        assert "reloaded" in result.stdout.lower()
+
+
+class TestCLITools:
+    """Tests for the tools command."""
+
+    def test_tools_command(self, cli_runner):
+        """Test listing available tools."""
+        runner, app = cli_runner
+        result = runner.invoke(
+            app,
+            ["tools"]
+        )
+        assert result.exit_code == 0
+        assert "docker" in result.stdout.lower()
+
+
+class TestCLIVersion:
+    """Tests for version option."""
+
+    def test_version_flag(self, cli_runner):
+        """Test --version flag."""
+        runner, app = cli_runner
+        result = runner.invoke(
+            app,
+            ["--version"]
+        )
+        assert result.exit_code == 0
+        assert "shell speak" in result.stdout.lower() or "version" in result.stdout.lower()

tests/test_cli_commands.py

@@ -0,0 +1,329 @@
+"""Tests for CLI commands."""
+
+import pytest
+from click.testing import CliRunner
+from pathlib import Path
+import tempfile
+import os
+
+
+@pytest.fixture
+def cli_runner():
+    """Create a Click CLI runner."""
+    return CliRunner()
+
+
+@pytest.fixture
+def project_runner(temp_dir, cli_runner):
+    """Create a CLI runner with a temporary project."""
+    os.chdir(temp_dir)
+    yield cli_runner
+    os.chdir("/")
+
+
+class TestInitCommand:
+    """Tests for init command."""
+
+    def test_init_creates_structure(self, temp_dir, cli_runner):
+        """Test that init creates the required directory structure."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["init"])
+
+            assert result.exit_code == 0, f"Error: {result.output}"
+            assert (temp_dir / ".env-profiles").exists()
+            assert (temp_dir / ".env-profiles" / ".active").exists()
+            assert (temp_dir / ".env-profiles" / "default" / ".env").exists()
+        finally:
+            os.chdir("/")
+
+    def test_init_with_template(self, temp_dir, cli_runner):
+        """Test init with a template."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["init", "--template", "fastapi"])
+
+            assert result.exit_code == 0
+            content = (temp_dir / ".env-profiles" / "default" / ".env").read_text()
+            assert "APP_NAME" in content or result.exit_code == 0
+        finally:
+            os.chdir("/")
+
+
+class TestProfileCommands:
+    """Tests for profile commands."""
+
+    def test_profile_create(self, temp_dir, cli_runner):
+        """Test creating a new profile."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["init"])
+            result = cli_runner.invoke(main, ["profile", "create", "staging"])
+            assert result.exit_code == 0, f"Error: {result.output}"
+            assert (temp_dir / ".env-profiles" / "staging").exists()
+        finally:
+            os.chdir("/")
+
+    def test_profile_list(self, temp_dir, cli_runner):
+        """Test listing profiles."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["init"])
+            result = cli_runner.invoke(main, ["profile", "list"])
+            assert result.exit_code == 0
+            assert "default" in result.output
+        finally:
+            os.chdir("/")
+
+    def test_profile_use(self, temp_dir, cli_runner):
+        """Test setting active profile."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["init"])
+            result = cli_runner.invoke(main, ["profile", "create", "prod"])
+            assert result.exit_code == 0
+
+            result = cli_runner.invoke(main, ["profile", "use", "prod"])
+            assert result.exit_code == 0
+
+            active = (temp_dir / ".env-profiles" / ".active").read_text()
+            assert active == "prod"
+        finally:
+            os.chdir("/")
+
+    def test_profile_delete(self, temp_dir, cli_runner):
+        """Test deleting a profile."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["init"])
+            result = cli_runner.invoke(main, ["profile", "create", "test"])
+            assert result.exit_code == 0
+
+            result = cli_runner.invoke(main, ["profile", "delete", "test", "--force"])
+            assert result.exit_code == 0
+            assert not (temp_dir / ".env-profiles" / "test").exists()
+        finally:
+            os.chdir("/")
+
+
+class TestVariableCommands:
+    """Tests for variable commands."""
+
+    def test_add_variable(self, temp_dir, cli_runner):
+        """Test adding a variable."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["init"])
+            result = cli_runner.invoke(main, ["add", "DATABASE_URL", "postgresql://localhost/db"])
+            assert result.exit_code == 0, f"Error: {result.output}"
+
+            env_file = temp_dir / ".env-profiles" / "default" / ".env"
+            content = env_file.read_text()
+            assert "DATABASE_URL" in content
+        finally:
+            os.chdir("/")
+
+    def test_set_variable(self, temp_dir, cli_runner):
+        """Test setting a variable."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["init"])
+            result = cli_runner.invoke(main, ["add", "DEBUG", "true"])
+            assert result.exit_code == 0
+
+            result = cli_runner.invoke(main, ["set", "DEBUG", "false"])
+            assert result.exit_code == 0
+
+            env_file = temp_dir / ".env-profiles" / "default" / ".env"
+            content = env_file.read_text()
+            assert "DEBUG=" in content
+        finally:
+            os.chdir("/")
+
+    def test_list_variables(self, temp_dir, cli_runner):
+        """Test listing variables."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["init"])
+            result = cli_runner.invoke(main, ["add", "TEST_VAR", "test-value"])
+            assert result.exit_code == 0
+
+            result = cli_runner.invoke(main, ["list"])
+            assert result.exit_code == 0
+            assert "TEST_VAR" in result.output
+        finally:
+            os.chdir("/")
+
+    def test_get_variable(self, temp_dir, cli_runner):
+        """Test getting a variable."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["init"])
+            result = cli_runner.invoke(main, ["add", "MY_VAR", "my-value"])
+            assert result.exit_code == 0
+
+            result = cli_runner.invoke(main, ["get", "MY_VAR"])
+            assert result.exit_code == 0
+            assert "my-value" in result.output
+        finally:
+            os.chdir("/")
+
+    def test_delete_variable(self, temp_dir, cli_runner):
+        """Test deleting a variable."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["init"])
+            result = cli_runner.invoke(main, ["add", "TO_DELETE", "value"])
+            assert result.exit_code == 0
+
+            result = cli_runner.invoke(main, ["delete", "TO_DELETE"])
+            assert result.exit_code == 0
+
+            result = cli_runner.invoke(main, ["get", "TO_DELETE"])
+            assert result.exit_code != 0 or "not found" in result.output.lower()
+        finally:
+            os.chdir("/")
+
+
+class TestTemplateCommands:
+    """Tests for template commands."""
+
+    def test_template_list(self, temp_dir, cli_runner):
+        """Test listing templates."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["template", "list"])
+            assert result.exit_code == 0
+            assert "fastapi" in result.output or "minimal" in result.output
+        finally:
+            os.chdir("/")
+
+    def test_template_show(self, temp_dir, cli_runner):
+        """Test showing template details."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["template", "show", "minimal"])
+            assert result.exit_code == 0
+            assert "Template:" in result.output
+        finally:
+            os.chdir("/")
+
+
+class TestValidationCommands:
+    """Tests for validation commands."""
+
+    def test_validate_no_schema(self, temp_dir, cli_runner):
+        """Test validation when no schema exists."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["validate"])
+            assert result.exit_code == 0 or "No schema" in result.output or "Validation error" in result.output
+        finally:
+            os.chdir("/")
+
+    def test_check_no_schema(self, temp_dir, cli_runner):
+        """Test check when no schema exists."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["check"])
+            assert result.exit_code == 0 or "No schema" in result.output or "Check error" in result.output
+        finally:
+            os.chdir("/")
+
+
+class TestExportCommands:
+    """Tests for export commands."""
+
+    def test_export_shell_format(self, temp_dir, cli_runner):
+        """Test exporting variables in shell format."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["init"])
+            result = cli_runner.invoke(main, ["add", "TEST_VAR", "test-value"])
+            assert result.exit_code == 0
+
+            result = cli_runner.invoke(main, ["export", "--format", "shell"])
+            assert result.exit_code == 0
+            assert "TEST_VAR=test-value" in result.output
+        finally:
+            os.chdir("/")
+
+    def test_export_json_format(self, temp_dir, cli_runner):
+        """Test exporting variables in JSON format."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["init"])
+            result = cli_runner.invoke(main, ["add", "JSON_VAR", "json-value"])
+            assert result.exit_code == 0
+
+            result = cli_runner.invoke(main, ["export", "--format", "json"])
+            assert result.exit_code == 0
+            assert "JSON_VAR" in result.output
+        finally:
+            os.chdir("/")
+
+
+class TestGitOpsCommands:
+    """Tests for GitOps commands."""
+
+    def test_gitignore_output(self, temp_dir, cli_runner):
+        """Test gitignore generation."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["gitignore"])
+            assert result.exit_code == 0
+            assert ".env-profiles" in result.output
+        finally:
+            os.chdir("/")
+
+    def test_example_output(self, temp_dir, cli_runner):
+        """Test .env.example generation."""
+        from env_pro.cli import main
+
+        os.chdir(temp_dir)
+        try:
+            result = cli_runner.invoke(main, ["init"])
+            result = cli_runner.invoke(main, ["add", "EXAMPLE_VAR", "example-value"])
+            assert result.exit_code == 0
+
+            result = cli_runner.invoke(main, ["example"])
+            assert result.exit_code == 0
+            assert "EXAMPLE_VAR" in result.output
+        finally:
+            os.chdir("/")

tests/test_command_library.py

@@ -0,0 +1,128 @@
+"""Tests for command library loader."""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+
+class TestCommandLibraryLoader:
+    """Tests for CommandLibraryLoader class."""
+
+    @pytest.fixture(autouse=True)
+    def setup(self, tmp_path, sample_docker_yaml, sample_git_yaml):
+        self.test_dir = tmp_path
+
+        docker_file = self.test_dir / "docker.yaml"
+        docker_file.write_text(sample_docker_yaml)
+
+        git_file = self.test_dir / "git.yaml"
+        git_file.write_text(sample_git_yaml)
+
+        os.environ["SHELL_SPEAK_DATA_DIR"] = str(self.test_dir)
+
+    def test_load_docker_library(self):
+        from shell_speak.library import get_loader
+
+        loader = get_loader()
+        loader._loaded = False
+        loader.load_library("docker")
+
+        patterns = loader.get_patterns()
+        assert len(patterns) > 0
+        assert any(p.tool == "docker" for p in patterns)
+
+    def test_load_git_library(self):
+        from shell_speak.library import get_loader
+
+        loader = get_loader()
+        loader._loaded = False
+        loader.load_library("git")
+
+        patterns = loader.get_patterns()
+        assert len(patterns) > 0
+        assert any(p.tool == "git" for p in patterns)
+
+    def test_load_all_libraries(self):
+        from shell_speak.library import get_loader
+
+        loader = get_loader()
+        loader._loaded = False
+        loader.load_library()
+
+        patterns = loader.get_patterns()
+        docker_patterns = [p for p in patterns if p.tool == "docker"]
+        git_patterns = [p for p in patterns if p.tool == "git"]
+        assert len(docker_patterns) > 0
+        assert len(git_patterns) > 0
+
+    def test_pattern_structure(self):
+        from shell_speak.library import get_loader
+
+        loader = get_loader()
+        loader._loaded = False
+        loader.load_library("docker")
+
+        patterns = loader.get_patterns()
+        if patterns:
+            pattern = patterns[0]
+            assert hasattr(pattern, "name")
+            assert hasattr(pattern, "tool")
+            assert hasattr(pattern, "template")
+            assert hasattr(pattern, "patterns")
+
+    def test_corrections(self, tmp_path, sample_corrections_json):
+        from shell_speak.library import get_loader
+
+        corrections_file = tmp_path / "corrections.json"
+        corrections_file.write_text(json.dumps(sample_corrections_json))
+
+        os.environ["SHELL_SPEAK_DATA_DIR"] = str(tmp_path)
+
+        loader = get_loader()
+        loader._loaded = False
+        loader.load_library()
+
+        corrections = loader.get_corrections()
+        assert "custom:my custom query" in corrections
+        assert corrections["custom:my custom query"] == "echo custom command"
+
+    def test_add_correction(self):
+        from shell_speak.library import get_loader
+
+        loader = get_loader()
+        loader._loaded = False
+        loader.load_library()
+
+        loader.add_correction("new query", "echo new", "unix")
+        corrections = loader.get_corrections()
+        assert "unix:new query" in corrections
+
+    def test_remove_correction(self):
+        from shell_speak.library import get_loader
+
+        loader = get_loader()
+        loader._loaded = False
+        loader.load_library()
+
+        loader.add_correction("test query", "echo test", "unix")
+        loader.remove_correction("test query", "unix")
+
+        corrections = loader.get_corrections()
+        assert "unix:test query" not in corrections
+
+    def test_reload(self):
+        from shell_speak.library import get_loader
+
+        loader = get_loader()
+        loader.load_library()
+        initial_count = len(loader.get_patterns())
+
+        loader.reload()
+        reload_count = len(loader.get_patterns())
+
+        assert initial_count == reload_count

tests/test_diff_parser.py

@@ -0,0 +1,250 @@
+"""Tests for the diff parser module."""
+
+import pytest
+from cli_diff_auditor.diff_parser import (
+    ChangeType,
+    DiffHunk,
+    DiffLine,
+    DiffParser,
+    FileDiff,
+)
+
+
+class TestDiffParser:
+    """Test cases for DiffParser class."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.parser = DiffParser()
+
+    def test_parse_empty_diff(self):
+        """Test parsing an empty diff."""
+        result = self.parser.parse_diff("")
+        assert result == []
+
+    def test_parse_none_diff(self):
+        """Test parsing a None-like diff."""
+        result = self.parser.parse_diff("   ")
+        assert result == []
+
+    def test_parse_simple_diff(self):
+        """Test parsing a simple file modification diff."""
+        diff_output = """diff --git a/test.py b/test.py
+index 1234567..89abcdef 100644
+--- a/test.py
++++ b/test.py
+@@ -1,3 +1,3 @@
+ line 1
+-old line
++new line
+ line 3
+"""
+        result = self.parser.parse_diff(diff_output)
+
+        assert len(result) == 1
+        assert result[0].file_path == "test.py"
+        assert result[0].change_type == ChangeType.MODIFIED
+
+    def test_parse_added_file_diff(self):
+        """Test parsing a diff for a newly added file."""
+        diff_output = """diff --git a/newfile.py b/newfile.py
+new file mode 100644
+index 0000000..1234567
+--- /dev/null
++++ b/newfile.py
+@@ -0,0 +1,2 @@
++line 1
++line 2
+"""
+        result = self.parser.parse_diff(diff_output)
+
+        assert len(result) == 1
+        assert result[0].change_type == ChangeType.ADDED
+        assert result[0].file_path == "newfile.py"
+
+    def test_parse_deleted_file_diff(self):
+        """Test parsing a diff for a deleted file."""
+        diff_output = """diff --git a/oldfile.py b/oldfile.py
+deleted file mode 100644
+index 1234567..0000000
+--- a/oldfile.py
++++ /dev/null
+@@ -1,2 +0,0 @@
+-line 1
+-line 2
+"""
+        result = self.parser.parse_diff(diff_output)
+
+        assert len(result) == 1
+        assert result[0].change_type == ChangeType.DELETED
+
+    def test_parse_multiple_files(self):
+        """Test parsing a diff with multiple files."""
+        diff_output = """diff --git a/file1.py b/file1.py
+index 1234567..89abcdef 100644
+--- a/file1.py
++++ b/file1.py
+@@ -1,2 +1,2 @@
+-old
++new
+
+diff --git a/file2.py b/file2.py
+index abcdefg..1234567 100644
+--- a/file2.py
++++ b/file2.py
+@@ -1,2 +1,2 @@
+-old2
++new2
+"""
+        result = self.parser.parse_diff(diff_output)
+
+        assert len(result) == 2
+        assert result[0].file_path == "file1.py"
+        assert result[1].file_path == "file2.py"
+
+    def test_extract_line_content(self):
+        """Test extracting line contents from a file diff."""
+        diff_output = """diff --git a/test.py b/test.py
+index 1234567..89abcdef 100644
+--- a/test.py
++++ b/test.py
+@@ -1,5 +1,5 @@
+ context line
+-old line
++new line 1
++new line 2
+ context line 2
+-old line 2
++new line 3
+ context line 3
+"""
+        result = self.parser.parse_diff(diff_output)
+
+        assert len(result) == 1
+        file_diff = result[0]
+
+        lines = self.parser.extract_line_content(file_diff)
+
+        assert len(lines) == 5
+        assert all(isinstance(line, tuple) and len(line) == 3 for line in lines)
+        changed_types = [line[2] for line in lines]
+        assert ChangeType.ADDED in changed_types
+        assert ChangeType.DELETED in changed_types
+
+    def test_get_changed_lines(self):
+        """Test getting only changed lines from a hunk."""
+        diff_output = """diff --git a/test.py b/test.py
+index 1234567..89abcdef 100644
+--- a/test.py
++++ b/test.py
+@@ -1,4 +1,5 @@
+ context
+-added
++modified
++another added
+ context again
+-deleted
+ final context
+"""
+        result = self.parser.parse_diff(diff_output)
+
+        assert len(result) == 1
+        file_diff = result[0]
+
+        assert len(file_diff.hunks) == 1
+        hunk = file_diff.hunks[0]
+
+        changed_lines = hunk.get_changed_lines()
+
+        assert len(changed_lines) == 4
+        for line in changed_lines:
+            assert line.is_context is False
+
+    def test_hunk_attributes(self):
+        """Test that hunk header attributes are correctly parsed."""
+        diff_output = """diff --git a/test.py b/test.py
+index 1234567..89abcdef 100644
+--- a/test.py
++++ b/test.py
+@@ -5,10 +7,15 @@
+"""
+        result = self.parser.parse_diff(diff_output)
+
+        assert len(result) == 1
+        hunk = result[0].hunks[0]
+
+        assert hunk.old_start == 5
+        assert hunk.old_lines == 10
+        assert hunk.new_start == 7
+        assert hunk.new_lines == 15
+
+
+class TestDiffLine:
+    """Test cases for DiffLine class."""
+
+    def test_diff_line_creation(self):
+        """Test creating a DiffLine instance."""
+        line = DiffLine(
+            line_number=10,
+            content="print('hello')",
+            change_type=ChangeType.ADDED
+        )
+
+        assert line.line_number == 10
+        assert line.content == "print('hello')"
+        assert line.change_type == ChangeType.ADDED
+        assert line.is_context is False
+
+    def test_diff_line_context(self):
+        """Test creating a context DiffLine."""
+        line = DiffLine(
+            line_number=5,
+            content="def foo():",
+            change_type=ChangeType.MODIFIED,
+            is_context=True
+        )
+
+        assert line.is_context is True
+
+
+class TestFileDiff:
+    """Test cases for FileDiff class."""
+
+    def test_get_added_lines(self):
+        """Test getting only added lines from a file diff."""
+        file_diff = FileDiff(
+            file_path="test.py",
+            change_type=ChangeType.MODIFIED
+        )
+
+        hunk = DiffHunk(old_start=1, old_lines=3, new_start=1, new_lines=4)
+        hunk.lines = [
+            DiffLine(line_number=1, content="old", change_type=ChangeType.DELETED),
+            DiffLine(line_number=2, content="new", change_type=ChangeType.ADDED),
+            DiffLine(line_number=3, content="context", change_type=ChangeType.MODIFIED, is_context=True),
+        ]
+        file_diff.hunks.append(hunk)
+
+        added_lines = file_diff.get_added_lines()
+
+        assert len(added_lines) == 1
+        assert added_lines[0].change_type == ChangeType.ADDED
+
+    def test_get_deleted_lines(self):
+        """Test getting only deleted lines from a file diff."""
+        file_diff = FileDiff(
+            file_path="test.py",
+            change_type=ChangeType.MODIFIED
+        )
+
+        hunk = DiffHunk(old_start=1, old_lines=3, new_start=1, new_lines=2)
+        hunk.lines = [
+            DiffLine(line_number=1, content="old", change_type=ChangeType.DELETED),
+            DiffLine(line_number=2, content="new", change_type=ChangeType.ADDED),
+        ]
+        file_diff.hunks.append(hunk)
+
+        deleted_lines = file_diff.get_deleted_lines()
+
+        assert len(deleted_lines) == 1
+        assert deleted_lines[0].change_type == ChangeType.DELETED

tests/test_encryption.py

@@ -0,0 +1,111 @@
+"""Tests for encryption module."""
+
+import pytest
+from pathlib import Path
+import tempfile
+
+
+class TestEncryption:
+    """Test cases for encryption module."""
+
+    def test_derive_key(self):
+        """Test key derivation from passphrase."""
+        from env_pro.core.encryption import derive_key, generate_salt
+
+        passphrase = "test-passphrase"
+        salt = generate_salt()
+
+        key1 = derive_key(passphrase, salt)
+        key2 = derive_key(passphrase, salt)
+
+        assert len(key1) == 32
+        assert key1 == key2
+
+    def test_generate_key(self):
+        """Test random key generation."""
+        from env_pro.core.encryption import generate_key, verify_key
+
+        key = generate_key()
+        assert verify_key(key)
+        assert len(key) == 32
+
+    def test_generate_salt(self):
+        """Test salt generation."""
+        from env_pro.core.encryption import generate_salt
+
+        salt = generate_salt()
+        assert len(salt) == 16
+
+    def test_generate_nonce(self):
+        """Test nonce generation."""
+        from env_pro.core.encryption import generate_nonce
+
+        nonce = generate_nonce()
+        assert len(nonce) == 12
+
+    def test_encrypt_decrypt_value(self, mocker):
+        """Test encryption and decryption of a value."""
+        from env_pro.core.encryption import (
+            encrypt_value, decrypt_value, generate_key, store_key_in_keyring
+        )
+
+        mocker.patch('keyring.set_password', return_value=None)
+        mocker.patch('keyring.get_password', return_value=None)
+
+        key = generate_key()
+        store_key_in_keyring(key)
+
+        original = "my-secret-value"
+        encrypted = encrypt_value(original, key)
+        decrypted = decrypt_value(encrypted, key)
+
+        assert decrypted == original
+        assert encrypted != original
+
+    def test_encrypt_value_different_each_time(self):
+        """Test that encryption produces different outputs."""
+        from env_pro.core.encryption import encrypt_value, generate_key
+
+        key = generate_key()
+        original = "same-value"
+
+        encrypted1 = encrypt_value(original, key)
+        encrypted2 = encrypt_value(original, key)
+
+        assert encrypted1 != encrypted2
+
+    def test_encrypt_file_structure(self):
+        """Test file encryption produces valid structure."""
+        from env_pro.core.encryption import encrypt_file, generate_key
+
+        key = generate_key()
+        content = "DATABASE_URL=postgresql://localhost:5432/db\nDEBUG=true"
+
+        result = encrypt_file(content, key)
+
+        assert "salt" in result
+        assert "nonce" in result
+        assert "ciphertext" in result
+
+    def test_decrypt_file(self):
+        """Test file decryption."""
+        from env_pro.core.encryption import encrypt_file, decrypt_file, generate_key
+
+        key = generate_key()
+        original = "SECRET_KEY=my-secret\nAPI_KEY=12345"
+
+        encrypted = encrypt_file(original, key)
+        decrypted = decrypt_file(encrypted, key)
+
+        assert decrypted == original
+
+
+class TestEncryptionErrors:
+    """Test cases for encryption errors."""
+
+    def test_invalid_encrypted_value(self):
+        """Test decryption of invalid data."""
+        from env_pro.core.encryption import decrypt_value, EncryptionError
+
+        with pytest.raises(EncryptionError):
+            decrypt_value("invalid-base64-data!!!")

tests/test_explainer.py

@@ -0,0 +1,126 @@
+"""Tests for the explainer module."""
+
+from cli_explain_fix.parser import ErrorParser
+from cli_explain_fix.explainer import Explainer
+from cli_explain_fix.knowledge_base import KnowledgeBase
+
+
+class TestExplainer:
+    """Test cases for Explainer."""
+
+    def setup_method(self):
+        """Set up explainer instance for each test."""
+        self.parser = ErrorParser()
+        self.kb = KnowledgeBase()
+        self.explainer = Explainer(self.kb)
+
+    def test_explain_python_error(self, sample_python_simple_error):
+        """Test explaining a Python error."""
+        parsed = self.parser.parse(sample_python_simple_error)
+        explanation = self.explainer.explain(parsed)
+
+        assert "error_type" in explanation
+        assert "language" in explanation
+        assert "summary" in explanation
+        assert "what_happened" in explanation
+        assert "why_happened" in explanation
+        assert "how_to_fix" in explanation
+
+        assert explanation["error_type"] == "ValueError"
+        assert explanation["language"] == "python"
+
+    def test_explain_python_traceback(self, sample_python_traceback):
+        """Test explaining Python traceback."""
+        parsed = self.parser.parse(sample_python_traceback)
+        explanation = self.explainer.explain(parsed)
+
+        assert explanation["error_type"] == "ModuleNotFoundError"
+        assert explanation["language"] == "python"
+        assert "location" in explanation
+        assert "/app/main.py" in explanation["location"]["file"]
+        assert explanation["location"]["line"] == 10
+
+    def test_explain_javascript_error(self, sample_js_error):
+        """Test explaining JavaScript error."""
+        parsed = self.parser.parse(sample_js_error)
+        explanation = self.explainer.explain(parsed)
+
+        assert explanation["error_type"] == "TypeError"
+        assert explanation["language"] == "javascript"
+
+    def test_explain_verbose_mode(self, sample_python_simple_error):
+        """Test explaining with verbose flag."""
+        parsed = self.parser.parse(sample_python_simple_error)
+        explanation = self.explainer.explain(parsed, verbose=True)
+
+        assert "raw_error" in explanation
+
+    def test_explain_without_verbose(self, sample_python_simple_error):
+        """Test explaining without verbose flag."""
+        parsed = self.parser.parse(sample_python_simple_error)
+        explanation = self.explainer.explain(parsed, verbose=False)
+
+        assert "raw_error" not in explanation
+
+    def test_explain_with_stack_trace(self, sample_python_traceback):
+        """Test explaining error with stack frames."""
+        parsed = self.parser.parse(sample_python_traceback)
+        explanation = self.explainer.explain(parsed)
+
+        assert "stack_trace" in explanation
+        assert len(explanation["stack_trace"]) > 0
+
+    def test_explain_with_code_examples(self, sample_python_simple_error):
+        """Test that code examples are included."""
+        parsed = self.parser.parse(sample_python_simple_error)
+        explanation = self.explainer.explain(parsed)
+
+        if "code_examples" in explanation:
+            assert isinstance(explanation["code_examples"], list)
+
+    def test_explain_simple(self, sample_python_simple_error):
+        """Test simple text explanation."""
+        result = self.explainer.explain_simple(
+            "ValueError",
+            "invalid value for int()",
+            "python"
+        )
+
+        assert "Error: ValueError" in result
+        assert "Language: python" in result
+        assert "What happened:" in result
+        assert "How to fix:" in result
+
+    def test_get_fix_steps(self, sample_python_simple_error):
+        """Test getting fix steps for an error."""
+        parsed = self.parser.parse(sample_python_simple_error)
+        steps = self.explainer.get_fix_steps(parsed)
+
+        assert isinstance(steps, list)
+        assert len(steps) > 0
+
+    def test_explain_unknown_error(self, sample_unknown_error):
+        """Test explaining an unknown error type."""
+        parsed = self.parser.parse(sample_unknown_error)
+        explanation = self.explainer.explain(parsed)
+
+        assert "error_type" in explanation
+        assert "what_happened" in explanation
+        assert "how_to_fix" in explanation
+
+
+class TestExplainerSummary:
+    """Test cases for explanation summary generation."""
+
+    def test_summary_format(self, sample_python_simple_error):
+        """Test summary format is correct."""
+        parser = ErrorParser()
+        kb = KnowledgeBase()
+        explainer = Explainer(kb)
+
+        parsed = parser.parse(sample_python_simple_error)
+        explanation = explainer.explain(parsed)
+
+        summary = explanation["summary"]
+        assert "ValueError" in summary
+        assert "python" in summary

tests/test_generators.py

@@ -0,0 +1,214 @@
+"""Tests for generators module."""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from doc2man.generators.man import generate_man_page, ManPageValidator, get_man_title
+from doc2man.generators.markdown import generate_markdown, MarkdownValidator, get_md_title
+from doc2man.generators.html import generate_html, HTMLValidator, get_html_title
+
+
+class TestManPageGenerator:
+    """Tests for man page generator."""
+
+    def test_generate_man_page_basic(self):
+        """Test basic man page generation."""
+        data = [
+            {
+                "file": "example.py",
+                "data": {
+                    "title": "Example Command",
+                    "description": "An example command for testing.",
+                    "functions": [
+                        {
+                            "name": "example",
+                            "description": "An example function.",
+                            "args": [
+                                {"name": "--input", "type": "string", "description": "Input file path"}
+                            ],
+                            "examples": ["example --input file.txt"]
+                        }
+                    ]
+                }
+            }
+        ]
+
+        with tempfile.NamedTemporaryFile(suffix=".1", delete=False) as f:
+            output_path = Path(f.name)
+            result = generate_man_page(data, output_path)
+
+            assert ".TH" in result
+            assert "EXAMPLE" in result
+            assert "NAME" in result
+            assert "example" in result.lower()
+
+            output_path.unlink()
+
+    def test_man_page_validator(self):
+        """Test man page validation."""
+        content = """
+.TH EXAMPLE 1
+.SH NAME
+example \- An example command
+.SH DESCRIPTION
+This is a description.
+"""
+        warnings = ManPageValidator.validate(content)
+
+        assert len(warnings) == 0
+
+    def test_man_page_validator_missing_th(self):
+        """Test validation with missing .TH macro."""
+        content = """
+.SH NAME
+example \- An example command
+.SH DESCRIPTION
+This is a description.
+"""
+        warnings = ManPageValidator.validate(content)
+
+        assert any("TH" in w for w in warnings)
+
+    def test_get_man_title(self):
+        """Test extracting man page title."""
+        data = [{"data": {"title": "Test Command"}}]
+        assert get_man_title(data) == "Test Command"
+
+        data = [{"data": {"functions": [{"name": "func1"}]}}]
+        assert get_man_title(data) == "func1"
+
+
+class TestMarkdownGenerator:
+    """Tests for markdown generator."""
+
+    def test_generate_markdown_basic(self):
+        """Test basic markdown generation."""
+        data = [
+            {
+                "file": "example.py",
+                "data": {
+                    "title": "Example Command",
+                    "description": "An example command for testing.",
+                    "functions": [
+                        {
+                            "name": "example",
+                            "description": "An example function.",
+                            "args": [
+                                {"name": "input", "type": "string", "description": "Input file"}
+                            ],
+                            "returns": {"type": "str", "description": "Result string"},
+                            "examples": ["example()"]
+                        }
+                    ]
+                }
+            }
+        ]
+
+        with tempfile.NamedTemporaryFile(suffix=".md", delete=False) as f:
+            output_path = Path(f.name)
+            result = generate_markdown(data, output_path)
+
+            assert "# Example Command" in result
+            assert "## Functions" in result
+            assert "### `example`" in result
+            assert "Parameters" in result
+            assert "| `input` |" in result
+
+            output_path.unlink()
+
+    def test_markdown_validator(self):
+        """Test markdown validation."""
+        content = """# Title
+
+Some content.
+"""
+        warnings = MarkdownValidator.validate(content)
+        assert len(warnings) == 0
+
+    def test_markdown_validator_no_header(self):
+        """Test validation with no header."""
+        content = """Some content without header.
+"""
+        warnings = MarkdownValidator.validate(content)
+
+        assert any("header" in w.lower() for w in warnings)
+
+    def get_md_title(self):
+        """Test extracting markdown title."""
+        data = [{"data": {"title": "Test Doc"}}]
+        assert get_md_title(data) == "Test Doc"
+
+
+class TestHTMLGenerator:
+    """Tests for HTML generator."""
+
+    def test_generate_html_basic(self):
+        """Test basic HTML generation."""
+        data = [
+            {
+                "file": "example.py",
+                "data": {
+                    "title": "Example Command",
+                    "description": "An example command for testing.",
+                    "functions": [
+                        {
+                            "name": "example",
+                            "description": "An example function.",
+                            "args": [
+                                {"name": "input", "type": "string", "description": "Input file"}
+                            ],
+                            "examples": ["example()"]
+                        }
+                    ]
+                }
+            }
+        ]
+
+        with tempfile.NamedTemporaryFile(suffix=".html", delete=False) as f:
+            output_path = Path(f.name)
+            result = generate_html(data, output_path)
+
+            assert "<!DOCTYPE html>" in result
+            assert "<title>Example Command</title>" in result
+            assert "<h1>Example Command</h1>" in result
+            assert "<h3 id=\"example\">example</h3>" in result
+            assert "<table>" in result
+
+            output_path.unlink()
+
+    def test_html_validator(self):
+        """Test HTML validation."""
+        content = """<!DOCTYPE html>
+<html>
+<head>
+    <title>Test</title>
+</head>
+<body>
+    Content
+</body>
+</html>
+"""
+        warnings = HTMLValidator.validate(content)
+        assert len(warnings) == 0
+
+    def test_html_validator_missing_doctype(self):
+        """Test validation with missing DOCTYPE."""
+        content = """<html>
+<head>
+    <title>Test</title>
+</head>
+<body>
+    Content
+</body>
+</html>
+"""
+        warnings = HTMLValidator.validate(content)
+
+        assert any("DOCTYPE" in w for w in warnings)
+
+    def get_html_title(self):
+        """Test extracting HTML title."""
+        data = [{"data": {"title": "Test Doc"}}]
+        assert get_html_title(data) == "Test Doc"

tests/test_integration.py

@@ -0,0 +1,234 @@
+"""Integration tests for the diff auditor."""
+
+import os
+import tempfile
+from pathlib import Path
+
+import pytest
+from click.testing import CliRunner
+from git import Repo
+
+from cli_diff_auditor.cli import main
+from cli_diff_auditor.hook import PreCommitHookManager
+
+
+class TestGitIntegration:
+    """Integration tests with git repository."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.runner = CliRunner()
+
+    @pytest.fixture
+    def temp_repo(self):
+        """Create a temporary git repository."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            repo = Repo.init(tmpdir)
+            yield tmpdir, repo
+
+    def test_audit_in_empty_repo(self, temp_repo):
+        """Test audit in a repository with no commits."""
+        tmpdir, repo = temp_repo
+
+        result = self.runner.invoke(main, ["audit"], catch_exceptions=False)
+
+        assert result.exit_code == 0
+
+    def test_audit_with_staged_debug_print(self, temp_repo):
+        """Test audit detects staged debug print."""
+        tmpdir, repo = temp_repo
+
+        test_file = Path(tmpdir) / "test.py"
+        test_file.write_text("print('hello')\n")
+
+        repo.index.add(["test.py"])
+        repo.index.commit("Initial commit")
+
+        test_file.write_text("print('world')\n")
+        repo.index.add(["test.py"])
+
+        result = self.runner.invoke(main, ["audit"], catch_exceptions=False)
+
+        assert result.exit_code == 0
+
+    def test_hook_install_and_check(self, temp_repo):
+        """Test installing and checking the hook."""
+        tmpdir, repo = temp_repo
+
+        manager = PreCommitHookManager()
+        result = manager.install_hook(tmpdir)
+
+        assert result.success is True
+
+        installed = manager.check_hook_installed(tmpdir)
+        assert installed is True
+
+    def test_hook_remove(self, temp_repo):
+        """Test removing the hook."""
+        tmpdir, repo = temp_repo
+
+        manager = PreCommitHookManager()
+        manager.install_hook(tmpdir)
+
+        result = manager.remove_hook(tmpdir)
+
+        assert result.success is True
+        assert manager.check_hook_installed(tmpdir) is False
+
+
+class TestAutoFixIntegration:
+    """Integration tests for auto-fix functionality."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.runner = CliRunner()
+
+    def test_fix_trailing_whitespace_integration(self):
+        """Test fixing trailing whitespace in actual file."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write("def hello():\n    return 'world'   \n")
+            temp_path = f.name
+
+        try:
+            result = self.runner.invoke(main, ["fix", temp_path])
+
+            assert result.exit_code == 0
+            content = Path(temp_path).read_text()
+            assert content == "def hello():\n    return 'world'\n"
+        finally:
+            os.unlink(temp_path)
+
+    def test_fix_notimplemented_integration(self):
+        """Test fixing NotImplemented in actual file."""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write("def foo():\n    raise NotImplemented\n")
+            temp_path = f.name
+
+        try:
+            from cli_diff_auditor.autofix import AutoFixer
+            fixer = AutoFixer()
+            result = fixer.fix_notimplemented_error(temp_path)
+
+            assert result.success is True
+            content = Path(temp_path).read_text()
+            assert "raise NotImplementedError" in content
+        finally:
+            os.unlink(temp_path)
+
+
+class TestConfigurationIntegration:
+    """Integration tests for configuration loading."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.runner = CliRunner()
+
+    def test_load_custom_rules(self):
+        """Test loading custom rules from config."""
+        config_content = """
+rules:
+  - id: custom-test
+    name: Custom Test
+    description: A custom test rule
+    pattern: "CUSTOM.*"
+    severity: warning
+    category: custom
+"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f:
+            f.write(config_content)
+            config_path = f.name
+
+        try:
+            result = self.runner.invoke(main, ["--config", config_path, "rules"])
+
+            assert result.exit_code == 0
+            assert "custom-test" in result.output
+        finally:
+            os.unlink(config_path)
+
+    def test_nonexistent_config(self):
+        """Test handling non-existent config file."""
+        result = self.runner.invoke(main, ["--config", "/nonexistent/config.yaml", "rules"])
+
+        assert result.exit_code == 0
+
+
+class TestEdgeCasesIntegration:
+    """Integration tests for edge cases."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.runner = CliRunner()
+
+    def test_empty_diff_audit(self):
+        """Test auditing empty diff."""
+        result = self.runner.invoke(main, ["audit-diff", ""])
+
+        assert result.exit_code == 0
+
+    def test_audit_binary_file_ignored(self, temp_repo):
+        """Test that binary files are skipped."""
+        tmpdir, repo = temp_repo
+
+        test_file = Path(tmpdir) / "image.png"
+        test_file.write_bytes(b"\x89PNG\r\n\x1a\n\x00\x00\x00\rIHDR")
+
+        repo.index.add(["image.png"])
+        repo.index.commit("Add binary file")
+
+        result = self.runner.invoke(main, ["audit"], catch_exceptions=False)
+
+        assert result.exit_code == 0
+
+    def test_audit_multiple_files(self, temp_repo):
+        """Test auditing multiple files."""
+        tmpdir, repo = temp_repo
+
+        file1 = Path(tmpdir) / "file1.py"
+        file1.write_text("print('hello')\n")
+        file2 = Path(tmpdir) / "file2.py"
+        file2.write_text("console.log('world')\n")
+
+        repo.index.add(["file1.py", "file2.py"])
+        repo.index.commit("Add files")
+
+        file1.write_text("print('updated')\n")
+        file2.write_text("console.log('updated')\n")
+        repo.index.add(["file1.py", "file2.py"])
+
+        result = self.runner.invoke(main, ["audit"], catch_exceptions=False)
+
+        assert result.exit_code == 0
+
+    @pytest.fixture
+    def temp_repo(self):
+        """Create a temporary git repository."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            repo = Repo.init(tmpdir)
+            yield tmpdir, repo
+
+
+class TestCLIFailLevel:
+    """Test CLI fail level option."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.runner = CliRunner()
+
+    def test_fail_level_error(self):
+        """Test fail-level error option."""
+        result = self.runner.invoke(main, ["check", "--fail-level", "error"])
+
+        assert result.exit_code == 0
+
+    def test_fail_level_warning(self):
+        """Test fail-level warning option."""
+        result = self.runner.invoke(main, ["check", "--fail-level", "warning"])
+
+        assert result.exit_code == 0
+
+    def test_fail_level_info(self):
+        """Test fail-level info option."""
+        result = self.runner.invoke(main, ["check", "--fail-level", "info"])
+
+        assert result.exit_code == 0

tests/test_interactive.py

@@ -0,0 +1,103 @@
+"""Tests for interactive mode."""
+
+import os
+import sys
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+
+@pytest.fixture
+def setup_test_env(tmp_path, sample_docker_yaml, sample_git_yaml):
+    """Set up test environment."""
+    docker_file = tmp_path / "docker.yaml"
+    docker_file.write_text(sample_docker_yaml)
+
+    git_file = tmp_path / "git.yaml"
+    git_file.write_text(sample_git_yaml)
+
+    os.environ["SHELL_SPEAK_DATA_DIR"] = str(tmp_path)
+    os.environ["SHELL_SPEAK_HISTORY_FILE"] = str(tmp_path / "history.json")
+    os.environ["SHELL_SPEAK_CORRECTIONS_FILE"] = str(tmp_path / "corrections.json")
+
+
+class TestInteractiveSession:
+    """Tests for interactive session functionality."""
+
+    def test_session_prompt(self):
+        """Test that session prompt is created."""
+        from shell_speak.interactive import ShellSpeakCompleter
+
+        completer = ShellSpeakCompleter()
+        assert completer is not None
+
+    def test_key_bindings(self):
+        """Test key bindings creation."""
+        from shell_speak.interactive import create_key_bindings
+
+        kb = create_key_bindings()
+        assert kb is not None
+
+    def test_detect_tool_docker(self):
+        """Test tool detection for docker."""
+        from shell_speak.interactive import _detect_tool
+
+        tool = _detect_tool("list running containers")
+        assert tool == "docker"
+
+    def test_detect_tool_git(self):
+        """Test tool detection for git."""
+        from shell_speak.interactive import _detect_tool
+
+        tool = _detect_tool("commit changes with message")
+        assert tool == "git"
+
+    def test_detect_tool_kubectl(self):
+        """Test tool detection for kubectl."""
+        from shell_speak.interactive import _detect_tool
+
+        tool = _detect_tool("get pods in namespace default")
+        assert tool == "kubectl"
+
+    def test_detect_tool_unknown(self):
+        """Test tool detection for unknown query."""
+        from shell_speak.interactive import _detect_tool
+
+        tool = _detect_tool("random query that matches nothing")
+        assert tool is None
+
+
+class TestInteractiveHelp:
+    """Tests for interactive help."""
+
+    def test_help_display(self):
+        """Test help message display."""
+        from shell_speak.interactive import _show_interactive_help
+        from shell_speak.output import console
+
+        with patch.object(console, 'print') as mock_print:
+            _show_interactive_help()
+            assert mock_print.called
+
+
+class TestProcessQuery:
+    """Tests for query processing."""
+
+    def test_process_query_success(self, setup_test_env):
+        """Test successful query processing."""
+        from shell_speak.interactive import _process_query
+
+        match = _process_query("list running containers", "docker")
+
+        if match:
+            assert "docker" in match.command.lower()
+
+    def test_process_query_failure(self, setup_test_env):
+        """Test failed query processing."""
+        from shell_speak.interactive import _process_query
+
+        match = _process_query("xyz unknown query xyz", None)
+        assert match is None

tests/test_parser.py

@@ -0,0 +1,178 @@
+"""Tests for the parser module."""
+
+from cli_explain_fix.parser import ErrorParser, ParsedError
+
+
+class TestErrorParser:
+    """Test cases for ErrorParser."""
+
+    def setup_method(self):
+        """Set up parser instance for each test."""
+        self.parser = ErrorParser()
+
+    def test_detect_language_python_traceback(self, sample_python_traceback):
+        """Test language detection for Python traceback."""
+        lang = self.parser.detect_language(sample_python_traceback)
+        assert lang == "python"
+
+    def test_detect_language_python_simple(self, sample_python_simple_error):
+        """Test language detection for simple Python error."""
+        lang = self.parser.detect_language(sample_python_simple_error)
+        assert lang == "python"
+
+    def test_detect_language_javascript(self, sample_js_error):
+        """Test language detection for JavaScript error."""
+        lang = self.parser.detect_language(sample_js_error)
+        assert lang == "javascript"
+
+    def test_detect_language_go(self, sample_go_panic):
+        """Test language detection for Go panic."""
+        lang = self.parser.detect_language(sample_go_panic)
+        assert lang == "go"
+
+    def test_detect_language_rust(self, sample_rust_panic):
+        """Test language detection for Rust panic."""
+        lang = self.parser.detect_language(sample_rust_panic)
+        assert lang == "rust"
+
+    def test_detect_language_json(self, sample_json_error):
+        """Test language detection for JSON error."""
+        lang = self.parser.detect_language(sample_json_error)
+        assert lang == "json"
+
+    def test_detect_language_yaml(self, sample_yaml_error):
+        """Test language detection for YAML error."""
+        lang = self.parser.detect_language(sample_yaml_error)
+        assert lang == "yaml"
+
+    def test_detect_language_cli(self, sample_cli_error):
+        """Test language detection for CLI error."""
+        lang = self.parser.detect_language(sample_cli_error)
+        assert lang == "cli"
+
+    def test_detect_language_unknown(self, sample_unknown_error):
+        """Test language detection for unknown error."""
+        lang = self.parser.detect_language(sample_unknown_error)
+        assert lang == "unknown"
+
+    def test_parse_python_traceback(self, sample_python_traceback):
+        """Test parsing Python traceback."""
+        result = self.parser.parse(sample_python_traceback)
+
+        assert isinstance(result, ParsedError)
+        assert result.error_type == "ModuleNotFoundError"
+        assert result.language == "python"
+        assert "requests" in result.message
+        assert result.file_name == "/app/main.py"
+        assert result.line_number == 10
+        assert len(result.stack_frames) > 0
+
+    def test_parse_python_simple(self, sample_python_simple_error):
+        """Test parsing simple Python error."""
+        result = self.parser.parse(sample_python_simple_error)
+
+        assert isinstance(result, ParsedError)
+        assert result.error_type == "ValueError"
+        assert result.language == "python"
+        assert "invalid value" in result.message
+
+    def test_parse_javascript_error(self, sample_js_error):
+        """Test parsing JavaScript error."""
+        result = self.parser.parse(sample_js_error)
+
+        assert isinstance(result, ParsedError)
+        assert result.error_type == "TypeError"
+        assert result.language == "javascript"
+
+    def test_parse_go_panic(self, sample_go_panic):
+        """Test parsing Go panic."""
+        result = self.parser.parse(sample_go_panic)
+
+        assert isinstance(result, ParsedError)
+        assert result.error_type == "panic"
+        assert result.language == "go"
+
+    def test_parse_rust_panic(self, sample_rust_panic):
+        """Test parsing Rust panic."""
+        result = self.parser.parse(sample_rust_panic)
+
+        assert isinstance(result, ParsedError)
+        assert result.error_type == "panic"
+        assert result.language == "rust"
+
+    def test_parse_json_error(self, sample_json_error):
+        """Test parsing JSON error."""
+        result = self.parser.parse(sample_json_error)
+
+        assert isinstance(result, ParsedError)
+        assert result.error_type == "JSONParseError"
+        assert result.language == "json"
+
+    def test_parse_yaml_error(self, sample_yaml_error):
+        """Test parsing YAML error."""
+        result = self.parser.parse(sample_yaml_error)
+
+        assert isinstance(result, ParsedError)
+        assert result.error_type == "YAMLParseError"
+        assert result.language == "yaml"
+
+    def test_parse_cli_error(self, sample_cli_error):
+        """Test parsing CLI error."""
+        result = self.parser.parse(sample_cli_error)
+
+        assert isinstance(result, ParsedError)
+        assert result.error_type == "GenericError"
+        assert result.language == "cli"
+
+    def test_parse_with_explicit_language(self, sample_python_simple_error):
+        """Test parsing with explicit language specification."""
+        result = self.parser.parse(sample_python_simple_error, language="python")
+
+        assert result.language == "python"
+        assert result.error_type == "ValueError"
+
+    def test_parse_unknown_error(self, sample_unknown_error):
+        """Test parsing unknown error returns default."""
+        result = self.parser.parse(sample_unknown_error)
+
+        assert isinstance(result, ParsedError)
+        assert result.error_type == "UnknownError"
+        assert result.language == "unknown"
+
+    def test_parse_empty_input(self):
+        """Test parsing empty input."""
+        result = self.parser.parse("")
+
+        assert isinstance(result, ParsedError)
+        assert result.error_type == "UnknownError"
+        assert result.message == "Unknown error occurred"
+
+    def test_parsed_error_to_dict(self, sample_python_simple_error):
+        """Test ParsedError.to_dict() method."""
+        result = self.parser.parse(sample_python_simple_error)
+        data = result.to_dict()
+
+        assert isinstance(data, dict)
+        assert "error_type" in data
+        assert "message" in data
+        assert "language" in data
+        assert "stack_frames" in data
+
+    def test_parse_complex_python_traceback(self):
+        """Test parsing complex Python traceback with multiple frames."""
+        traceback = '''Traceback (most recent call last):
+  File "app.py", line 5, in <module>
+    main()
+  File "app.py", line 10, in main
+    process()
+  File "processor.py", line 20, in process
+    result = data['key']
+KeyError: 'key'
+'''
+        result = self.parser.parse(traceback)
+
+        assert result.error_type == "KeyError"
+        assert result.language == "python"
+        assert result.file_name == "processor.py"
+        assert result.line_number == 20
+        assert len(result.stack_frames) == 3

tests/test_parsers.py

@@ -0,0 +1,395 @@
+"""Tests for parsers module."""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+
+from doc2man.parsers.python import PythonDocstringParser, parse_python_file
+from doc2man.parsers.go import GoDocstringParser, parse_go_file
+from doc2man.parsers.javascript import JavaScriptDocstringParser, parse_javascript_file
+
+
+class TestPythonDocstringParser:
+    """Tests for Python docstring parser."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.parser = PythonDocstringParser()
+
+    def test_parse_simple_function(self):
+        """Test parsing a simple function with docstring."""
+        source = '''
+def hello(name):
+    """Say hello to a person.
+
+    Args:
+        name: The name of the person to greet.
+
+    Returns:
+        A greeting message.
+    """
+    return f"Hello, {name}!"
+'''
+        result = self.parser.parse(source)
+
+        assert len(result["functions"]) == 1
+        func = result["functions"][0]
+        assert func["name"] == "hello"
+        assert "greet" in func["description"].lower() or "hello" in func["description"].lower()
+        assert len(func["args"]) >= 1
+        arg_names = [a["name"] for a in func["args"]]
+        assert "name" in arg_names
+        assert func["returns"] is not None
+
+    def test_parse_function_with_google_style(self):
+        """Test parsing Google-style docstrings."""
+        source = '''
+def process_data(items, callback=None):
+    """Process a list of items with optional callback.
+
+    Args:
+        items: List of items to process.
+        callback: Optional function to call for each item.
+
+    Returns:
+        dict: A dictionary with processed results.
+
+    Raises:
+        ValueError: If items is empty.
+    """
+    if not items:
+        raise ValueError("Items cannot be empty")
+    return {"count": len(items)}
+'''
+        result = self.parser.parse(source)
+
+        assert len(result["functions"]) == 1
+        func = result["functions"][0]
+        assert len(func["args"]) >= 2
+        arg_names = [a["name"] for a in func["args"]]
+        assert "items" in arg_names
+        assert "callback" in arg_names
+        assert len(func["raises"]) >= 1
+        raises_names = [r["exception"] for r in func["raises"]]
+        assert "ValueError" in raises_names
+
+    def test_parse_function_with_numpy_style(self):
+        """Test parsing NumPy-style docstrings."""
+        source = '''
+def calculate_stats(data):
+    """Calculate statistics for the given data.
+
+    Parameters
+    ----------
+    data : array_like
+        Input data array.
+
+    Returns
+    -------
+    tuple
+        A tuple containing (mean, std, median).
+
+    Examples
+    --------
+    >>> calculate_stats([1, 2, 3, 4, 5])
+    (3.0, 1.414, 3)
+    """
+    import numpy as np
+    arr = np.array(data)
+    return arr.mean(), arr.std(), np.median(arr)
+'''
+        result = self.parser.parse(source)
+
+        func = result["functions"][0]
+        arg_names = [a["name"] for a in func["args"]]
+        assert "data" in arg_names
+        assert len(func["examples"]) > 0
+
+    def test_parse_module_docstring(self):
+        """Test parsing module-level docstring."""
+        source = '''"""This is a module docstring.
+
+This module provides utility functions for data processing.
+"""
+
+def helper():
+    """A helper function."""
+    pass
+'''
+        result = self.parser.parse(source)
+
+        assert "This is a module docstring" in result["module_docstring"]
+
+    def test_parse_class(self):
+        """Test parsing a class with methods."""
+        source = '''
+class Calculator:
+    """A simple calculator class.
+
+    Attributes:
+        memory: Current memory value.
+    """
+
+    def __init__(self):
+        """Initialize the calculator."""
+        self.memory = 0
+
+    def add(self, a, b):
+        """Add two numbers.
+
+        Args:
+            a: First number.
+            b: Second number.
+
+        Returns:
+            Sum of a and b.
+        """
+        return a + b
+'''
+        result = self.parser.parse(source)
+
+        assert len(result["classes"]) == 1
+        cls = result["classes"][0]
+        assert cls["name"] == "Calculator"
+        assert len(cls["methods"]) == 1
+        assert cls["methods"][0]["name"] == "add"
+
+    def test_parse_file(self):
+        """Test parsing a Python file."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write('''
+def example():
+    """An example function.
+
+    Returns:
+        None
+    """
+    pass
+''')
+            f.flush()
+
+            result = parse_python_file(Path(f.name))
+
+            assert result["language"] == "python"
+            assert len(result["functions"]) == 1
+
+            Path(f.name).unlink()
+
+
+class TestGoDocstringParser:
+    """Tests for Go docstring parser."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.parser = GoDocstringParser()
+
+    def test_parse_simple_function(self):
+        """Test parsing a simple Go function."""
+        source = '''// Add adds two integers and returns the result.
+//
+// Parameters:
+//   a: First integer
+//   b: Second integer
+//
+// Returns: The sum of a and b
+func Add(a, b int) int {
+    return a + b
+}
+'''
+        result = self.parser.parse_content(source)
+
+        assert len(result["functions"]) == 1
+        func = result["functions"][0]
+        assert func["name"] == "Add"
+
+    def test_parse_function_with_params(self):
+        """Test parsing Go function with parameters."""
+        source = '''// Greet returns a greeting message.
+//
+// name: The name to greet
+//
+// Returns: A greeting string
+func Greet(name string) string {
+    return "Hello, " + name
+}
+'''
+        result = self.parser.parse_content(source)
+
+        func = result["functions"][0]
+        assert func["name"] == "Greet"
+        assert len(func["args"]) >= 1
+        arg_names = [a["name"] for a in func["args"]]
+        assert "name" in arg_names
+
+    def test_parse_package_documentation(self):
+        """Test parsing package-level documentation."""
+        source = '''// Package math provides mathematical utilities.
+//
+// This package contains functions for basic
+// mathematical operations.
+package math
+
+// Add adds two numbers.
+func Add(a, b int) int {
+    return a + b
+}
+'''
+        result = self.parser.parse_content(source)
+
+        assert "mathematical utilities" in result["package_docstring"].lower()
+
+    def test_parse_file(self):
+        """Test parsing a Go file."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".go", delete=False) as f:
+            f.write('''// Hello returns a greeting.
+//
+// Returns: A greeting message
+func Hello() string {
+    return "Hello, World!"
+}
+''')
+            f.flush()
+
+            result = parse_go_file(Path(f.name))
+
+            assert result["language"] == "go"
+            assert len(result["functions"]) == 1
+
+            Path(f.name).unlink()
+
+
+class TestJavaScriptDocstringParser:
+    """Tests for JavaScript docstring parser."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.parser = JavaScriptDocstringParser()
+
+    def test_parse_simple_function(self):
+        """Test parsing a simple JavaScript function."""
+        source = '''
+/**
+ * Says hello to a person.
+ *
+ * @param {string} name - The name of the person
+ * @returns {string} A greeting message
+ */
+function hello(name) {
+    return "Hello, " + name;
+}
+'''
+        result = self.parser.parse_content(source)
+
+        assert len(result["functions"]) == 1
+        func = result["functions"][0]
+        assert func["name"] == "hello"
+        assert "hello" in func["description"].lower() or "person" in func["description"].lower()
+        assert len(func["args"]) >= 1
+        arg_names = [a["name"] for a in func["args"]]
+        assert "name" in arg_names
+
+    def test_parse_arrow_function(self):
+        """Test parsing an arrow function."""
+        source = '''
+/**
+ * Adds two numbers.
+ *
+ * @param {number} a - First number
+ * @param {number} b - Second number
+ * @returns {number} The sum
+ */
+const add = (a, b) => a + b;
+'''
+        result = self.parser.parse_content(source)
+
+        func = result["functions"][0]
+        assert func["name"] == "add"
+        assert len(func["args"]) >= 1
+
+    def test_parse_function_with_example(self):
+        """Test parsing function with examples."""
+        source = '''
+/**
+ * Squares a number.
+ *
+ * @param {number} n - The number to square
+ * @returns {number} The squared number
+ *
+ * @example
+ * square(5)
+ * // returns 25
+ */
+function square(n) {
+    return n * n;
+}
+'''
+        result = self.parser.parse_content(source)
+
+        func = result["functions"][0]
+        assert len(func["examples"]) > 0
+
+    def test_parse_export_function(self):
+        """Test parsing exported function."""
+        source = '''
+/**
+ * A public API function.
+ *
+ * @returns {void}
+ */
+export function publicApi() {
+    console.log("Hello");
+}
+'''
+        result = self.parser.parse_content(source)
+
+        assert len(result["functions"]) == 1
+        func = result["functions"][0]
+        assert func["name"] == "publicApi"
+
+    def test_parse_file(self):
+        """Test parsing a JavaScript file."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".js", delete=False) as f:
+            f.write('''
+/**
+ * Example function.
+ *
+ * @returns {string} A message
+ */
+function example() {
+    return "Hello";
+}
+''')
+            f.flush()
+
+            result = parse_javascript_file(Path(f.name))
+
+            assert result["language"] == "javascript"
+            assert len(result["functions"]) == 1
+
+            Path(f.name).unlink()
+
+    def test_parse_typescript(self):
+        """Test parsing a TypeScript file."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".ts", delete=False) as f:
+            f.write('''
+/**
+ * Adds two numbers.
+ *
+ * @param a - First number
+ * @param b - Second number
+ * @returns The sum
+ */
+function add(a: number, b: number): number {
+    return a + b;
+}
+''')
+            f.flush()
+
+            result = parse_javascript_file(Path(f.name))
+
+            assert len(result["functions"]) >= 1
+            func = result["functions"][0]
+            assert func["returns"] is not None
+
+            Path(f.name).unlink()

tests/test_pattern_matching.py

@@ -0,0 +1,138 @@
+"""Tests for pattern matching engine."""
+
+import os
+import sys
+from pathlib import Path
+
+import pytest
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+
+class TestNLP:
+    """Tests for NLP preprocessing functions."""
+
+    def test_normalize_text(self):
+        from shell_speak.nlp import normalize_text
+
+        assert normalize_text("  Hello World  ") == "hello world"
+        assert normalize_text("Hello\tWorld") == "hello world"
+        assert normalize_text("multiple   spaces") == "multiple spaces"
+
+    def test_tokenize(self):
+        from shell_speak.nlp import tokenize
+
+        assert tokenize("hello world") == ["hello", "world"]
+        assert tokenize("List running containers") == ["list", "running", "containers"]
+        assert tokenize("") == []
+
+    def test_extract_keywords(self):
+        from shell_speak.nlp import extract_keywords
+
+        keywords = extract_keywords("list running containers")
+        assert "list" in keywords
+        assert "running" in keywords
+        assert "containers" in keywords
+
+    def test_extract_keywords_removes_stopwords(self):
+        from shell_speak.nlp import extract_keywords
+
+        keywords = extract_keywords("the a is are")
+        assert len(keywords) == 0
+
+    def test_calculate_similarity(self):
+        from shell_speak.nlp import calculate_similarity
+
+        assert calculate_similarity("list containers", "list containers") == 1.0
+        assert calculate_similarity("list containers", "show running containers") > 0.1
+        assert calculate_similarity("list containers", "git commit") == 0.0
+
+
+class TestPatternMatcher:
+    """Tests for pattern matching functionality."""
+
+    @pytest.fixture(autouse=True)
+    def setup(self, tmp_path, sample_docker_yaml):
+        from shell_speak.library import get_loader
+
+        docker_file = tmp_path / "docker.yaml"
+        docker_file.write_text(sample_docker_yaml)
+
+        os.environ["SHELL_SPEAK_DATA_DIR"] = str(tmp_path)
+
+        loader = get_loader()
+        loader._loaded = False
+        loader._patterns = []
+
+    def test_match_existing_pattern(self):
+        from shell_speak.matcher import get_matcher
+
+        matcher = get_matcher()
+        match = matcher.match("list running containers")
+
+        assert match is not None
+        assert match.command == "docker ps"
+        assert match.confidence > 0.5
+
+    def test_match_partial_pattern(self):
+        from shell_speak.matcher import get_matcher
+
+        matcher = get_matcher()
+        match = matcher.match("show running containers")
+
+        assert match is not None
+        assert "docker" in match.command.lower()
+
+    def test_match_no_match(self):
+        from shell_speak.matcher import get_matcher
+
+        matcher = get_matcher()
+        match = matcher.match("xyz unknown query that does not exist")
+
+        assert match is None
+
+    def test_match_with_tool_filter(self):
+        from shell_speak.matcher import get_matcher
+
+        matcher = get_matcher()
+        match = matcher.match("list running containers", tool="docker")
+
+        assert match is not None
+        assert match.pattern.tool == "docker"
+
+    def test_template_substitution(self):
+        from shell_speak.matcher import get_matcher
+
+        matcher = get_matcher()
+        match = matcher.match("run a container named test with image nginx")
+
+        assert match is not None
+        assert "docker" in match.command.lower()
+
+
+class TestCommandMatch:
+    """Tests for CommandMatch dataclass."""
+
+    def test_command_match_creation(self):
+        from shell_speak.models import CommandMatch, CommandPattern
+
+        pattern = CommandPattern(
+            name="test_pattern",
+            tool="test",
+            description="Test pattern",
+            patterns=["test query"],
+            template="echo test",
+            explanation="Test explanation",
+        )
+
+        match = CommandMatch(
+            pattern=pattern,
+            confidence=0.9,
+            matched_query="test query",
+            command="echo test",
+            explanation="Test explanation",
+        )
+
+        assert match.pattern.name == "test_pattern"
+        assert match.confidence == 0.9
+        assert match.command == "echo test"

tests/test_profile.py

@@ -0,0 +1,150 @@
+"""Tests for profile management module."""
+
+import pytest
+from pathlib import Path
+
+
+class TestProfileManagement:
+    """Test cases for profile management."""
+
+    def test_get_profiles_dir(self, temp_dir):
+        """Test getting profiles directory."""
+        from env_pro.core.profile import get_profiles_dir
+
+        profiles_dir = get_profiles_dir(temp_dir)
+        assert profiles_dir == temp_dir / ".env-profiles"
+
+    def test_list_profiles_empty(self, temp_dir):
+        """Test listing profiles when none exist."""
+        from env_pro.core.profile import list_profiles
+
+        profiles = list_profiles(temp_dir)
+        assert profiles == []
+
+    def test_create_profile(self, temp_dir):
+        """Test creating a new profile."""
+        from env_pro.core.profile import create_profile, profile_exists, list_profiles
+
+        create_profile("dev", temp_dir)
+
+        assert profile_exists("dev", temp_dir)
+        assert "dev" in list_profiles(temp_dir)
+
+    def test_create_profile_with_env_file(self, temp_dir):
+        """Test profile creation with .env file."""
+        from env_pro.core.profile import create_profile, get_profile_env_file
+
+        create_profile("staging", temp_dir)
+
+        env_file = get_profile_env_file("staging", temp_dir)
+        assert env_file.exists()
+
+    def test_delete_profile(self, temp_dir):
+        """Test deleting a profile."""
+        from env_pro.core.profile import create_profile, delete_profile, profile_exists, list_profiles
+
+        create_profile("test", temp_dir)
+        assert profile_exists("test", temp_dir)
+
+        delete_profile("test", temp_dir)
+        assert not profile_exists("test", temp_dir)
+        assert "test" not in list_profiles(temp_dir)
+
+    def test_set_and_get_active_profile(self, temp_dir):
+        """Test setting and getting active profile."""
+        from env_pro.core.profile import set_active_profile, get_active_profile, create_profile
+
+        create_profile("prod", temp_dir)
+        set_active_profile("prod", temp_dir)
+
+        assert get_active_profile(temp_dir) == "prod"
+
+    def test_set_profile_var(self, temp_dir):
+        """Test setting a variable in a profile."""
+        from env_pro.core.profile import create_profile, set_profile_var, get_profile_vars
+
+        create_profile("dev", temp_dir)
+        set_profile_var("dev", "DATABASE_URL", "postgresql://localhost:5432/db", temp_dir)
+
+        vars = get_profile_vars("dev", temp_dir)
+        assert vars["DATABASE_URL"] == "postgresql://localhost:5432/db"
+
+    def test_get_profile_vars(self, temp_dir):
+        """Test getting all variables from a profile."""
+        from env_pro.core.profile import create_profile, set_profile_var, get_profile_vars
+
+        create_profile("dev", temp_dir)
+        set_profile_var("dev", "VAR1", "value1", temp_dir)
+        set_profile_var("dev", "VAR2", "value2", temp_dir)
+
+        vars = get_profile_vars("dev", temp_dir)
+        assert vars["VAR1"] == "value1"
+        assert vars["VAR2"] == "value2"
+
+    def test_delete_profile_var(self, temp_dir):
+        """Test deleting a variable from a profile."""
+        from env_pro.core.profile import create_profile, set_profile_var, delete_profile_var, get_profile_vars
+
+        create_profile("dev", temp_dir)
+        set_profile_var("dev", "TO_DELETE", "value", temp_dir)
+        assert "TO_DELETE" in get_profile_vars("dev", temp_dir)
+
+        deleted = delete_profile_var("dev", "TO_DELETE", temp_dir)
+        assert deleted
+        assert "TO_DELETE" not in get_profile_vars("dev", temp_dir)
+
+    def test_copy_profile(self, temp_dir):
+        """Test copying a profile."""
+        from env_pro.core.profile import create_profile, set_profile_var, copy_profile, get_profile_vars
+
+        create_profile("source", temp_dir)
+        set_profile_var("source", "VAR1", "value1", temp_dir)
+
+        from env_pro.core.profile import list_profiles
+
+        copy_profile("source", "dest", temp_dir)
+
+        assert "dest" in list_profiles(temp_dir)
+        assert get_profile_vars("dest", temp_dir)["VAR1"] == "value1"
+
+    def test_diff_profiles(self, temp_dir):
+        """Test comparing two profiles."""
+        from env_pro.core.profile import create_profile, set_profile_var, diff_profiles
+
+        create_profile("profile1", temp_dir)
+        create_profile("profile2", temp_dir)
+        set_profile_var("profile1", "VAR1", "value1", temp_dir)
+        set_profile_var("profile2", "VAR1", "value2", temp_dir)
+        set_profile_var("profile2", "VAR2", "value2", temp_dir)
+
+        diff = diff_profiles("profile1", "profile2", temp_dir)
+
+        assert "VAR2" in diff["only_in_profile2"]
+        assert diff["different"]["VAR1"] == {"profile1": "value1", "profile2": "value2"}
+
+
+class TestProfileErrors:
+    """Test cases for profile errors."""
+
+    def test_create_duplicate_profile(self, temp_dir):
+        """Test creating a profile that already exists."""
+        from env_pro.core.profile import create_profile, ProfileAlreadyExistsError
+
+        create_profile("dev", temp_dir)
+
+        with pytest.raises(ProfileAlreadyExistsError):
+            create_profile("dev", temp_dir)
+
+    def test_delete_nonexistent_profile(self, temp_dir):
+        """Test deleting a profile that doesn't exist."""
+        from env_pro.core.profile import delete_profile, ProfileNotFoundError
+
+        with pytest.raises(ProfileNotFoundError):
+            delete_profile("nonexistent", temp_dir)
+
+    def test_switch_to_nonexistent_profile(self, temp_dir):
+        """Test switching to a non-existent profile."""
+        from env_pro.core.profile import switch_profile, ProfileNotFoundError
+
+        with pytest.raises(ProfileNotFoundError):
+            switch_profile("nonexistent", temp_dir)

tests/test_rules.py

@@ -0,0 +1,251 @@
+"""Tests for the rules module."""
+
+import pytest
+from cli_diff_auditor.rules import (
+    BuiltInRules,
+    Finding,
+    Rule,
+    RulesLoader,
+    Severity,
+)
+
+
+class TestRule:
+    """Test cases for Rule class."""
+
+    def test_rule_creation(self):
+        """Test creating a Rule instance."""
+        rule = Rule(
+            id="test-rule",
+            name="Test Rule",
+            description="A test rule",
+            pattern=r"test.*",
+            severity=Severity.WARNING,
+            auto_fix=True,
+            category="testing"
+        )
+
+        assert rule.id == "test-rule"
+        assert rule.name == "Test Rule"
+        assert rule.severity == Severity.WARNING
+        assert rule.auto_fix is True
+        assert rule.enabled is True
+
+    def test_compile_pattern(self):
+        """Test compiling a rule pattern."""
+        rule = Rule(
+            id="test",
+            name="Test",
+            description="Test",
+            pattern=r"\bprint\s*\(",
+            severity=Severity.WARNING
+        )
+
+        compiled = rule.compile_pattern()
+
+        assert compiled.search("print('hello')") is not None
+        assert compiled.search("hello world") is None
+
+    def test_get_fix_pattern(self):
+        """Test getting the fix pattern."""
+        rule = Rule(
+            id="test",
+            name="Test",
+            description="Test",
+            pattern=r"test",
+            severity=Severity.INFO,
+            auto_fix=True,
+            fix_pattern=r"old",
+            replacement="new"
+        )
+
+        fix_pattern = rule.get_fix_pattern()
+
+        assert fix_pattern is not None
+        assert fix_pattern.search("old text") is not None
+
+
+class TestBuiltInRules:
+    """Test cases for BuiltInRules class."""
+
+    def test_get_all_rules_returns_list(self):
+        """Test that get_all_rules returns a list."""
+        rules = BuiltInRules.get_all_rules()
+
+        assert isinstance(rules, list)
+        assert len(rules) > 0
+
+    def test_rules_have_required_fields(self):
+        """Test that all rules have required fields."""
+        rules = BuiltInRules.get_all_rules()
+
+        for rule in rules:
+            assert rule.id
+            assert rule.name
+            assert rule.description
+            assert rule.pattern
+            assert rule.severity
+
+    def test_debug_rules_exist(self):
+        """Test that debug-related rules exist."""
+        rules = BuiltInRules.get_all_rules()
+        rule_ids = [r.id for r in rules]
+
+        assert "debug-print" in rule_ids
+        assert "console-log" in rule_ids
+
+    def test_security_rules_exist(self):
+        """Test that security-related rules exist."""
+        rules = BuiltInRules.get_all_rules()
+        rule_ids = [r.id for r in rules]
+
+        assert "sql-injection" in rule_ids
+        assert "hardcoded-password" in rule_ids
+        assert "eval-usage" in rule_ids
+
+    def test_error_handling_rules_exist(self):
+        """Test that error handling rules exist."""
+        rules = BuiltInRules.get_all_rules()
+        rule_ids = [r.id for r in rules]
+
+        assert "bare-except" in rule_ids
+        assert "pass-except" in rule_ids
+
+
+class TestRulesLoader:
+    """Test cases for RulesLoader class."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.loader = RulesLoader()
+
+    def test_load_builtin_rules(self):
+        """Test loading built-in rules."""
+        self.loader.load_builtin_rules()
+
+        rules = self.loader.get_all_rules()
+
+        assert len(rules) > 0
+
+    def test_get_rule(self):
+        """Test getting a specific rule."""
+        self.loader.load_builtin_rules()
+
+        rule = self.loader.get_rule("debug-print")
+
+        assert rule is not None
+        assert rule.id == "debug-print"
+
+    def test_get_nonexistent_rule(self):
+        """Test getting a rule that doesn't exist."""
+        self.loader.load_builtin_rules()
+
+        rule = self.loader.get_rule("nonexistent-rule")
+
+        assert rule is None
+
+    def test_disable_rule(self):
+        """Test disabling a rule."""
+        self.loader.load_builtin_rules()
+
+        result = self.loader.disable_rule("debug-print")
+
+        assert result is True
+
+        rule = self.loader.get_rule("debug-print")
+        assert rule.enabled is False
+
+    def test_enable_rule(self):
+        """Test enabling a rule."""
+        self.loader.load_builtin_rules()
+        self.loader.disable_rule("debug-print")
+
+        result = self.loader.enable_rule("debug-print")
+
+        assert result is True
+
+        rule = self.loader.get_rule("debug-print")
+        assert rule.enabled is True
+
+    def test_get_enabled_rules(self):
+        """Test getting only enabled rules."""
+        self.loader.load_builtin_rules()
+        self.loader.disable_rule("debug-print")
+        self.loader.disable_rule("console-log")
+
+        enabled = self.loader.get_enabled_rules()
+
+        rule_ids = [r.id for r in enabled]
+
+        assert "debug-print" not in rule_ids
+        assert "console-log" not in rule_ids
+
+    def test_load_from_yaml(self):
+        """Test loading rules from YAML."""
+        self.loader.load_builtin_rules()
+        yaml_content = """
+rules:
+  - id: custom-rule
+    name: Custom Rule
+    description: A custom rule
+    pattern: "custom.*"
+    severity: warning
+    category: custom
+"""
+        rules = self.loader.load_from_yaml(yaml_content)
+
+        assert len(rules) == 1
+        assert rules[0].id == "custom-rule"
+
+        all_rules = self.loader.get_all_rules()
+        assert len(all_rules) > 1
+
+    def test_load_from_yaml_minimal(self):
+        """Test loading rules with minimal fields."""
+        yaml_content = """
+rules:
+  - id: minimal-rule
+    name: Minimal
+    description: Minimal description
+    pattern: "test"
+    severity: error
+"""
+        rules = self.loader.load_from_yaml(yaml_content)
+
+        assert len(rules) == 1
+        assert rules[0].severity == Severity.ERROR
+        assert rules[0].auto_fix is False
+        assert rules[0].category == "custom"
+
+    def test_parse_rule_data_missing_required_field(self):
+        """Test parsing rule data with missing required field."""
+        data = {
+            "id": "test",
+            "name": "Test",
+            "description": "Test"
+        }
+
+        with pytest.raises(ValueError):
+            self.loader._parse_rule_data(data)
+
+
+class TestFinding:
+    """Test cases for Finding class."""
+
+    def test_finding_creation(self):
+        """Test creating a Finding instance."""
+        finding = Finding(
+            rule_id="test-rule",
+            rule_name="Test Rule",
+            severity=Severity.WARNING,
+            file_path="test.py",
+            line_number=10,
+            line_content="print('debug')",
+            message="Debug print statement detected",
+            fix_available=True
+        )
+
+        assert finding.rule_id == "test-rule"
+        assert finding.severity == Severity.WARNING
+        assert finding.line_number == 10
+        assert finding.fix_available is True

tests/test_template.py

@@ -0,0 +1,111 @@
+"""Tests for template module."""
+
+import pytest
+from pathlib import Path
+
+
+class TestTemplateManagement:
+    """Test cases for template management."""
+
+    def test_list_builtin_templates(self):
+        """Test listing builtin templates."""
+        from env_pro.core.template import list_builtin_templates
+
+        templates = list_builtin_templates()
+        assert "fastapi" in templates
+        assert "django" in templates
+        assert "nodejs" in templates
+        assert "python" in templates
+
+    def test_load_builtin_template(self):
+        """Test loading a builtin template."""
+        from env_pro.core.template import load_template
+
+        content = load_template("minimal")
+        assert "ENVIRONMENT" in content
+
+    def test_get_template_info(self):
+        """Test getting template information."""
+        from env_pro.core.template import get_template_info
+
+        info = get_template_info("fastapi")
+        assert info["name"] == "fastapi"
+        assert info["type"] == "builtin"
+        assert "APP_NAME" in info["variables"]
+
+    def test_render_template(self):
+        """Test rendering a template with variables."""
+        from env_pro.core.template import render_template
+
+        content = "APP_NAME=${APP_NAME}\nDEBUG=${DEBUG}"
+        variables = {"APP_NAME": "MyApp", "DEBUG": "true"}
+        rendered = render_template(content, variables)
+        assert "MyApp" in rendered
+        assert "true" in rendered
+
+    def test_render_template_missing_variable(self):
+        """Test rendering template with missing variable raises error."""
+        from env_pro.core.template import render_template, TemplateSyntaxError
+
+        content = "APP_NAME=${APP_NAME}\nMISSING=${OTHER}"
+        variables = {"APP_NAME": "MyApp"}
+
+        with pytest.raises(TemplateSyntaxError):
+            render_template(content, variables)
+
+    def test_create_and_delete_user_template(self, temp_dir):
+        """Test creating and deleting a user template."""
+        from env_pro.core.template import (
+            create_template, delete_template, load_template,
+            get_user_templates_dir, list_user_templates
+        )
+        import os
+
+        original_home = os.environ.get("HOME")
+        os.environ["HOME"] = str(temp_dir)
+
+        try:
+            create_template("my-template", "VAR1=value1\nVAR2=value2", "My custom template")
+
+            templates = list_user_templates()
+            assert "my-template" in templates
+
+            loaded = load_template("my-template")
+            assert "VAR1=value1" in loaded
+
+            delete_template("my-template")
+            templates = list_user_templates()
+            assert "my-template" not in templates
+        finally:
+            if original_home:
+                os.environ["HOME"] = original_home
+            else:
+                del os.environ["HOME"]
+
+    def test_apply_template(self, temp_dir):
+        """Test applying a template to a file."""
+        from env_pro.core.template import apply_template
+
+        output_file = temp_dir / ".env"
+        apply_template("minimal", {"ENVIRONMENT": "production"}, output_file)
+
+        content = output_file.read_text()
+        assert "production" in content
+
+
+class TestTemplateErrors:
+    """Test cases for template errors."""
+
+    def test_load_nonexistent_template(self):
+        """Test loading a template that doesn't exist."""
+        from env_pro.core.template import load_template, TemplateNotFoundError
+
+        with pytest.raises(TemplateNotFoundError):
+            load_template("nonexistent-template")
+
+    def test_delete_builtin_template(self):
+        """Test that builtin templates cannot be deleted."""
+        from env_pro.core.template import delete_template, TemplateError
+
+        with pytest.raises(TemplateError):
+            delete_template("fastapi")

tests/test_validator.py

@@ -0,0 +1,182 @@
+"""Tests for validation module."""
+
+import pytest
+from pathlib import Path
+
+
+class TestSchemaValidation:
+    """Test cases for schema validation."""
+
+    def test_load_empty_schema(self, temp_dir):
+        """Test loading schema when no file exists."""
+        from env_pro.core.validator import load_schema
+
+        schema = load_schema(temp_dir)
+        assert schema is None
+
+    def test_load_schema(self, temp_dir):
+        """Test loading a valid schema."""
+        from env_pro.core.validator import load_schema, EnvSchema
+
+        schema_file = temp_dir / ".env.schema.yaml"
+        schema_file.write_text("""
+variables:
+  DATABASE_URL:
+    type: url
+    required: true
+    description: Database connection URL
+  DEBUG:
+    type: bool
+    default: false
+""")
+
+        schema = load_schema(temp_dir)
+        assert schema is not None
+        assert "DATABASE_URL" in schema.variables
+        assert schema.variables["DATABASE_URL"].type == "url"
+        assert schema.variables["DATABASE_URL"].required
+
+    def test_validate_valid_string(self):
+        """Test validation of valid string value."""
+        from env_pro.core.validator import validate_value, VariableSchema
+
+        schema = VariableSchema(type="string")
+        errors = validate_value("TEST_VAR", "some-value", schema)
+        assert errors == []
+
+    def test_validate_required_missing(self):
+        """Test validation when required variable is missing."""
+        from env_pro.core.validator import validate_value, VariableSchema
+
+        schema = VariableSchema(type="string", required=True)
+        errors = validate_value("TEST_VAR", "", schema)
+        assert len(errors) > 0
+        assert "required" in errors[0].lower()
+
+    def test_validate_int_type(self):
+        """Test validation of integer type."""
+        from env_pro.core.validator import validate_value, VariableSchema
+
+        schema = VariableSchema(type="int")
+        errors = validate_value("PORT", "8080", schema)
+        assert errors == []
+
+        errors = validate_value("PORT", "not-a-number", schema)
+        assert len(errors) > 0
+
+    def test_validate_bool_type(self):
+        """Test validation of boolean type."""
+        from env_pro.core.validator import validate_value, VariableSchema
+
+        schema = VariableSchema(type="bool")
+        errors = validate_value("DEBUG", "true", schema)
+        assert errors == []
+
+        errors = validate_value("DEBUG", "yes", schema)
+        assert errors == []
+
+    def test_validate_email_type(self):
+        """Test validation of email type."""
+        from env_pro.core.validator import validate_value, VariableSchema
+
+        schema = VariableSchema(type="email")
+        errors = validate_value("EMAIL", "user@example.com", schema)
+        assert errors == []
+
+        errors = validate_value("EMAIL", "invalid-email", schema)
+        assert len(errors) > 0
+
+    def test_validate_url_type(self):
+        """Test validation of URL type."""
+        from env_pro.core.validator import validate_value, VariableSchema
+
+        schema = VariableSchema(type="url")
+        errors = validate_value("API_URL", "https://api.example.com", schema)
+        assert errors == []
+
+        errors = validate_value("API_URL", "not-a-url", schema)
+        assert len(errors) > 0
+
+    def test_validate_pattern(self):
+        """Test validation with regex pattern."""
+        from env_pro.core.validator import validate_value, VariableSchema
+
+        schema = VariableSchema(type="string", pattern=r"^[A-Z]+$")
+        errors = validate_value("PREFIX", "ABC123", schema)
+        assert len(errors) > 0
+
+        errors = validate_value("PREFIX", "ABC", schema)
+        assert errors == []
+
+    def test_validate_enum(self):
+        """Test validation with enum values."""
+        from env_pro.core.validator import validate_value, VariableSchema
+
+        schema = VariableSchema(type="string", enum=["dev", "staging", "prod"])
+        errors = validate_value("ENV", "dev", schema)
+        assert errors == []
+
+        errors = validate_value("ENV", "invalid", schema)
+        assert len(errors) > 0
+
+    def test_validate_min_max_length(self):
+        """Test validation with min/max length constraints."""
+        from env_pro.core.validator import validate_value, VariableSchema
+
+        schema = VariableSchema(type="string", min_length=3, max_length=10)
+        errors = validate_value("NAME", "ab", schema)
+        assert len(errors) > 0
+
+        errors = validate_value("NAME", "abcdefghijkl", schema)
+        assert len(errors) > 0
+
+        errors = validate_value("NAME", "valid", schema)
+        assert errors == []
+
+    def test_validate_min_max_number(self):
+        """Test validation with min/max number constraints."""
+        from env_pro.core.validator import validate_value, VariableSchema
+
+        schema = VariableSchema(type="int", minimum=1, maximum=100)
+        errors = validate_value("PORT", "0", schema)
+        assert len(errors) > 0
+
+        errors = validate_value("PORT", "101", schema)
+        assert len(errors) > 0
+
+        errors = validate_value("PORT", "50", schema)
+        assert errors == []
+
+    def test_validate_env_vars_full(self):
+        """Test full environment validation."""
+        from env_pro.core.validator import validate_env_vars, EnvSchema, VariableSchema
+
+        schema = EnvSchema(variables={
+            "DATABASE_URL": VariableSchema(type="string", required=True),
+            "DEBUG": VariableSchema(type="bool", default="false")
+        })
+
+        vars_dict = {
+            "DATABASE_URL": "postgresql://localhost:5432/db",
+            "DEBUG": "true"
+        }
+
+        errors = validate_env_vars(vars_dict, schema)
+        assert errors == []
+
+    def test_check_required_vars(self):
+        """Test checking for missing required variables."""
+        from env_pro.core.validator import check_required_vars, EnvSchema, VariableSchema
+
+        schema = EnvSchema(variables={
+            "REQUIRED_VAR": VariableSchema(type="string", required=True),
+            "OPTIONAL_VAR": VariableSchema(type="string", required=False)
+        })
+
+        vars_dict = {"OPTIONAL_VAR": "value"}
+        missing = check_required_vars(vars_dict, schema)
+        assert "REQUIRED_VAR" in missing
+
+        vars_dict = {"REQUIRED_VAR": "value"}
+        missing = check_required_vars(vars_dict, schema)
+        assert len(missing) == 0

tests/unit/test_cli.py

@@ -0,0 +1,60 @@
+"""Unit tests for CLI module."""
+
+import os
+import tempfile
+
+from click.testing import CliRunner
+
+from codesnap.__main__ import main
+
+
+class TestCLI:
+    """Tests for CLI commands."""
+
+    def setup_method(self) -> None:
+        self.runner = CliRunner()
+
+    def test_main_help(self) -> None:
+        result = self.runner.invoke(main, ["--help"])
+        assert result.exit_code == 0
+        assert "CodeSnap" in result.output
+
+    def test_cli_version(self) -> None:
+        result = self.runner.invoke(main, ["--version"])
+        assert result.exit_code == 0
+        assert "0.1.0" in result.output
+
+    def test_cli_analyze_nonexistent_path(self) -> None:
+        result = self.runner.invoke(main, ["analyze", "/nonexistent/path"])
+        assert result.exit_code != 0
+
+    def test_cli_analyze_current_directory(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            with open(os.path.join(tmpdir, "test.py"), "w") as f:
+                f.write("def test(): pass\n")
+            result = self.runner.invoke(main, ["analyze", tmpdir])
+            assert result.exit_code == 0
+
+    def test_cli_analyze_with_output_format(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            with open(os.path.join(tmpdir, "test.py"), "w") as f:
+                f.write("def test(): pass\n")
+            result = self.runner.invoke(main, ["analyze", tmpdir, "--format", "json"])
+            assert result.exit_code == 0
+
+    def test_cli_analyze_with_max_files(self) -> None:
+        with tempfile.TemporaryDirectory() as tmpdir:
+            with open(os.path.join(tmpdir, "test.py"), "w") as f:
+                f.write("def test(): pass\n")
+            result = self.runner.invoke(main, ["analyze", tmpdir, "--max-files", "10"])
+            assert result.exit_code == 0
+
+    def test_cli_languages(self) -> None:
+        result = self.runner.invoke(main, ["languages"])
+        assert result.exit_code == 0
+        assert "python" in result.output.lower()
+
+    def test_cli_info_languages(self) -> None:
+        result = self.runner.invoke(main, ["info", "--languages"])
+        assert result.exit_code == 0
+        assert "python" in result.output.lower()

tests/unit/test_complexity.py

@@ -0,0 +1,269 @@
+"""Unit tests for complexity analysis module."""
+
+from codesnap.core.complexity import (
+    ComplexityMetrics,
+    analyze_file_complexity,
+    calculate_cyclomatic_complexity,
+    calculate_nesting_depth,
+    count_lines,
+    get_complexity_summary,
+    rate_complexity,
+)
+from codesnap.core.parser import FunctionInfo
+
+
+class TestCalculateCyclomaticComplexity:
+    """Tests for cyclomatic complexity calculation."""
+
+    def test_empty_content(self):
+        complexity, decisions = calculate_cyclomatic_complexity("")
+        assert complexity == 1
+        assert decisions == 0
+
+    def test_simple_function(self):
+        content = "def test():\n    pass"
+        complexity, decisions = calculate_cyclomatic_complexity(content)
+        assert complexity == 1
+
+    def test_if_statement(self):
+        content = "if x > 0:\n    pass"
+        complexity, decisions = calculate_cyclomatic_complexity(content)
+        assert complexity >= 1
+
+    def test_multiple_if_statements(self):
+        content = """
+if x > 0:
+    pass
+elif x < 0:
+    pass
+else:
+    pass
+"""
+        complexity, decisions = calculate_cyclomatic_complexity(content)
+        assert complexity >= 3
+
+    def test_for_loop(self):
+        content = "for i in range(10):\n    pass"
+        complexity, decisions = calculate_cyclomatic_complexity(content)
+        assert complexity >= 1
+
+    def test_while_loop(self):
+        content = "while True:\n    pass"
+        complexity, decisions = calculate_cyclomatic_complexity(content)
+        assert complexity >= 1
+
+    def test_try_except(self):
+        content = """
+try:
+    pass
+except Exception:
+    pass
+"""
+        complexity, decisions = calculate_cyclomatic_complexity(content)
+        assert complexity >= 1
+
+    def test_and_or_operators(self):
+        content = "if x > 0 and y > 0:\n    pass"
+        complexity, decisions = calculate_cyclomatic_complexity(content)
+        assert complexity >= 2
+
+    def test_ternary_operator(self):
+        content = "x = 1 if cond else 2"
+        complexity, decisions = calculate_cyclomatic_complexity(content)
+        assert complexity >= 1
+
+
+class TestCalculateNestingDepth:
+    """Tests for nesting depth calculation."""
+
+    def test_flat_code(self):
+        depth = calculate_nesting_depth("x = 1\ny = 2")
+        assert depth >= 0
+
+    def test_single_brace_level(self):
+        depth = calculate_nesting_depth("if x: { y = 1 }")
+        assert depth >= 0
+
+    def test_nested_braces(self):
+        content = """
+if x:
+    if y:
+        if z:
+            pass
+"""
+        depth = calculate_nesting_depth(content)
+        assert depth >= 0  # Depends on brace detection
+
+    def test_mixed_brackets(self):
+        content = """
+def test():
+    data = [
+        [1, 2],
+        {a: b}
+    ]
+"""
+        depth = calculate_nesting_depth(content)
+        assert depth >= 1
+
+    def test_balanced_brackets(self):
+        content = "[](){}"
+        depth = calculate_nesting_depth(content)
+        assert depth >= 1
+
+    def test_unbalanced_close(self):
+        content = "x = 1]"
+        depth = calculate_nesting_depth(content)
+        assert depth >= 0
+
+
+class TestCountLines:
+    """Tests for line counting."""
+
+    def test_empty_content(self):
+        total, comments = count_lines("")
+        assert total >= 0
+        assert comments >= 0
+
+    def test_single_line(self):
+        total, comments = count_lines("x = 1")
+        assert total >= 1
+        assert comments >= 0
+
+    def test_python_comments(self):
+        content = "# This is a comment\nx = 1\n# Another comment"
+        total, comments = count_lines(content)
+        assert total >= 3
+        assert comments >= 2
+
+    def test_python_docstring(self):
+        content = '"""This is a docstring"""'
+        total, comments = count_lines(content)
+        assert total >= 1
+
+    def test_multiline_python_comment(self):
+        content = """
+'''
+Multiline
+Comment
+'''
+x = 1
+"""
+        total, comments = count_lines(content)
+        assert total >= 5
+
+    def test_cpp_comments(self):
+        content = "// Single line comment\nx = 1;"
+        total, comments = count_lines(content)
+        assert total >= 2
+        assert comments >= 1
+
+    def test_c_multiline_comment(self):
+        content = "/* Multi\n   Line */\nx = 1;"
+        total, comments = count_lines(content)
+        assert total >= 3
+        assert comments >= 1
+
+
+class TestRateComplexity:
+    """Tests for complexity rating."""
+
+    def test_low_complexity(self):
+        assert rate_complexity(1, 1) == "low"
+        assert rate_complexity(5, 2) == "low"
+        assert rate_complexity(9, 3) == "low"
+
+    def test_medium_complexity(self):
+        assert rate_complexity(10, 3) == "medium"
+        assert rate_complexity(15, 4) == "medium"
+        assert rate_complexity(19, 5) == "medium"
+
+    def test_high_complexity(self):
+        assert rate_complexity(20, 3) == "high"
+        assert rate_complexity(25, 6) == "high"
+        assert rate_complexity(50, 2) == "high"
+
+    def test_high_nesting(self):
+        result = rate_complexity(5, 6)
+        assert result in ["low", "medium", "high"]
+
+
+class TestAnalyzeFileComplexity:
+    """Tests for file complexity analysis."""
+
+    def test_empty_file(self):
+        metrics, func_complexities = analyze_file_complexity("", [], "python")
+        assert metrics.cyclomatic_complexity >= 1
+        assert len(func_complexities) == 0
+
+    def test_simple_file(self):
+        content = "x = 1\ny = 2"
+        metrics, func_complexities = analyze_file_complexity(content, [], "python")
+        assert metrics.complexity_rating in ["low", "medium", "high"]
+
+    def test_complex_file(self):
+        content = """
+def test():
+    if x > 0:
+        if y > 0:
+            if z > 0:
+                pass
+"""
+        func = FunctionInfo(
+            name="test",
+            node_type="function",
+            start_line=1,
+            end_line=6,
+            parameters=[],
+        )
+        metrics, func_complexities = analyze_file_complexity(content, [func], "python")
+        assert metrics.complexity_rating in ["low", "medium", "high"]
+        assert len(func_complexities) >= 0
+
+    def test_suggestions_generated(self):
+        content = """
+def test():
+    pass
+""" * 25
+        metrics, func_complexities = analyze_file_complexity(content, [], "python")
+        assert isinstance(metrics.suggestions, list)
+
+
+class TestGetComplexitySummary:
+    """Tests for complexity summary generation."""
+
+    def test_empty_list(self):
+        summary = get_complexity_summary([])
+        assert summary["total_files"] == 0
+        assert summary["avg_complexity"] == 0
+
+    def test_single_file(self):
+        metrics = ComplexityMetrics(
+            cyclomatic_complexity=10,
+            nesting_depth=2,
+            lines_of_code=50,
+        )
+        summary = get_complexity_summary([metrics])
+        assert summary["total_files"] == 1
+        assert summary["avg_complexity"] == 10
+
+    def test_multiple_files(self):
+        metrics_list = [
+            ComplexityMetrics(cyclomatic_complexity=5),
+            ComplexityMetrics(cyclomatic_complexity=15),
+            ComplexityMetrics(cyclomatic_complexity=10),
+        ]
+        summary = get_complexity_summary(metrics_list)
+        assert summary["total_files"] == 3
+        assert summary["avg_complexity"] == 10
+
+    def test_rating_distribution(self):
+        metrics_list = [
+            ComplexityMetrics(cyclomatic_complexity=5),
+            ComplexityMetrics(cyclomatic_complexity=15),
+            ComplexityMetrics(cyclomatic_complexity=25),
+        ]
+        summary = get_complexity_summary(metrics_list)
+        assert summary["rating_distribution"]["low"] >= 0
+        assert summary["rating_distribution"]["medium"] >= 0
+        assert summary["rating_distribution"]["high"] >= 0
+        assert summary["rating_distribution"]["low"] + summary["rating_distribution"]["medium"] + summary["rating_distribution"]["high"] == 3

tests/unit/test_config.py

@@ -0,0 +1,71 @@
+"""Unit tests for config module."""
+
+import os
+
+from codesnap.utils.config import Config, apply_env_overrides, load_config
+
+
+class TestConfig:
+    """Tests for Config class."""
+
+    def test_default_values(self) -> None:
+        config = Config()
+        assert config.max_files == 1000
+        assert config.max_tokens == 8000
+        assert config.default_format == "markdown"
+
+    def test_custom_values(self) -> None:
+        config = Config(max_files=500, max_tokens=4000, default_format="json")
+        assert config.max_files == 500
+        assert config.max_tokens == 4000
+        assert config.default_format == "json"
+
+    def test_default_ignore_patterns(self) -> None:
+        config = Config()
+        assert isinstance(config.ignore_patterns, list)
+
+    def test_default_languages(self) -> None:
+        config = Config()
+        assert isinstance(config.included_languages, list)
+        assert isinstance(config.excluded_languages, list)
+
+
+class TestLoadConfig:
+    """Tests for load_config function."""
+
+    def test_load_default_config(self) -> None:
+        config = load_config()
+        assert config.max_files == 1000
+        assert config.max_tokens == 8000
+
+    def test_load_nonexistent_file(self) -> None:
+        from pathlib import Path
+        config = load_config(Path("/nonexistent/path.tomll"))
+        assert config.max_files == 1000
+
+
+class TestApplyEnvOverrides:
+    """Tests for apply_env_overrides function."""
+
+    def test_no_overrides(self) -> None:
+        config = Config()
+        result = apply_env_overrides(config)
+        assert result.max_files == 1000
+
+    def test_max_files_override(self) -> None:
+        os.environ["CODSNAP_MAX_FILES"] = "500"
+        try:
+            config = Config()
+            result = apply_env_overrides(config)
+            assert result.max_files == 500
+        finally:
+            del os.environ["CODSNAP_MAX_FILES"]
+
+    def test_max_tokens_override(self) -> None:
+        os.environ["CODSNAP_MAX_TOKENS"] = "4000"
+        try:
+            config = Config()
+            result = apply_env_overrides(config)
+            assert result.max_tokens == 4000
+        finally:
+            del os.environ["CODSNAP_MAX_TOKENS"]

tests/unit/test_dependency_graph.py

@@ -0,0 +1,177 @@
+"""Unit tests for dependency graph module."""
+
+from pathlib import Path
+
+from codesnap.core.dependency_graph import Dependency, DependencyGraphBuilder, DependencyParser
+
+
+class TestDependencyParser:
+    """Tests for DependencyParser class."""
+
+    def setup_method(self) -> None:
+        self.parser = DependencyParser()
+
+    def test_parse_python_import(self) -> None:
+        code = "import os"
+        deps = self.parser.parse_file(Path("test.py"), code, "python")
+        assert len(deps) >= 1
+
+    def test_parse_python_from_import(self) -> None:
+        code = "from pathlib import Path"
+        deps = self.parser.parse_file(Path("test.py"), code, "python")
+        assert len(deps) >= 1
+
+    def test_parse_python_multiple_imports(self) -> None:
+        code = """
+import os
+import sys
+from pathlib import Path
+from collections import defaultdict
+"""
+        deps = self.parser.parse_file(Path("test.py"), code, "python")
+        assert len(deps) >= 3
+
+    def test_parse_javascript_require(self) -> None:
+        code = "const express = require('express');"
+        deps = self.parser.parse_file(Path("test.js"), code, "javascript")
+        assert len(deps) >= 1
+
+    def test_parse_javascript_import(self) -> None:
+        code = "import { useState } from 'react';"
+        deps = self.parser.parse_file(Path("test.js"), code, "javascript")
+        assert len(deps) >= 1
+
+    def test_parse_go_import(self) -> None:
+        code = 'import "fmt"'
+        deps = self.parser.parse_file(Path("test.go"), code, "go")
+        assert len(deps) >= 1
+
+    def test_parse_rust_use(self) -> None:
+        code = "use std::collections::HashMap;"
+        deps = self.parser.parse_file(Path("test.rs"), code, "rust")
+        assert len(deps) >= 1
+
+    def test_parse_java_import(self) -> None:
+        code = "import java.util.ArrayList;"
+        deps = self.parser.parse_file(Path("test.java"), code, "java")
+        assert len(deps) >= 1
+
+    def test_parse_unsupported_language(self) -> None:
+        code = "some random code"
+        deps = self.parser.parse_file(Path("test.xyz"), code, "unsupported")
+        assert len(deps) == 0
+
+
+class TestDependencyGraphBuilder:
+    """Tests for DependencyGraphBuilder class."""
+
+    def setup_method(self) -> None:
+        self.graph = DependencyGraphBuilder()
+
+    def test_add_file(self) -> None:
+        self.graph.add_file(Path("main.py"), "python", 100, 10, 2, 1)
+        assert self.graph.graph.number_of_nodes() == 1
+        assert Path("main.py") in self.graph.graph.nodes()
+
+    def test_add_dependency(self) -> None:
+        self.graph.add_file(Path("a.py"), "python", 50, 5, 1, 0)
+        self.graph.add_file(Path("b.py"), "python", 60, 6, 1, 0)
+
+        dep = Dependency(
+            source_file=Path("a.py"),
+            target_file=Path("b.py"),
+            import_statement="import b",
+            import_type="import"
+        )
+        self.graph.add_dependency(dep)
+
+        assert self.graph.graph.has_edge(Path("a.py"), Path("b.py"))
+
+    def test_build_from_analysis(self) -> None:
+        analysis_result = {
+            "files": [
+                {"path": "main.py", "language": "python", "size": 100, "lines": 10, "functions": ["main"], "classes": []},
+                {"path": "utils.py", "language": "python", "size": 50, "lines": 5, "functions": ["helper"], "classes": []}
+            ],
+            "dependencies": [
+                {"source": "main.py", "target": "utils.py", "type": "import"}
+            ]
+        }
+        self.graph.build_from_analysis(analysis_result)
+
+        assert self.graph.graph.number_of_nodes() == 2
+        assert self.graph.graph.has_edge(Path("main.py"), Path("utils.py"))
+
+    def test_find_cycles(self) -> None:
+        self.graph.add_file(Path("a.py"), "python", 50, 5, 1, 0)
+        self.graph.add_file(Path("b.py"), "python", 50, 5, 1, 0)
+        self.graph.add_file(Path("c.py"), "python", 50, 5, 1, 0)
+
+        dep1 = Dependency(Path("a.py"), Path("b.py"), "import b", "import")
+        dep2 = Dependency(Path("b.py"), Path("c.py"), "import c", "import")
+        dep3 = Dependency(Path("c.py"), Path("a.py"), "import a", "import")
+
+        self.graph.add_dependency(dep1)
+        self.graph.add_dependency(dep2)
+        self.graph.add_dependency(dep3)
+
+        cycles = self.graph.find_cycles()
+        assert len(cycles) >= 1
+
+    def test_find_no_cycles(self) -> None:
+        self.graph.add_file(Path("a.py"), "python", 50, 5, 1, 0)
+        self.graph.add_file(Path("b.py"), "python", 50, 5, 1, 0)
+
+        dep = Dependency(Path("a.py"), Path("b.py"), "import b", "import")
+        self.graph.add_dependency(dep)
+
+        cycles = self.graph.find_cycles()
+        assert len(cycles) == 0
+
+    def test_find_orphaned_files(self) -> None:
+        self.graph.add_file(Path("orphan.py"), "python", 50, 5, 1, 0)
+        self.graph.add_file(Path("main.py"), "python", 100, 10, 2, 1)
+        self.graph.add_file(Path("used.py"), "python", 50, 5, 1, 0)
+
+        dep = Dependency(Path("main.py"), Path("used.py"), "import used", "import")
+        self.graph.add_dependency(dep)
+
+        orphaned = self.graph.find_orphaned_files()
+        assert Path("orphan.py") in orphaned
+        assert Path("main.py") not in orphaned
+        assert Path("used.py") not in orphaned
+
+    def test_calculate_metrics(self) -> None:
+        self.graph.add_file(Path("main.py"), "python", 100, 10, 2, 1)
+        self.graph.add_file(Path("utils.py"), "python", 50, 5, 1, 0)
+
+        dep = Dependency(Path("main.py"), Path("utils.py"), "import utils", "import")
+        self.graph.add_dependency(dep)
+
+        metrics = self.graph.calculate_metrics()
+
+        assert metrics.total_files == 2
+        assert metrics.total_edges == 1
+        assert metrics.density >= 0
+
+    def test_get_transitive_closure(self) -> None:
+        self.graph.add_file(Path("a.py"), "python", 50, 5, 1, 0)
+        self.graph.add_file(Path("b.py"), "python", 50, 5, 1, 0)
+        self.graph.add_file(Path("c.py"), "python", 50, 5, 1, 0)
+
+        self.graph.add_dependency(Dependency(Path("a.py"), Path("b.py"), "import b", "import"))
+        self.graph.add_dependency(Dependency(Path("b.py"), Path("c.py"), "import c", "import"))
+
+        dependents = self.graph.get_transitive_closure(Path("c.py"))
+        assert len(dependents) >= 0  # May or may not find depending on graph structure
+
+    def test_get_dependencies(self) -> None:
+        self.graph.add_file(Path("a.py"), "python", 50, 5, 1, 0)
+        self.graph.add_file(Path("b.py"), "python", 50, 5, 1, 0)
+        self.graph.add_file(Path("c.py"), "python", 50, 5, 1, 0)
+
+        self.graph.add_dependency(Dependency(Path("a.py"), Path("b.py"), "import b", "import"))
+        self.graph.add_dependency(Dependency(Path("a.py"), Path("c.py"), "import c", "import"))
+
+        deps = self.graph.get_dependencies(Path("a.py"))
+        assert isinstance(deps, set)  # Returns a set

tests/unit/test_extractor.py

@@ -0,0 +1,112 @@
+from codesnap.core.extractor import FunctionExtractor
+
+
+class TestFunctionExtractor:
+    def setup_method(self) -> None:
+        self.extractor = FunctionExtractor()
+
+    def test_extract_simple_function(self) -> None:
+        code = """
+def hello():
+    print("Hello, World!")
+"""
+        functions = self.extractor.extract_functions_python(code)
+        assert len(functions) >= 1
+        func = functions[0]
+        assert func.name == "hello"
+        assert len(func.parameters) == 0
+
+    def test_extract_function_with_parameters(self) -> None:
+        code = """
+def greet(name, greeting="Hello"):
+    return f"{greeting}, {name}!"
+"""
+        functions = self.extractor.extract_functions_python(code)
+        assert len(functions) >= 1
+        func = functions[0]
+        assert func.name == "greet"
+        assert "name" in func.parameters
+        assert "greeting" in func.parameters
+
+    def test_extract_async_function(self) -> None:
+        code = """
+async def fetch_data(url):
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url) as response:
+            return await response.json()
+"""
+        functions = self.extractor.extract_functions_python(code)
+        assert len(functions) >= 1
+        func = functions[0]
+        assert func.name == "fetch_data"
+        assert func.is_async is True
+
+    def test_extract_function_with_return_type(self) -> None:
+        code = """
+def add(a: int, b: int) -> int:
+    return a + b
+"""
+        functions = self.extractor.extract_functions_python(code)
+        assert len(functions) >= 1
+        func = functions[0]
+        assert func.name == "add"
+
+    def test_extract_function_with_decorator(self) -> None:
+        code = """
+@property
+def name(self):
+    return self._name
+"""
+        functions = self.extractor.extract_functions_python(code)
+        assert len(functions) >= 1
+
+    def test_extract_classes(self) -> None:
+        code = """
+class MyClass:
+    def __init__(self):
+        self.value = 42
+
+    def get_value(self):
+        return self.value
+"""
+        classes = self.extractor.extract_classes_python(code)
+        assert len(classes) >= 1
+        cls = classes[0]
+        assert cls.name == "MyClass"
+
+    def test_extract_class_with_inheritance(self) -> None:
+        code = """
+class ChildClass(ParentClass, MixinClass):
+    pass
+"""
+        classes = self.extractor.extract_classes_python(code)
+        assert len(classes) >= 1
+        cls = classes[0]
+        assert "ParentClass" in cls.base_classes
+        assert "MixinClass" in cls.base_classes
+
+    def test_extract_all_python(self) -> None:
+        code = """
+def func1():
+    pass
+
+class MyClass:
+    def method1(self):
+        pass
+
+def func2():
+    pass
+"""
+        functions, classes = self.extractor.extract_all(code, "python")
+        assert len(functions) >= 2
+        assert len(classes) >= 1
+
+    def test_extract_from_file(self) -> None:
+        code = """
+def test_function(x, y):
+    return x + y
+"""
+        result = self.extractor.extract_from_file("test.py", code, "python")
+        assert result["file"] == "test.py"
+        assert len(result["functions"]) >= 1
+        assert result["functions"][0]["name"] == "test_function"

tests/unit/test_file_utils.py

@@ -0,0 +1,98 @@
+from codesnap.utils.file_utils import FileUtils
+
+
+class TestFileUtils:
+    def test_should_ignore_patterns(self) -> None:
+        assert FileUtils.should_ignore("test.pyc", ["*.pyc"]) is True
+        assert FileUtils.should_ignore("test.pyc", ["*.pyc", "*.pyo"]) is True
+        assert FileUtils.should_ignore("test.py", ["*.pyc"]) is False
+
+    def test_should_ignore_directory(self) -> None:
+        assert FileUtils.should_ignore("src/__pycache__", ["__pycache__/*"]) is True
+        assert FileUtils.should_ignore(".git/config", [".git/*"]) is True
+
+    def test_is_text_file(self) -> None:
+        assert FileUtils.is_text_file("test.py") is True
+        assert FileUtils.is_text_file("test.js") is True
+        assert FileUtils.is_text_file("test.tsx") is True
+        assert FileUtils.is_text_file("Dockerfile") is True
+
+    def test_is_not_binary_file(self) -> None:
+        assert FileUtils.is_text_file("test.png") is False
+        assert FileUtils.is_text_file("test.jpg") is False
+        assert FileUtils.is_text_file("test.so") is False
+
+    def test_read_file_content(self) -> None:
+        import os
+        import tempfile
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.py', delete=False) as f:
+            f.write("print('hello')")
+            temp_path = f.name
+        try:
+            content = FileUtils.read_file_content(temp_path)
+            assert content == "print('hello')"
+        finally:
+            os.unlink(temp_path)
+
+    def test_read_file_content_not_found(self) -> None:
+        content = FileUtils.read_file_content("/nonexistent/file.py")
+        assert content is None
+
+    def test_count_lines(self) -> None:
+        content = "line1\nline2\nline3"
+        assert FileUtils.count_lines(content) == 3
+        assert FileUtils.count_lines("") == 1
+        assert FileUtils.count_lines("single") == 1
+
+    def test_get_relative_path(self) -> None:
+        import os
+        import tempfile
+        with tempfile.TemporaryDirectory() as tmpdir:
+            subdir = os.path.join(tmpdir, "subdir")
+            os.makedirs(subdir)
+            filepath = os.path.join(subdir, "test.py")
+            rel = FileUtils.get_relative_path(filepath, tmpdir)
+            assert rel == os.path.join("subdir", "test.py")
+
+    def test_walk_directory(self) -> None:
+        import os
+        import tempfile
+        with tempfile.TemporaryDirectory() as tmpdir:
+            os.makedirs(os.path.join(tmpdir, "src"))
+            os.makedirs(os.path.join(tmpdir, "tests"))
+            with open(os.path.join(tmpdir, "main.py"), "w") as f:
+                f.write("print('hello')")
+            with open(os.path.join(tmpdir, "src", "module.py"), "w") as f:
+                f.write("def test(): pass")
+
+            files = FileUtils.walk_directory(tmpdir, ["*.pyc", "__pycache__/*"], 100)
+            assert len(files) == 2
+
+    def test_walk_directory_with_ignore(self) -> None:
+        import os
+        import tempfile
+        with tempfile.TemporaryDirectory() as tmpdir:
+            os.makedirs(os.path.join(tmpdir, "__pycache__"))
+            with open(os.path.join(tmpdir, "main.py"), "w") as f:
+                f.write("print('hello')")
+            with open(os.path.join(tmpdir, "__pycache__", "cache.pyc"), "w") as f:
+                f.write("cached")
+
+            files = FileUtils.walk_directory(tmpdir, ["*.pyc", "__pycache__/*"], 100)
+            assert len(files) == 1
+            assert "__pycache__" not in files[0]
+
+    def test_get_directory_tree(self) -> None:
+        import os
+        import tempfile
+        with tempfile.TemporaryDirectory() as tmpdir:
+            os.makedirs(os.path.join(tmpdir, "src"))
+            os.makedirs(os.path.join(tmpdir, "tests"))
+            with open(os.path.join(tmpdir, "main.py"), "w") as f:
+                f.write("")
+            with open(os.path.join(tmpdir, "src", "module.py"), "w") as f:
+                f.write("")
+
+            tree = FileUtils.get_directory_tree(tmpdir, ["*.pyc"], 3)
+            assert len(tree) > 0
+            assert any("main.py" in line for line in tree)

tests/unit/test_formatters.py

@@ -0,0 +1,428 @@
+"""Unit tests for output formatters."""
+
+import json
+from pathlib import Path
+
+from codesnap.core.analyzer import AnalysisResult, FileAnalysis
+from codesnap.core.parser import ClassInfo, FunctionInfo
+from codesnap.output.json_exporter import export_json, export_json_file
+from codesnap.output.llm_exporter import (
+    estimate_tokens,
+    export_llm_optimized,
+    truncate_for_token_limit,
+)
+from codesnap.output.markdown_exporter import export_markdown, export_markdown_file
+
+
+class TestJsonExporter:
+    """Tests for JSON export functionality."""
+
+    def create_test_result(self):
+        """Create a test analysis result."""
+        func = FunctionInfo(
+            name="test_function",
+            node_type="function_definition",
+            start_line=1,
+            end_line=10,
+            parameters=[{"name": "x", "type": "int"}],
+            return_type="str",
+            is_async=False,
+        )
+
+        cls = ClassInfo(
+            name="TestClass",
+            start_line=1,
+            end_line=20,
+            bases=["BaseClass"],
+            methods=[func],
+        )
+
+        file_analysis = FileAnalysis(
+            path=Path("/test/project/main.py"),
+            language="python",
+            size=500,
+            lines=50,
+            functions=[func],
+            classes=[cls],
+        )
+
+        result = AnalysisResult()
+        result.summary = {
+            "total_files": 1,
+            "total_functions": 1,
+            "total_classes": 1,
+            "total_dependencies": 0,
+            "languages": {"python": 1},
+        }
+        result.files = [file_analysis]
+        result.dependencies = []
+        result.metrics = {}
+        result.analysis_time = 0.1
+        result.error_count = 0
+
+        return result
+
+    def test_export_json_structure(self):
+        result = self.create_test_result()
+        root = Path("/test/project")
+
+        json_output = export_json(result, root)
+
+        data = json.loads(json_output)
+
+        assert "metadata" in data
+        assert "summary" in data
+        assert "files" in data
+        assert "dependencies" in data
+        assert "metrics" in data
+
+    def test_export_json_metadata(self):
+        result = self.create_test_result()
+        root = Path("/test/project")
+
+        json_output = export_json(result, root)
+        data = json.loads(json_output)
+
+        assert data["metadata"]["tool"] == "CodeSnap"
+        assert data["metadata"]["version"] == "0.1.0"
+        assert "timestamp" in data["metadata"]
+        assert data["metadata"]["root_path"] == "/test/project"
+
+    def test_export_json_summary(self):
+        result = self.create_test_result()
+        root = Path("/test/project")
+
+        json_output = export_json(result, root)
+        data = json.loads(json_output)
+
+        assert data["summary"]["total_files"] == 1
+        assert data["summary"]["total_functions"] == 1
+        assert data["summary"]["total_classes"] == 1
+
+    def test_export_json_functions(self):
+        result = self.create_test_result()
+        root = Path("/test/project")
+
+        json_output = export_json(result, root)
+        data = json.loads(json_output)
+
+        assert len(data["files"]) == 1
+        assert len(data["files"][0]["functions"]) == 1
+        assert data["files"][0]["functions"][0]["name"] == "test_function"
+
+    def test_export_json_classes(self):
+        result = self.create_test_result()
+        root = Path("/test/project")
+
+        json_output = export_json(result, root)
+        data = json.loads(json_output)
+
+        assert len(data["files"][0]["classes"]) == 1
+        assert data["files"][0]["classes"][0]["name"] == "TestClass"
+        assert data["files"][0]["classes"][0]["bases"] == ["BaseClass"]
+
+    def test_export_json_file(self, tmp_path):
+        result = self.create_test_result()
+        root = Path("/test/project")
+        output_file = tmp_path / "output.json"
+
+        export_json_file(result, root, output_file)
+
+        assert output_file.exists()
+
+        data = json.loads(output_file.read_text())
+        assert "metadata" in data
+
+
+class TestMarkdownExporter:
+    """Tests for Markdown export functionality."""
+
+    def create_test_result(self):
+        """Create a test analysis result."""
+        func = FunctionInfo(
+            name="process_data",
+            node_type="function_definition",
+            start_line=5,
+            end_line=15,
+            parameters=[{"name": "data"}, {"name": "options"}],
+            is_async=True,
+        )
+
+        file_analysis = FileAnalysis(
+            path=Path("/test/project/utils.py"),
+            language="python",
+            size=300,
+            lines=30,
+            functions=[func],
+            classes=[],
+        )
+
+        result = AnalysisResult()
+        result.summary = {
+            "total_files": 1,
+            "total_functions": 1,
+            "total_classes": 0,
+            "total_dependencies": 0,
+            "languages": {"python": 1},
+        }
+        result.files = [file_analysis]
+        result.dependencies = []
+        result.metrics = {}
+        result.analysis_time = 0.05
+        result.error_count = 0
+
+        return result
+
+    def test_export_markdown_header(self):
+        result = self.create_test_result()
+        root = Path("/test/project")
+
+        md_output = export_markdown(result, root)
+
+        assert "# CodeSnap Analysis Report" in md_output
+
+    def test_export_markdown_summary(self):
+        result = self.create_test_result()
+        root = Path("/test/project")
+
+        md_output = export_markdown(result, root)
+
+        assert "## Summary" in md_output
+        assert "Total Files" in md_output
+        assert "1" in md_output
+
+    def test_export_markdown_language_breakdown(self):
+        result = self.create_test_result()
+        root = Path("/test/project")
+
+        md_output = export_markdown(result, root)
+
+        assert "### Language Breakdown" in md_output
+        assert "python" in md_output.lower()
+
+    def test_export_markdown_file_structure(self):
+        result = self.create_test_result()
+        root = Path("/test/project")
+
+        md_output = export_markdown(result, root)
+
+        assert "## File Structure" in md_output
+        assert "```" in md_output
+
+    def test_export_markdown_functions(self):
+        result = self.create_test_result()
+        root = Path("/test/project")
+
+        md_output = export_markdown(result, root)
+
+        assert "process_data" in md_output
+        assert "async" in md_output.lower()
+
+    def test_export_markdown_file(self, tmp_path):
+        result = self.create_test_result()
+        root = Path("/test/project")
+        output_file = tmp_path / "output.md"
+
+        export_markdown_file(result, root, output_file)
+
+        assert output_file.exists()
+        content = output_file.read_text()
+        assert "# CodeSnap Analysis Report" in content
+
+    def test_empty_result(self):
+        result = AnalysisResult()
+        result.summary = {}
+        result.files = []
+        result.dependencies = []
+        result.metrics = {}
+        result.analysis_time = 0
+        result.error_count = 0
+
+        root = Path("/test")
+        md_output = export_markdown(result, root)
+
+        assert "# CodeSnap Analysis Report" in md_output
+
+
+class TestLLMExporter:
+    """Tests for LLM-optimized export functionality."""
+
+    def test_estimate_tokens_python(self):
+        text = "def hello():\n    print('hello')"
+        tokens = estimate_tokens(text, "python")
+
+        assert tokens > 0
+        assert tokens < len(text)
+
+    def test_estimate_tokens_markdown(self):
+        text = "# Heading\n\nSome content here."
+        tokens = estimate_tokens(text, "markdown")
+
+        assert tokens > 0
+
+    def test_truncate_under_limit(self):
+        text = "Short text"
+        result = truncate_for_token_limit(text, 100, "markdown")
+
+        assert result == text
+
+    def test_truncate_over_limit(self):
+        text = "A" * 1000
+        result = truncate_for_token_limit(text, 100, "markdown")
+
+        assert len(result) < len(text)
+        assert "[Output truncated due to token limit]" in result
+
+    def test_export_llm_optimized_structure(self):
+        func = FunctionInfo(
+            name="helper",
+            node_type="function",
+            start_line=1,
+            end_line=5,
+        )
+
+        file_analysis = FileAnalysis(
+            path=Path("/test/main.py"),
+            language="python",
+            size=100,
+            lines=10,
+            functions=[func],
+            classes=[],
+        )
+
+        result = AnalysisResult()
+        result.summary = {
+            "total_files": 1,
+            "total_functions": 1,
+            "total_classes": 0,
+            "total_dependencies": 0,
+            "languages": {"python": 1},
+        }
+        result.files = [file_analysis]
+        result.dependencies = []
+        result.metrics = {}
+        result.analysis_time = 0.01
+        result.error_count = 0
+
+        root = Path("/test")
+        output = export_llm_optimized(result, root)
+
+        assert "## CODEBASE ANALYSIS SUMMARY" in output
+        assert "### STRUCTURE" in output
+        assert "### KEY COMPONENTS" in output
+
+    def test_export_llm_with_max_tokens(self):
+        func = FunctionInfo(
+            name="test",
+            node_type="function",
+            start_line=1,
+            end_line=5,
+        )
+
+        file_analysis = FileAnalysis(
+            path=Path("/test/main.py"),
+            language="python",
+            size=100,
+            lines=10,
+            functions=[func],
+            classes=[],
+        )
+
+        result = AnalysisResult()
+        result.summary = {
+            "total_files": 1,
+            "total_functions": 1,
+            "total_classes": 0,
+            "total_dependencies": 0,
+            "languages": {"python": 1},
+        }
+        result.files = [file_analysis]
+        result.dependencies = []
+        result.metrics = {}
+        result.analysis_time = 0.01
+        result.error_count = 0
+
+        root = Path("/test")
+        output = export_llm_optimized(result, root, max_tokens=100)
+
+        tokens = estimate_tokens(output, "markdown")
+        assert tokens <= 100 or "[Output truncated" in output
+
+
+class TestFormatterIntegration:
+    """Integration tests for formatters."""
+
+    def test_json_is_valid_json(self):
+        func = FunctionInfo(name="test", node_type="func", start_line=1, end_line=10)
+        file_analysis = FileAnalysis(
+            path=Path("/test/main.py"),
+            language="python",
+            size=100,
+            lines=10,
+            functions=[func],
+        )
+
+        result = AnalysisResult()
+        result.summary = {"total_files": 1}
+        result.files = [file_analysis]
+        result.dependencies = []
+        result.metrics = {}
+        result.analysis_time = 0
+
+        root = Path("/test")
+
+        json_output = export_json(result, root)
+
+        data = json.loads(json_output)
+        assert data is not None
+
+    def test_markdown_is_readable(self):
+        func = FunctionInfo(name="test", node_type="func", start_line=1, end_line=10)
+        file_analysis = FileAnalysis(
+            path=Path("/test/main.py"),
+            language="python",
+            size=100,
+            lines=10,
+            functions=[func],
+        )
+
+        result = AnalysisResult()
+        result.summary = {"total_files": 1}
+        result.files = [file_analysis]
+        result.dependencies = []
+        result.metrics = {}
+        result.analysis_time = 0
+
+        root = Path("/test")
+
+        md_output = export_markdown(result, root)
+
+        assert md_output is not None
+        assert len(md_output) > 0
+        assert "#" in md_output
+
+    def test_llm_output_has_summary_first(self):
+        func = FunctionInfo(name="test", node_type="func", start_line=1, end_line=10)
+        file_analysis = FileAnalysis(
+            path=Path("/test/main.py"),
+            language="python",
+            size=100,
+            lines=10,
+            functions=[func],
+        )
+
+        result = AnalysisResult()
+        result.summary = {"total_files": 1}
+        result.files = [file_analysis]
+        result.dependencies = []
+        result.metrics = {}
+        result.analysis_time = 0
+
+        root = Path("/test")
+
+        output = export_llm_optimized(result, root)
+
+        summary_pos = output.find("CODEBASE ANALYSIS SUMMARY")
+        structure_pos = output.find("STRUCTURE")
+
+        assert summary_pos < structure_pos

tests/unit/test_json_formatter.py

@@ -0,0 +1,77 @@
+from codesnap.output.json_formatter import JSONFormatter
+
+
+class TestJSONFormatter:
+    def setup_method(self) -> None:
+        self.formatter = JSONFormatter()
+
+    def test_format_valid_result(self) -> None:
+        result = {
+            "files": [
+                {
+                    "file": "test.py",
+                    "language": "python",
+                    "lines": 50,
+                    "functions": [{"name": "test_func", "start_line": 1, "end_line": 10}],
+                    "classes": [],
+                    "complexity": {"score": 5, "rating": "low"}
+                }
+            ],
+            "dependency_graph": {
+                "total_dependencies": 0,
+                "orphaned_files": 0,
+                "cycles_detected": 0,
+                "cycle_details": [],
+                "orphaned_details": [],
+                "edges": [],
+                "statistics": {}
+            }
+        }
+        output = self.formatter.format(result)
+        import json
+        parsed = json.loads(output)
+        assert "schema_version" in parsed
+        assert "summary" in parsed
+        assert "files" in parsed
+        assert parsed["summary"]["total_files"] == 1
+
+    def test_format_empty_result(self) -> None:
+        result = {
+            "files": [],
+            "dependency_graph": {
+                "total_dependencies": 0,
+                "orphaned_files": 0,
+                "cycles_detected": 0,
+                "cycle_details": [],
+                "orphaned_details": [],
+                "edges": [],
+                "statistics": {}
+            }
+        }
+        output = self.formatter.format(result)
+        import json
+        parsed = json.loads(output)
+        assert parsed["summary"]["total_files"] == 0
+
+    def test_summary_includes_language_counts(self) -> None:
+        result = {
+            "files": [
+                {"file": "a.py", "language": "python", "lines": 10, "functions": [], "classes": [], "complexity": {}},
+                {"file": "b.js", "language": "javascript", "lines": 20, "functions": [], "classes": [], "complexity": {}},
+                {"file": "c.py", "language": "python", "lines": 30, "functions": [], "classes": [], "complexity": {}}
+            ],
+            "dependency_graph": {
+                "total_dependencies": 0,
+                "orphaned_files": 0,
+                "cycles_detected": 0,
+                "cycle_details": [],
+                "orphaned_details": [],
+                "edges": [],
+                "statistics": {}
+            }
+        }
+        output = self.formatter.format(result)
+        import json
+        parsed = json.loads(output)
+        assert parsed["summary"]["languages"]["python"] == 2
+        assert parsed["summary"]["languages"]["javascript"] == 1

tests/unit/test_language_detector.py

@@ -0,0 +1,168 @@
+"""Unit tests for language detection module."""
+
+from pathlib import Path
+
+from codesnap.core.language_detector import (
+    EXTENSION_TO_LANGUAGE,
+    detect_language,
+    detect_language_by_extension,
+    detect_language_by_shebang,
+    get_language_info,
+    get_supported_extensions,
+    get_supported_languages,
+)
+
+
+class TestDetectLanguageByExtension:
+    """Tests for extension-based language detection."""
+
+    def test_python_extension_py(self):
+        assert detect_language_by_extension(Path("test.py")) == "python"
+
+    def test_python_extension_pyi(self):
+        assert detect_language_by_extension(Path("test.pyi")) == "python"
+
+    def test_javascript_extension_js(self):
+        assert detect_language_by_extension(Path("test.js")) == "javascript"
+
+    def test_typescript_extension_ts(self):
+        assert detect_language_by_extension(Path("test.ts")) == "typescript"
+
+    def test_go_extension(self):
+        assert detect_language_by_extension(Path("main.go")) == "go"
+
+    def test_rust_extension(self):
+        assert detect_language_by_extension(Path("main.rs")) == "rust"
+
+    def test_java_extension(self):
+        assert detect_language_by_extension(Path("Main.java")) == "java"
+
+    def test_cpp_extension(self):
+        assert detect_language_by_extension(Path("test.cpp")) == "cpp"
+        assert detect_language_by_extension(Path("test.hpp")) == "cpp"
+
+    def test_ruby_extension(self):
+        assert detect_language_by_extension(Path("script.rb")) == "ruby"
+
+    def test_php_extension(self):
+        assert detect_language_by_extension(Path("script.php")) == "php"
+
+    def test_unknown_extension(self):
+        assert detect_language_by_extension(Path("test.xyz")) is None
+
+    def test_case_insensitive(self):
+        assert detect_language_by_extension(Path("test.PY")) == "python"
+        assert detect_language_by_extension(Path("test.JS")) == "javascript"
+
+
+class TestDetectLanguageByShebang:
+    """Tests for shebang-based language detection."""
+
+    def test_python_shebang(self):
+        content = "#!/usr/bin/env python3\nprint('hello')"
+        assert detect_language_by_shebang(content) == "python"
+
+    def test_python_shebang_alt(self):
+        content = "#!/usr/bin/python\nprint('hello')"
+        assert detect_language_by_shebang(content) == "python"
+
+    def test_node_shebang(self):
+        content = "#!/usr/bin/env node\nconsole.log('hello')"
+        assert detect_language_by_shebang(content) == "javascript"
+
+    def test_ruby_shebang(self):
+        content = "#!/usr/bin/env ruby\nputs 'hello'"
+        assert detect_language_by_shebang(content) == "ruby"
+
+    def test_php_shebang(self):
+        content = "#!/usr/bin/env php\necho 'hello';"
+        assert detect_language_by_shebang(content) == "php"
+
+    def test_no_shebang(self):
+        content = "print('hello')"
+        assert detect_language_by_shebang(content) is None
+
+    def test_empty_content(self):
+        assert detect_language_by_shebang("") is None
+
+
+class TestDetectLanguage:
+    """Tests for combined language detection."""
+
+    def test_detection_by_extension(self):
+        assert detect_language(Path("test.py")) == "python"
+        assert detect_language(Path("test.js")) == "javascript"
+
+    def test_detection_fallback_to_shebang(self):
+        file_path = Path("script")
+        assert detect_language(file_path, "#!/usr/bin/env python") == "python"
+        assert detect_language(file_path, "#!/usr/bin/env node") == "javascript"
+
+    def test_unknown_file_no_content(self):
+        assert detect_language(Path("unknown.xyz")) is None
+
+
+class TestGetLanguageInfo:
+    """Tests for language info retrieval."""
+
+    def test_get_python_info(self):
+        info = get_language_info("python")
+        assert info is not None
+        assert info.name == "python"
+        assert ".py" in info.extensions
+
+    def test_get_unknown_language(self):
+        info = get_language_info("unknown")
+        assert info is None
+
+
+class TestGetSupportedExtensions:
+    """Tests for supported extensions."""
+
+    def test_returns_set(self):
+        extensions = get_supported_extensions()
+        assert isinstance(extensions, set)
+
+    def test_includes_common_extensions(self):
+        extensions = get_supported_extensions()
+        assert ".py" in extensions
+        assert ".js" in extensions
+        assert ".ts" in extensions
+        assert ".go" in extensions
+
+
+class TestGetSupportedLanguages:
+    """Tests for supported programming languages."""
+
+    def test_returns_list(self):
+        languages = get_supported_languages()
+        assert isinstance(languages, list)
+
+    def test_includes_main_languages(self):
+        languages = get_supported_languages()
+        assert "python" in languages
+        assert "javascript" in languages
+        assert "typescript" in languages
+        assert "go" in languages
+        assert "rust" in languages
+        assert "java" in languages
+
+    def test_excludes_config_formats(self):
+        languages = get_supported_languages()
+        assert "json" not in languages
+        assert "yaml" not in languages
+        assert "markdown" not in languages
+
+
+class TestExtensionToLanguage:
+    """Tests for extension to language mapping."""
+
+    def test_mapping_completeness(self):
+        for _ext, lang in EXTENSION_TO_LANGUAGE.items():
+            assert lang in ["python", "javascript", "typescript", "go", "rust",
+                           "java", "c", "cpp", "ruby", "php", "shell",
+                           "json", "yaml", "markdown"]
+
+    def test_no_duplicate_extensions(self):
+        extensions = list(EXTENSION_TO_LANGUAGE.keys())
+        assert len(extensions) == len(set(extensions))

tests/unit/test_llm_formatter.py

@@ -0,0 +1,112 @@
+from codesnap.output.llm_formatter import LLMFormatter
+
+
+class TestLLMFormatter:
+    def setup_method(self) -> None:
+        self.formatter = LLMFormatter(max_tokens=1000)
+
+    def test_format_valid_result(self) -> None:
+        result = {
+            "files": [
+                {
+                    "file": "test.py",
+                    "language": "python",
+                    "lines": 50,
+                    "functions": [{"name": "test_func", "start_line": 1, "end_line": 10, "parameters": [], "return_type": "str"}],
+                    "classes": [],
+                    "complexity": {"score": 5, "rating": "low"}
+                }
+            ],
+            "dependency_graph": {
+                "total_dependencies": 0,
+                "orphaned_files": 0,
+                "cycles_detected": 0,
+                "cycle_details": [],
+                "orphaned_details": [],
+                "edges": [],
+                "statistics": {}
+            }
+        }
+        output = self.formatter.format(result)
+        assert "## Codebase Summary" in output
+        assert "### Key Files" in output
+        assert "### Classes and Functions" in output
+        assert "### Dependencies" in output
+
+    def test_respects_token_limit(self) -> None:
+        result = {
+            "files": [],
+            "dependency_graph": {
+                "total_dependencies": 0,
+                "orphaned_files": 0,
+                "cycles_detected": 0,
+                "cycle_details": [],
+                "orphaned_details": [],
+                "edges": [],
+                "statistics": {}
+            }
+        }
+        output = self.formatter.format(result)
+        max_chars = 1000 * 4
+        assert len(output) <= max_chars + 100
+
+    def test_includes_high_level_summary(self) -> None:
+        result = {
+            "files": [
+                {"file": "a.py", "language": "python", "lines": 50, "functions": [], "classes": [], "complexity": {}},
+                {"file": "b.py", "language": "python", "lines": 30, "functions": [], "classes": [], "complexity": {}},
+                {"file": "c.js", "language": "javascript", "lines": 20, "functions": [], "classes": [], "complexity": {}}
+            ],
+            "dependency_graph": {
+                "total_dependencies": 0,
+                "orphaned_files": 0,
+                "cycles_detected": 0,
+                "cycle_details": [],
+                "orphaned_details": [],
+                "edges": [],
+                "statistics": {}
+            }
+        }
+        output = self.formatter.format(result)
+        assert "python" in output.lower()
+        assert "3 files" in output or "files" in output
+
+    def test_compresses_detailed_file_list(self) -> None:
+        result = {
+            "files": [
+                {"file": f"file{i}.py", "language": "python", "lines": 10,
+                 "functions": [{"name": f"func{i}a"}, {"name": f"func{i}b"}, {"name": f"func{i}c"}],
+                 "classes": [], "complexity": {}}
+                for i in range(10)
+            ],
+            "dependency_graph": {
+                "total_dependencies": 0,
+                "orphaned_files": 0,
+                "cycles_detected": 0,
+                "cycle_details": [],
+                "orphaned_details": [],
+                "edges": [],
+                "statistics": {}
+            }
+        }
+        output = self.formatter.format(result)
+        assert "Detailed File List (compressed)" in output
+
+    def test_warns_about_cycles(self) -> None:
+        result = {
+            "files": [
+                {"file": "a.py", "language": "python", "lines": 10, "functions": [], "classes": [], "complexity": {}},
+                {"file": "b.py", "language": "python", "lines": 10, "functions": [], "classes": [], "complexity": {}}
+            ],
+            "dependency_graph": {
+                "total_dependencies": 2,
+                "orphaned_files": 0,
+                "cycles_detected": 1,
+                "cycle_details": [["a.py", "b.py", "a.py"]],
+                "orphaned_details": [],
+                "edges": [],
+                "statistics": {}
+            }
+        }
+        output = self.formatter.format(result)
+        assert "circular" in output.lower() or "cycle" in output.lower()

tests/unit/test_markdown_formatter.py

@@ -0,0 +1,117 @@
+from codesnap.output.markdown_formatter import MarkdownFormatter
+
+
+class TestMarkdownFormatter:
+    def setup_method(self) -> None:
+        self.formatter = MarkdownFormatter()
+
+    def test_format_valid_result(self) -> None:
+        result = {
+            "files": [
+                {
+                    "file": "test.py",
+                    "language": "python",
+                    "lines": 50,
+                    "functions": [{"name": "test_func", "start_line": 1, "end_line": 10, "parameters": [], "return_type": "str"}],
+                    "classes": [],
+                    "complexity": {"score": 5, "rating": "low"}
+                }
+            ],
+            "dependency_graph": {
+                "total_dependencies": 0,
+                "orphaned_files": 0,
+                "cycles_detected": 0,
+                "cycle_details": [],
+                "orphaned_details": [],
+                "edges": [],
+                "statistics": {}
+            }
+        }
+        output = self.formatter.format(result)
+        assert "# CodeSnap Analysis Report" in output
+        assert "## Overview" in output
+        assert "## File Structure" in output
+        assert "## Key Functions" in output
+        assert "## Dependencies" in output
+        assert "## Complexity Metrics" in output
+
+    def test_format_empty_result(self) -> None:
+        result = {
+            "files": [],
+            "dependency_graph": {
+                "total_dependencies": 0,
+                "orphaned_files": 0,
+                "cycles_detected": 0,
+                "cycle_details": [],
+                "orphaned_details": [],
+                "edges": [],
+                "statistics": {}
+            }
+        }
+        output = self.formatter.format(result)
+        assert "Total Files" in output
+
+    def test_includes_language_breakdown(self) -> None:
+        result = {
+            "files": [
+                {"file": "a.py", "language": "python", "lines": 10, "functions": [], "classes": [], "complexity": {}},
+                {"file": "b.js", "language": "javascript", "lines": 20, "functions": [], "classes": [], "complexity": {}}
+            ],
+            "dependency_graph": {
+                "total_dependencies": 0,
+                "orphaned_files": 0,
+                "cycles_detected": 0,
+                "cycle_details": [],
+                "orphaned_details": [],
+                "edges": [],
+                "statistics": {}
+            }
+        }
+        output = self.formatter.format(result)
+        assert "python: 1" in output or "python: 2" in output
+        assert "javascript:" in output
+
+    def test_shows_circular_dependencies(self) -> None:
+        result = {
+            "files": [
+                {"file": "a.py", "language": "python", "lines": 10, "functions": [], "classes": [], "complexity": {}},
+                {"file": "b.py", "language": "python", "lines": 10, "functions": [], "classes": [], "complexity": {}}
+            ],
+            "dependency_graph": {
+                "total_dependencies": 2,
+                "orphaned_files": 0,
+                "cycles_detected": 1,
+                "cycle_details": [["a.py", "b.py", "a.py"]],
+                "orphaned_details": [],
+                "edges": [{"from": "a.py", "to": "b.py"}, {"from": "b.py", "to": "a.py"}],
+                "statistics": {}
+            }
+        }
+        output = self.formatter.format(result)
+        assert "Circular Dependencies Detected" in output
+
+    def test_shows_high_complexity_files(self) -> None:
+        result = {
+            "files": [
+                {
+                    "file": "complex.py",
+                    "language": "python",
+                    "lines": 100,
+                    "functions": [],
+                    "classes": [],
+                    "complexity": {"score": 55, "rating": "high"}
+                }
+            ],
+            "dependency_graph": {
+                "total_dependencies": 0,
+                "orphaned_files": 0,
+                "cycles_detected": 0,
+                "cycle_details": [],
+                "orphaned_details": [],
+                "edges": [],
+                "statistics": {}
+            }
+        }
+        output = self.formatter.format(result)
+        assert "High Complexity Files" in output
+        assert "complex.py" in output