codeguardian-offline 0.1.0__tar.gz

codeguardian_offline-0.1.0/PKG-INFO

@@ -0,0 +1,155 @@
+Metadata-Version: 2.4
+Name: codeguardian-offline
+Version: 0.1.0
+Summary: Offline AI QA Assistant
+Author-email: CodeGuardian Maintainers <maintainers@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: typer>=0.12.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: sqlmodel>=0.0.16
+Requires-Dist: httpx>=0.27.0
+Provides-Extra: ui
+Requires-Dist: playwright>=1.42.0; extra == "ui"
+Provides-Extra: ai
+Requires-Dist: ollama<1.0,>=0.2.0; extra == "ai"
+Requires-Dist: chromadb<0.6.0,>=0.4.24; extra == "ai"
+Requires-Dist: sentence-transformers>=2.5.1; extra == "ai"
+Provides-Extra: scan
+Requires-Dist: tree-sitter>=0.21.0; extra == "scan"
+Requires-Dist: tree-sitter-python>=0.21.0; extra == "scan"
+Requires-Dist: tree-sitter-javascript>=0.21.0; extra == "scan"
+Requires-Dist: tree-sitter-java>=0.21.0; extra == "scan"
+Provides-Extra: server
+Requires-Dist: fastapi>=0.110.0; extra == "server"
+Requires-Dist: uvicorn>=0.29.0; extra == "server"
+Provides-Extra: full
+Requires-Dist: codeguardian[ai,scan,server,ui]; extra == "full"
+Provides-Extra: dev
+Requires-Dist: codeguardian[full]; extra == "dev"
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23.0; extra == "dev"
+Requires-Dist: ruff>=0.4.0; extra == "dev"
+
+# CodeGuardian
+
+An **Offline AI QA Assistant** that tests applications automatically and explains failures.
+
+No internet. No API keys. No cloud services.
+
+## Architecture & Features
+
+- **CLI Automation**: Built with `Typer` and `Rich` for a premium terminal experience.
+- **API Testing**: Uses `HTTPX` to validate JSON endpoints.
+- **UI Testing**: Uses `Playwright` for headless browser automation and UI validation.
+- **Static Analysis**: Hooks into `Semgrep` and `Ruff`.
+- **RAG & Knowledge Base**: Parses source code with `Tree-sitter`, embeds it using `SentenceTransformers`, and stores it in `ChromaDB`.
+- **Local AI Explanations**: Queries your local `Ollama` (`qwen2.5-coder` recommended) to explain test failures by correlating test errors with the relevant source code.
+
+## Installation
+
+Ensure you have Python 3.10+ installed.
+
+CodeGuardian uses optional dependencies so you only install what you need.
+
+```bash
+git clone <repository>
+cd CodeGuardian
+python -m venv venv
+
+# On Windows:
+.\venv\Scripts\activate
+# On Mac/Linux:
+source venv/bin/activate
+```
+
+Install CodeGuardian with the features you need:
+
+| Use case | Command | Approx size |
+|---|---|---|
+| API testing only | `pip install -e .` | ~50MB |
+| + UI testing | `pip install -e .[ui]` | ~200MB |
+| + AI explanations | `pip install -e .[ai]` | ~3GB |
+| + Code scanning | `pip install -e .[scan]` | ~100MB |
+| Everything | `pip install -e .[full]` | ~3.5GB |
+
+*(Note: AI explanations require PyTorch which is ~2GB. Playwright requires an extra step: `playwright install chromium`).*
+
+### Install Ollama
+
+Install [Ollama](https://ollama.com/) on your local machine if you plan to use AI features. CodeGuardian will automatically pull the recommended model (`qwen2.5-coder`) when you first use the `ask` command.
+
+## Usage
+
+### 1. Initialize
+Initialize the CodeGuardian database and pre-compile any language grammars:
+```bash
+cd /path/to/your/project
+codeguardian init
+```
+
+### 2. Configure Tests
+Create a `codeguardian-api.json` or `codeguardian-ui.json` in your project root. 
+CodeGuardian will validate your config using Pydantic before running.
+
+**codeguardian-api.json**
+```json
+{
+  "base_url": "https://httpbin.org",
+  "tests": [
+    {"name": "Get Request", "url": "/get", "method": "GET", "expected_status": 200},
+    {"name": "Not Found", "url": "/status/404", "method": "GET", "expected_status": 404}
+  ]
+}
+```
+
+**codeguardian-ui.json**
+```json
+{
+  "browser": "chromium",
+  "headless": true,
+  "tests": [
+    {
+      "name": "Check Example Domain",
+      "steps": [
+        {"action": "navigate", "url": "http://example.com"},
+        {"action": "assert_visible", "selector": "h1"}
+      ]
+    }
+  ]
+}
+```
+
+### 3. Run Tests
+Run both API and UI tests (results will be logged to SQLite):
+```bash
+codeguardian test
+# Or target specific suites:
+# codeguardian test --api-only
+# codeguardian test --ui-only
+```
+
+### 4. Build Knowledge Base
+Scan the project to run static analysis and build the ChromaDB vector index:
+```bash
+codeguardian scan .
+```
+
+### 5. Ask the AI
+If tests fail, query the AI. CodeGuardian will fetch the latest failures, pull relevant source code from ChromaDB, and ask Ollama to explain what went wrong:
+```bash
+codeguardian ask "Why did the API tests fail?"
+```
+
+### 6. Generate Reports
+Export beautiful HTML reports or JUnit XML for CI/CD integrations:
+```bash
+codeguardian report --format html
+codeguardian report --format junit
+codeguardian report --format both
+```

codeguardian_offline-0.1.0/README.md

@@ -0,0 +1,117 @@
+# CodeGuardian
+
+An **Offline AI QA Assistant** that tests applications automatically and explains failures.
+
+No internet. No API keys. No cloud services.
+
+## Architecture & Features
+
+- **CLI Automation**: Built with `Typer` and `Rich` for a premium terminal experience.
+- **API Testing**: Uses `HTTPX` to validate JSON endpoints.
+- **UI Testing**: Uses `Playwright` for headless browser automation and UI validation.
+- **Static Analysis**: Hooks into `Semgrep` and `Ruff`.
+- **RAG & Knowledge Base**: Parses source code with `Tree-sitter`, embeds it using `SentenceTransformers`, and stores it in `ChromaDB`.
+- **Local AI Explanations**: Queries your local `Ollama` (`qwen2.5-coder` recommended) to explain test failures by correlating test errors with the relevant source code.
+
+## Installation
+
+Ensure you have Python 3.10+ installed.
+
+CodeGuardian uses optional dependencies so you only install what you need.
+
+```bash
+git clone <repository>
+cd CodeGuardian
+python -m venv venv
+
+# On Windows:
+.\venv\Scripts\activate
+# On Mac/Linux:
+source venv/bin/activate
+```
+
+Install CodeGuardian with the features you need:
+
+| Use case | Command | Approx size |
+|---|---|---|
+| API testing only | `pip install -e .` | ~50MB |
+| + UI testing | `pip install -e .[ui]` | ~200MB |
+| + AI explanations | `pip install -e .[ai]` | ~3GB |
+| + Code scanning | `pip install -e .[scan]` | ~100MB |
+| Everything | `pip install -e .[full]` | ~3.5GB |
+
+*(Note: AI explanations require PyTorch which is ~2GB. Playwright requires an extra step: `playwright install chromium`).*
+
+### Install Ollama
+
+Install [Ollama](https://ollama.com/) on your local machine if you plan to use AI features. CodeGuardian will automatically pull the recommended model (`qwen2.5-coder`) when you first use the `ask` command.
+
+## Usage
+
+### 1. Initialize
+Initialize the CodeGuardian database and pre-compile any language grammars:
+```bash
+cd /path/to/your/project
+codeguardian init
+```
+
+### 2. Configure Tests
+Create a `codeguardian-api.json` or `codeguardian-ui.json` in your project root. 
+CodeGuardian will validate your config using Pydantic before running.
+
+**codeguardian-api.json**
+```json
+{
+  "base_url": "https://httpbin.org",
+  "tests": [
+    {"name": "Get Request", "url": "/get", "method": "GET", "expected_status": 200},
+    {"name": "Not Found", "url": "/status/404", "method": "GET", "expected_status": 404}
+  ]
+}
+```
+
+**codeguardian-ui.json**
+```json
+{
+  "browser": "chromium",
+  "headless": true,
+  "tests": [
+    {
+      "name": "Check Example Domain",
+      "steps": [
+        {"action": "navigate", "url": "http://example.com"},
+        {"action": "assert_visible", "selector": "h1"}
+      ]
+    }
+  ]
+}
+```
+
+### 3. Run Tests
+Run both API and UI tests (results will be logged to SQLite):
+```bash
+codeguardian test
+# Or target specific suites:
+# codeguardian test --api-only
+# codeguardian test --ui-only
+```
+
+### 4. Build Knowledge Base
+Scan the project to run static analysis and build the ChromaDB vector index:
+```bash
+codeguardian scan .
+```
+
+### 5. Ask the AI
+If tests fail, query the AI. CodeGuardian will fetch the latest failures, pull relevant source code from ChromaDB, and ask Ollama to explain what went wrong:
+```bash
+codeguardian ask "Why did the API tests fail?"
+```
+
+### 6. Generate Reports
+Export beautiful HTML reports or JUnit XML for CI/CD integrations:
+```bash
+codeguardian report --format html
+codeguardian report --format junit
+codeguardian report --format both
+```

codeguardian_offline-0.1.0/codeguardian/__init__.py

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

codeguardian_offline-0.1.0/codeguardian/ai/__init__.py

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

codeguardian_offline-0.1.0/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_offline-0.1.0/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_offline-0.1.0/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_offline-0.1.0/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_offline-0.1.0/codeguardian/cli/__init__.py

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

codeguardian_offline-0.1.0/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_offline-0.1.0/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_offline-0.1.0/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.")