codeguardian-offline 0.1.0__py3-none-any.whl

codeguardian/__init__.py

@@ -0,0 +1 @@
+"""CodeGuardian - Offline AI QA Assistant"""

codeguardian/ai/__init__.py

@@ -0,0 +1 @@
+"""AI and RAG module."""

codeguardian/ai/health.py

@@ -0,0 +1,62 @@
+# codeguardian/ai/health.py
+
+import ollama
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+console = Console()
+
+RECOMMENDED_MODEL = "qwen2.5-coder"
+
+
+def check_ollama(warn_only: bool = False) -> bool:
+    """
+    Checks if the Ollama daemon is running.
+    If warn_only=True, prints a warning instead of raising.
+    Returns True if healthy, False otherwise.
+    """
+    try:
+        ollama.list()
+        console.print("[green]✓[/green] Ollama daemon is running")
+        return True
+    except Exception:
+        msg = (
+            "[yellow]![/yellow] Ollama is not running.\n"
+            "  Start it with: [bold]ollama serve[/bold]\n"
+            "  (Required for [bold]codeguardian ask[/bold])"
+        )
+        if warn_only:
+            console.print(msg)
+            return False
+        raise RuntimeError(
+            "Ollama is not running. Start it with: ollama serve"
+        )
+
+
+def ensure_model(model: str = RECOMMENDED_MODEL):
+    """
+    Checks if the model is pulled locally. Pulls it if not.
+    """
+    check_ollama()
+
+    available = {m["name"] for m in ollama.list().get("models", [])}
+
+    if model in available:
+        console.print(f"[green]✓[/green] Model [bold]{model}[/bold] is ready")
+        return
+
+    console.print(f"[yellow]Model [bold]{model}[/bold] not found locally. Pulling now...[/yellow]")
+    console.print("[dim](This is a one-time download — may take several minutes)[/dim]\n")
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+    ) as progress:
+        task = progress.add_task(f"Pulling {model}...", total=None)
+        for chunk in ollama.pull(model, stream=True):
+            status = chunk.get("status", "")
+            if status:
+                progress.update(task, description=f"[cyan]{status}[/cyan]")
+
+    console.print(f"\n[green]✓[/green] Model [bold]{model}[/bold] ready")

codeguardian/ai/ollama_client.py

@@ -0,0 +1,26 @@
+from codeguardian.core.logger import logger
+from typing import Optional
+
+def generate_explanation(prompt: str, model: str = "qwen2.5-coder") -> Optional[str]:
+    """
+    Sends a prompt to the local Ollama instance and returns the generated explanation.
+    """
+    from codeguardian.core.extras import require_extra
+    require_extra("ollama", "ai")
+    import ollama
+    try:
+        response = ollama.chat(model=model, messages=[
+            {
+                "role": "system",
+                "content": "You are an expert AI QA Engineer. You analyze failed tests and source code to explain failures and suggest fixes."
+            },
+            {
+                "role": "user",
+                "content": prompt
+            }
+        ])
+        return response['message']['content']
+    except Exception as e:
+        logger.error(f"Failed to communicate with local Ollama instance: {e}")
+        logger.error("Make sure Ollama is installed and running locally with the model available.")
+        return None

codeguardian/ai/rag.py

@@ -0,0 +1,68 @@
+import os
+from pathlib import Path
+from codeguardian.core.logger import logger
+from typing import List, Dict
+
+CODEGUARDIAN_DIR = Path(".codeguardian")
+CHROMA_DB_DIR = CODEGUARDIAN_DIR / "chroma"
+
+class CodeRAG:
+    def __init__(self):
+        from codeguardian.core.extras import require_extra
+        require_extra("chromadb", "ai")
+        require_extra("sentence_transformers", "ai")
+        from codeguardian.core.chroma_compat import get_client, get_or_create_collection
+        from sentence_transformers import SentenceTransformer
+
+        # Ensure directory exists
+        CHROMA_DB_DIR.mkdir(parents=True, exist_ok=True)
+        
+        try:
+            self.client = get_client(str(CHROMA_DB_DIR))
+            self.collection = get_or_create_collection(self.client, "codebase")
+            # Load a lightweight embedding model
+            self.model = SentenceTransformer('all-MiniLM-L6-v2')
+            self.is_ready = True
+        except Exception as e:
+            logger.error(f"Failed to initialize ChromaDB or SentenceTransformers: {e}")
+            self.is_ready = False
+
+    def add_chunks(self, chunks: List[str], metadatas: List[Dict[str, str]], ids: List[str]):
+        if not self.is_ready or not chunks:
+            return
+            
+        try:
+            embeddings = self.model.encode(chunks).tolist()
+            self.collection.add(
+                documents=chunks,
+                embeddings=embeddings,
+                metadatas=metadatas,
+                ids=ids
+            )
+            logger.info(f"Added {len(chunks)} chunks to the vector database.")
+        except Exception as e:
+            logger.error(f"Failed to add chunks to RAG: {e}")
+
+    def query(self, query_text: str, n_results: int = 3) -> List[Dict]:
+        if not self.is_ready:
+            return []
+            
+        try:
+            query_embedding = self.model.encode([query_text]).tolist()
+            results = self.collection.query(
+                query_embeddings=query_embedding,
+                n_results=n_results
+            )
+            
+            out = []
+            if results['documents'] and len(results['documents']) > 0:
+                for i in range(len(results['documents'][0])):
+                    out.append({
+                        "document": results['documents'][0][i],
+                        "metadata": results['metadatas'][0][i],
+                        "distance": results['distances'][0][i]
+                    })
+            return out
+        except Exception as e:
+            logger.error(f"Failed to query RAG: {e}")
+            return []

codeguardian/ai/test_generator.py

@@ -0,0 +1,51 @@
+import json
+import os
+from codeguardian.core.logger import logger
+import ollama
+
+def generate_api_tests(project_path: str, output_file: str = "codeguardian-api.json"):
+    """
+    Scans the project to guess endpoints and uses Ollama to generate an API test config.
+    """
+    logger.info("[bold cyan]Generating API tests using local AI...[/bold cyan]")
+    
+    # We will simply ask Ollama to generate a config based on a standard template.
+    # In a real scenario, this would first use Tree-sitter to find all endpoints.
+    prompt = """
+You are an expert QA Engineer. 
+I have a local FastAPI server running on http://127.0.0.1:8000.
+It has the following endpoints:
+1. GET /
+2. GET /users
+3. POST /users (requires JSON body with 'name')
+4. GET /error
+
+Generate a complete JSON configuration for my testing tool. 
+The JSON must have a 'base_url' and a list of 'endpoints'. 
+Each endpoint object must have 'path', 'method', and 'expected_status'.
+Return ONLY the raw JSON without any markdown formatting or backticks.
+"""
+    try:
+        response = ollama.chat(model='qwen2.5-coder', messages=[{"role": "user", "content": prompt}])
+        raw_json = response['message']['content'].strip()
+        
+        # Strip potential markdown formatting if the model still includes it
+        if raw_json.startswith("```json"):
+            raw_json = raw_json[7:]
+        if raw_json.startswith("```"):
+            raw_json = raw_json[3:]
+        if raw_json.endswith("```"):
+            raw_json = raw_json[:-3]
+            
+        config = json.loads(raw_json)
+        
+        out_path = os.path.join(project_path, output_file)
+        with open(out_path, "w") as f:
+            json.dump(config, f, indent=2)
+            
+        logger.info(f"[bold green]Successfully generated {output_file}[/bold green]")
+    except json.JSONDecodeError:
+        logger.error("[bold red]Failed to parse AI output as JSON.[/bold red]")
+        logger.debug(raw_json)
+    except Exception as e:
+        logger.error(f"[bold red]Failed to generate tests: {e}[/bold red]")

codeguardian/cli/__init__.py

@@ -0,0 +1 @@
+"""CLI modules."""

codeguardian/cli/ask.py

@@ -0,0 +1,83 @@
+import typer
+from rich.console import Console
+from codeguardian.core.logger import logger
+from codeguardian.core.db import get_session, TestResult, is_scanned, get_scan_summary, get_engine
+from codeguardian.ai.rag import CodeRAG
+from codeguardian.ai.ollama_client import generate_explanation
+from sqlmodel import select
+from codeguardian.ai.health import check_ollama, ensure_model, RECOMMENDED_MODEL
+
+console = Console()
+app = typer.Typer(help="Ask the local AI about failures.")
+
+@app.callback(invoke_without_command=True)
+def ask(query: str = typer.Argument(..., help="Question to ask the AI")):
+    """
+    Queries the local Ollama LLM with context from the vector DB and recent test results.
+    """
+    engine = get_engine()
+
+    # Guard: knowledge base must exist
+    if not is_scanned(engine):
+        console.print(
+            "\n[bold red]No knowledge base found.[/bold red]\n"
+            "The AI needs your codebase indexed before it can explain failures.\n\n"
+            "Run first: [bold]codeguardian scan .[/bold]\n"
+        )
+        raise typer.Exit(1)
+
+    summary = get_scan_summary(engine)
+    console.print(
+        f"[dim]Knowledge base: {summary.file_count} files, "
+        f"{summary.chunk_count} chunks "
+        f"(last scanned: {summary.scanned_at.strftime('%Y-%m-%d %H:%M')})[/dim]\n"
+    )
+
+    check_ollama()
+    ensure_model()
+
+    logger.info(f"[bold magenta]Querying AI with:[/bold magenta] {query}")
+    
+    # 1. Fetch recent failed tests from SQLite
+    session = next(get_session())
+    failed_tests = session.exec(
+        select(TestResult).where(TestResult.status == "FAIL").order_by(TestResult.id.desc()).limit(5)
+    ).all()
+    
+    test_context = "Recent Failed Tests:\n"
+    if not failed_tests:
+        test_context += "None found.\n"
+    for t in failed_tests:
+        test_context += f"- {t.endpoint_or_element}: {t.error_message}\n"
+        
+    # 2. Fetch relevant code from RAG
+    rag = CodeRAG()
+    rag_results = rag.query(query, n_results=3)
+    code_context = "Relevant Code Snippets:\n"
+    
+    if not rag_results:
+        code_context += "None found.\n"
+    for r in rag_results:
+        meta = r.get("metadata", {})
+        code = r.get("document", "")
+        code_context += f"--- {meta.get('file', 'Unknown File')} ({meta.get('name', '')}) ---\n"
+        code_context += f"{code}\n\n"
+        
+    # 3. Construct prompt
+    prompt = f"""
+User Query: {query}
+
+{test_context}
+
+{code_context}
+
+Based on the above context, explain the failure and suggest a fix.
+"""
+    logger.info("[bold]Generating explanation (this may take a moment)...[/bold]")
+    explanation = generate_explanation(prompt)
+    
+    if explanation:
+        logger.info("\n[bold green]AI Explanation:[/bold green]")
+        logger.info(explanation)
+    else:
+        logger.error("Could not generate explanation.")

codeguardian/cli/ci.py

@@ -0,0 +1,47 @@
+import typer
+import os
+from codeguardian.core.logger import logger
+
+app = typer.Typer(help="CI/CD Integration.")
+
+@app.callback(invoke_without_command=True)
+def ci(
+    platform: str = typer.Option("github", help="CI platform (github, gitlab)")
+):
+    """
+    Generates a template workflow for your CI/CD pipeline.
+    """
+    logger.info(f"[bold cyan]Generating CI template for {platform}...[/bold cyan]")
+    
+    if platform.lower() == "github":
+        template = """name: CodeGuardian QA
+on: [push, pull_request]
+
+jobs:
+  qa:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: "3.10"
+      - name: Install Dependencies
+        run: |
+          pip install -r requirements.txt
+          pip install codeguardian
+      - name: Run App
+        run: |
+          # Start your app in the background here
+          # e.g., uvicorn main:app --port 8000 &
+      - name: Run CodeGuardian
+        run: |
+          codeguardian init
+          codeguardian test --fail-on-error
+"""
+        os.makedirs(".github/workflows", exist_ok=True)
+        with open(".github/workflows/codeguardian.yml", "w") as f:
+            f.write(template)
+        logger.info("[bold green]Created .github/workflows/codeguardian.yml[/bold green]")
+    else:
+        logger.warning(f"Platform {platform} is not fully supported yet.")

codeguardian/cli/generate.py

@@ -0,0 +1,20 @@
+import typer
+from codeguardian.core.logger import logger
+from codeguardian.ai.test_generator import generate_api_tests
+
+app = typer.Typer(help="Generate tests automatically using AI.")
+
+@app.callback(invoke_without_command=True)
+def generate(
+    project_path: str = typer.Argument(".", help="Path to the project"),
+    type: str = typer.Option("api", help="Type of tests to generate (api or ui)")
+):
+    """
+    Scans the project and generates tests using Ollama.
+    """
+    logger.info(f"[bold yellow]Generating {type} tests for {project_path}[/bold yellow]")
+    
+    if type.lower() == "api":
+        generate_api_tests(project_path)
+    else:
+        logger.warning(f"Generation for type '{type}' is not yet implemented.")

codeguardian/cli/init.py

@@ -0,0 +1,68 @@
+# codeguardian/cli/init.py
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+console = Console()
+
+
+def check_playwright_browsers() -> bool:
+    """Returns True if Playwright and Chromium are ready."""
+    try:
+        from playwright.sync_api import sync_playwright
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True)
+            browser.close()
+        return True
+    except ImportError:
+        return False  # playwright not installed (optional dep)
+    except Exception:
+        return False  # playwright installed but browsers missing
+
+
+app = typer.Typer(help="Initialize a new CodeGuardian project.")
+
+@app.callback(invoke_without_command=True)
+def init_command(path: str = "."):
+    """codeguardian init — sets up DB and validates environment."""
+
+    console.print(Panel("[bold cyan]Initializing CodeGuardian[/bold cyan]", expand=False))
+
+    # 1. Initialize SQLite DB
+    from codeguardian.core.db import init_db
+    init_db(path)
+    console.print("[green]✓[/green] Database initialized")
+
+    # 2. Check Playwright (only warn if installed, not required for core)
+    try:
+        import playwright  # noqa: F401
+        if check_playwright_browsers():
+            console.print("[green]✓[/green] Playwright browsers ready")
+        else:
+            console.print(
+                "[yellow]![/yellow] Playwright is installed but browsers are missing.\n"
+                "  Run: [bold]playwright install chromium[/bold]\n"
+                "  (Required only for UI testing)"
+            )
+    except ImportError:
+        pass  # playwright not installed — that's fine, it's optional
+
+    # 3. Check Ollama (only warn if ai extra is installed)
+    try:
+        import ollama
+        from codeguardian.ai.health import check_ollama
+        check_ollama(warn_only=True)
+    except ImportError:
+        pass  # ai extra not installed
+
+    # 4. Check scan dependencies
+    try:
+        import tree_sitter  # noqa: F401
+        from codeguardian.scanner.grammars import ensure_grammars
+        ensure_grammars()
+    except ImportError:
+        pass  # scan extra not installed
+
+    console.print("\n[bold green]CodeGuardian ready.[/bold green]")
+    console.print("Next: configure [bold]codeguardian-api.json[/bold] then run [bold]codeguardian test[/bold]")

codeguardian/cli/report.py

@@ -0,0 +1,42 @@
+import typer
+from rich.console import Console
+from typing import Annotated
+from enum import Enum
+
+console = Console()
+app = typer.Typer(help="Generate reports.")
+
+class ReportFormat(str, Enum):
+    html = "html"
+    junit = "junit"
+    both = "both"
+
+@app.callback(invoke_without_command=True)
+def report(
+    format: Annotated[ReportFormat, typer.Option("--format", "-f")] = ReportFormat.html,
+    output: Annotated[str, typer.Option("--output", "-o")] = ".",
+):
+    """
+    Generates reports based on the latest test runs.
+    """
+    from codeguardian.core.db import get_engine, get_all_results
+    results = get_all_results(get_engine())
+
+    if not results:
+        console.print("[yellow]No test results found. Run [bold]codeguardian test[/bold] first.[/yellow]")
+        raise typer.Exit(1)
+
+    if format in (ReportFormat.html, ReportFormat.both):
+        try:
+            from codeguardian.reports.generator import generate_report
+            # generate_report in the existing project probably generates HTML by default
+            generate_report(format="html", output_dir=output)
+            path = f"{output}/report.html"
+            console.print(f"[green]✓[/green] HTML report generated.")
+        except ImportError:
+            console.print("[yellow]HTML report generator not found.[/yellow]")
+
+    if format in (ReportFormat.junit, ReportFormat.both):
+        from codeguardian.reports.junit import generate_junit_xml
+        path = generate_junit_xml(results, output_path=f"{output}/codeguardian-report.xml")
+        console.print(f"[green]✓[/green] JUnit XML: [bold]{path}[/bold]")

codeguardian/cli/scan.py

@@ -0,0 +1,39 @@
+import typer
+from codeguardian.core.logger import logger
+from codeguardian.scanner.semgrep_runner import run_semgrep
+from codeguardian.scanner.ruff_runner import run_ruff
+from codeguardian.scanner.tree_sitter_runner import index_project
+from codeguardian.ai.rag import CodeRAG
+
+from codeguardian.core.db import mark_scanned, get_engine
+from rich.console import Console
+
+console = Console()
+
+app = typer.Typer(help="Scan project for static analysis and build knowledge base.")
+
+@app.callback(invoke_without_command=True)
+def scan(path: str = typer.Argument(".", help="Path to scan")):
+    """
+    Scans the directory using Tree-sitter and runs static analysis (Semgrep, Ruff).
+    """
+    logger.info(f"[bold yellow]Scanning path: {path}[/bold yellow]")
+    
+    # 1. Static Analysis
+    logger.info("[bold]Running Static Analysis...[/bold]")
+    run_semgrep(path)
+    run_ruff(path)
+    
+    # 2. Build Knowledge Base
+    logger.info("[bold]Building Knowledge Base with Tree-sitter & ChromaDB...[/bold]")
+    rag = CodeRAG()
+    # Assume index_project returns files_indexed, chunks_added or similar.
+    # The fix guide didn't change index_project signature, but asked to use files_indexed, chunks_added.
+    # Let's adjust according to index_project's actual return values if possible, or just default to 0 for now.
+    # I'll just unpack what index_project returns. If it doesn't return anything, this will fail. Let's check `index_project` next if it fails.
+    # For now, let's just pass some dummy values, I will check what `index_project` actually returns. Wait, I should just check `tree_sitter_runner.py`.
+    files_indexed, chunks_added = index_project(path, rag)
+    
+    mark_scanned(get_engine(), path=path, file_count=files_indexed, chunk_count=chunks_added)
+    console.print(f"[green]✓[/green] Knowledge base built: {files_indexed} files, {chunks_added} chunks")
+    logger.info("[bold green]Scan completed.[/bold green]")

codeguardian/cli/serve.py

@@ -0,0 +1,23 @@
+import typer
+import uvicorn
+from codeguardian.core.logger import logger
+
+app = typer.Typer(help="Launch the local Web Dashboard.")
+
+@app.callback(invoke_without_command=True)
+def serve(
+    port: int = typer.Option(8080, help="Port to run the dashboard on"),
+    host: str = typer.Option("127.0.0.1", help="Host IP")
+):
+    """
+    Spins up a FastAPI web server to view a live CodeGuardian dashboard.
+    """
+    logger.info(f"[bold cyan]Starting CodeGuardian Dashboard on http://{host}:{port}[/bold cyan]")
+    logger.info("[bold yellow]Press Ctrl+C to stop.[/bold yellow]")
+    
+    # We run uvicorn programmatically
+    # The ASGI app is located in codeguardian.server.app:app
+    try:
+        uvicorn.run("codeguardian.server.app:app", host=host, port=port, log_level="warning")
+    except Exception as e:
+        logger.error(f"[bold red]Failed to start server: {e}[/bold red]")

codeguardian/cli/test.py

@@ -0,0 +1,93 @@
+import typer
+from codeguardian.core.logger import logger
+from codeguardian.core.db import get_session, Project, TestRun, TestResult
+from codeguardian.testers.api import run_api_tests
+from codeguardian.testers.ui import run_ui_tests
+from sqlmodel import select
+import os
+
+app = typer.Typer(help="Run automated tests (API + UI).")
+
+def _get_or_create_project(session) -> Project:
+    project = session.exec(select(Project)).first()
+    if not project:
+        project = Project(name=os.path.basename(os.getcwd()), path=os.getcwd())
+        session.add(project)
+        session.commit()
+        session.refresh(project)
+    return project
+
+from codeguardian.core.config_loader import load_api_config, load_ui_config
+
+@app.callback(invoke_without_command=True)
+def test(
+    api_only: bool = typer.Option(False, "--api-only", help="Run only API tests"),
+    ui_only: bool = typer.Option(False, "--ui-only", help="Run only UI tests"),
+    fail_on_error: bool = typer.Option(False, "--fail-on-error", help="Return non-zero exit code if tests fail")
+):
+    """
+    Runs the full test suite (API + UI).
+    """
+    if api_only and ui_only:
+        logger.error("[bold red]Cannot specify both --api-only and --ui-only[/bold red]")
+        raise typer.Exit(code=1)
+
+    logger.info("[bold yellow]Starting test runs...[/bold yellow]")
+    
+    session = next(get_session())
+    project = _get_or_create_project(session)
+    
+    if not ui_only:
+        logger.info("\n[bold]Running API tests...[/bold]")
+        config = load_api_config()
+        api_results = run_api_tests(config)
+        if api_results:
+            run_record = TestRun(project_id=project.id, type="API", status="PASS", duration_ms=sum(r.duration_ms for r in api_results))
+            for res in api_results:
+                if res.status == "FAIL":
+                    run_record.status = "FAIL"
+            session.add(run_record)
+            session.commit()
+            session.refresh(run_record)
+            
+            for res in api_results:
+                db_res = TestResult(
+                    run_id=run_record.id,
+                    endpoint_or_element=res.endpoint,
+                    status=res.status,
+                    error_message=res.error_message
+                )
+                session.add(db_res)
+            session.commit()
+    
+    if not api_only:
+        logger.info("\n[bold]Running UI tests...[/bold]")
+        config = load_ui_config()
+        ui_results = run_ui_tests(config)
+        if ui_results:
+            run_record = TestRun(project_id=project.id, type="UI", status="PASS", duration_ms=sum(r.duration_ms for r in ui_results))
+            for res in ui_results:
+                if res.status == "FAIL":
+                    run_record.status = "FAIL"
+            session.add(run_record)
+            session.commit()
+            session.refresh(run_record)
+            
+            for res in ui_results:
+                db_res = TestResult(
+                    run_id=run_record.id,
+                    endpoint_or_element=res.action_name,
+                    status=res.status,
+                    error_message=res.error_message
+                )
+                session.add(db_res)
+            session.commit()
+
+    logger.info("\n[bold green]All tests completed.[/bold green]")
+    
+    if fail_on_error:
+        # Check if any run failed
+        failed_runs = session.exec(select(TestRun).where(TestRun.project_id == project.id).order_by(TestRun.id.desc()).limit(2)).all()
+        if any(run.status == "FAIL" for run in failed_runs):
+            logger.error("\n[bold red]Tests failed and --fail-on-error is set. Exiting with 1.[/bold red]")
+            raise typer.Exit(code=1)

codeguardian/core/__init__.py

@@ -0,0 +1 @@
+"""Core logic for CodeGuardian."""

codeguardian/core/chroma_compat.py

@@ -0,0 +1,26 @@
+# codeguardian/core/chroma_compat.py
+
+"""
+ChromaDB compatibility layer.
+Wraps the ChromaDB client so internal code is insulated from minor API shifts.
+Update this file when bumping the chromadb version pin.
+"""
+
+import chromadb
+from chromadb.config import Settings
+
+
+def get_client(persist_directory: str) -> chromadb.ClientAPI:
+    """Returns a persistent ChromaDB client."""
+    return chromadb.PersistentClient(
+        path=persist_directory,
+        settings=Settings(anonymized_telemetry=False),  # keep it private
+    )
+
+
+def get_or_create_collection(client: chromadb.ClientAPI, name: str):
+    """Gets or creates a named collection safely."""
+    return client.get_or_create_collection(
+        name=name,
+        metadata={"hnsw:space": "cosine"},
+    )