> ## Documentation Index
> Fetch the complete documentation index at: https://docs.praison.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Code Analysis Agent

> Automated code review with structured output, persistence, and API deployment

```mermaid theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
flowchart LR
    In[Code Repository] --> A[Code Analyzer]
    A --> Out[Analysis Report]
    
    style In fill:#8B0000,color:#fff
    style A fill:#2E8B57,color:#fff
    style Out fill:#8B0000,color:#fff
```

Analyze GitHub repos or local code: quality scoring, security review, architecture assessment. Includes SQLite persistence, structured Pydantic output, and API deployment.

## Setup

```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Create environment
python3 -m venv venv && source venv/bin/activate

# Install packages
pip install praisonaiagents praisonai gitingest

# Set API key
export OPENAI_API_KEY="your-key"
```

## Create Sample Code

```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Create test directory with sample code
mkdir -p sample_project/src
cat > sample_project/src/main.py << 'EOF'
import os
from typing import List, Optional

class DataProcessor:
    def __init__(self, config: dict):
        self.config = config
        self.data = []
    
    def load_data(self, path: str) -> List[dict]:
        # TODO: Add error handling
        with open(path) as f:
            return eval(f.read())  # Security issue: eval
    
    def process(self, items: List[dict]) -> List[dict]:
        results = []
        for item in items:
            results.append(self._transform(item))
        return results
    
    def _transform(self, item: dict) -> dict:
        return {k: str(v).upper() for k, v in item.items()}

if __name__ == "__main__":
    dp = DataProcessor({})
    data = dp.load_data("data.json")
    print(dp.process(data))
EOF
```

## Run: Python Code

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent, Task, AgentTeam
from praisonaiagents import Agent, AgentTeam, Task, tool, db
from pydantic import BaseModel
from typing import List, Dict
from gitingest import ingest
import json

# Structured output schema
class CodeAnalysisReport(BaseModel):
    overall_quality: int
    architecture_score: int
    maintainability_score: int
    security_score: int
    key_strengths: List[str]
    security_issues: List[str]
    recommendations: List[str]

# Database persistence is configured via memory={} parameter

# Code analyzer agent
analyzer = Agent(
    name="CodeAnalyzer",
    instructions="""Analyze code for quality, security, and best practices.
    Provide scores 0-100 and specific findings.""",
    memory={
        "db": "sqlite:///code_analysis.db",
        "session_id": "code-review-session"
    }
)

# Analysis task with structured output
analysis_task = Task(
    description="""Analyze this code repository:

{code_content}

Provide:
1. Overall quality score (0-100)
2. Architecture score
3. Maintainability score  
4. Security score
5. Key strengths (list)
6. Security issues found (list)
7. Recommendations (list)""",
    agent=analyzer,
    expected_output="Structured code analysis report",
    output_pydantic=CodeAnalysisReport
)

def analyze_code(source: str) -> CodeAnalysisReport:
    """Analyze code from path or GitHub URL."""
    summary, tree, content = ingest(source)
    code_content = f"STRUCTURE:\n{tree}\n\nCODE:\n{content[:10000]}"
    
    agents = AgentTeam(agents=[analyzer], tasks=[analysis_task])
    result = agents.start(code_content=code_content)
    return result

if __name__ == "__main__":
    # Analyze local directory
    report = analyze_code("./sample_project")
    print(json.dumps(report.model_dump() if hasattr(report, 'model_dump') else str(report), indent=2))
```

## Run: CLI

```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Analyze with file input
praisonai "Analyze this code for security issues" --file ./sample_project/src/main.py

# With memory persistence
praisonai "Review code quality" --file ./sample_project --memory --user-id reviewer1

# With verbose output
praisonai "Find security vulnerabilities in this code" --file ./sample_project --verbose
```

## Run: agents.yaml

Create `agents.yaml`:

```yaml theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
framework: praisonai
topic: "code quality analysis"
roles:
  code_analyzer:
    role: Senior Code Reviewer
    goal: Analyze code for quality, security, and best practices
    backstory: Expert in code review with 15 years experience
    tasks:
      analyze_code:
        description: |
          Analyze the provided code for:
          - Code quality (0-100 score)
          - Security vulnerabilities
          - Best practices adherence
          - Recommendations for improvement
        expected_output: |
          JSON report with scores and findings
          
  security_auditor:
    role: Security Auditor
    goal: Find security vulnerabilities
    backstory: Cybersecurity expert specializing in code audits
    tasks:
      security_audit:
        description: |
          Perform security audit:
          - Injection vulnerabilities
          - Authentication issues
          - Data exposure risks
        expected_output: Security findings with severity levels
```

Run:

```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
praisonai agents.yaml --file ./sample_project --verbose
```

## Monitor & Verify

```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# View analysis history
praisonai --history 5 --user-id reviewer1

# Check metrics
praisonai --metrics

# Save results
praisonai --save code_review_results
```

## Serve API

```python theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
from praisonaiagents import Agent
from gitingest import ingest

agent = Agent(
    name="CodeReviewAPI",
    instructions="Analyze code for quality and security issues. Return structured JSON."
)

agent.launch(path="/analyze", port=8000)
```

Test:

```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
# Start server (in background)
python code_api.py &

# Test endpoint
curl -X POST http://localhost:8000/analyze \
  -H "Content-Type: application/json" \
  -d '{"message": "Analyze this Python code: def foo(): return eval(input())"}'
```

## Cleanup

```bash theme={"theme":{"light":"vitesse-light","dark":"vitesse-dark"}}
rm -rf sample_project code_analysis.db
deactivate
```

## Features Demonstrated

| Feature               | Implementation                |
| --------------------- | ----------------------------- |
| **Structured Output** | Pydantic `CodeAnalysisReport` |
| **DB Persistence**    | SQLite via `db()`             |
| **External Tool**     | `gitingest` for repo parsing  |
| **CLI**               | `--file` flag for code input  |
| **YAML Config**       | Multi-agent security audit    |
| **API Endpoint**      | `agent.launch()`              |
| **Session Resume**    | `session_id` parameter        |