Project: AI-Powered Code Review Tool

You are a code reviewer.
Review the provided Python code and give feedback.

You are a senior Python code reviewer.
Review code for:
1. Correctness (bugs, edge cases)
2. Style (PEP 8 compliance)
3. Performance (inefficiencies)
4. Security (vulnerabilities)
5. Documentation (clarity, completeness)

Format: ## [Category] header for each, list issues with severity.

You are a senior Python developer at a tech company.
Your job is to review code for quality, correctness, and adherence to standards.

REVIEW CRITERIA:
1. **Correctness**: Does it work? Handle edge cases? Any bugs?
2. **Style**: PEP 8, naming conventions, readability
3. **Performance**: Inefficient algorithms, unnecessary loops
4. **Security**: SQL injection, unvalidated input, hardcoded secrets
5. **Testing**: Are there tests? Are they sufficient?
6. **Documentation**: Docstrings, comments, clarity

STANDARDS TO APPLY (provided below):
{standards_context}

OUTPUT FORMAT:
## Summary
[1-2 sentence overview of code quality]

## Issues Found
[Numbered list with severity level (🔴 Critical, 🟡 Warning, 🔵 Info)]

## Positive Notes
[What the code does well]

## Recommendations
[Top 3 actionable improvements]

## Overall Rating
[One of: Excellent / Good / Needs Review / Critical Issues]

Be constructive, specific, and cite the standards where applicable.
If code is correct but could be improved, suggest alternatives with examples.

tools = [
    {
        "name": "read_file",
        "description": "Read a Python file from disk",
        "input_schema": {
            "type": "object",
            "properties": {
                "path": {
                    "type": "string",
                    "description": "File path (absolute or relative)"
                }
            },
            "required": ["path"]
        }
    },
    {
        "name": "get_coding_standards",
        "description": "Retrieve relevant coding standards via RAG",
        "input_schema": {
            "type": "object",
            "properties": {
                "topic": {
                    "type": "string",
                    "description": "Topic (error handling, testing, security, etc)"
                }
            },
            "required": ["topic"]
        }
    }
]

import anthropic
import os

client = anthropic.Anthropic()

def read_file_tool(path: str) -> str:
    """Read file from filesystem"""
    with open(path, "r") as f:
        return f.read()

def get_standards_tool(topic: str) -> str:
    """Mock RAG retrieval of coding standards"""
    standards = {
        "error_handling": "Always use specific exceptions. Never bare except.",
        "testing": "Every function should have at least one test case.",
        "naming": "Use descriptive names. Avoid abbreviations.",
        "security": "Validate all user input. Use parameterized queries."
    }
    return standards.get(topic, "No standards found")

def execute_tool(name: str, input_dict: dict) -> str:
    """Execute tool and return result"""
    if name == "read_file":
        return read_file_tool(input_dict["path"])
    elif name == "get_coding_standards":
        return get_standards_tool(input_dict["topic"])
    return "Unknown tool"

def review_code(file_path: str) -> str:
    """Main review pipeline"""

    # Step 1: Read the code
    code = read_file_tool(file_path)

    # Step 2: Get standards
    standards = get_standards_tool("general")

    # Step 3: Build augmented prompt
    system_prompt = """You are a senior Python code reviewer..."""

    user_message = f"""
<standards>
{standards}
</standards>

<code>
{code}
</code>

Please review this code."""

    # Step 4: Call Claude
    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=1024,
        system=system_prompt,
        messages=[{
            "role": "user",
            "content": user_message
        }]
    )

    return response.content[0].text

# Usage:
review = review_code("example.py")
print(review)

import chromadb

# Initialize Chroma for vector storage
chroma_client = chromadb.Client()
standards_collection = chroma_client.create_collection(
    name="coding_standards"
)

# Embed company coding standards
standards_docs = [
    "Always validate user input to prevent injection attacks.",
    "Use type hints for all function signatures.",
    "Write tests for all public functions.",
    "Avoid nested loops; optimize with built-ins like map/filter.",
    "Use descriptive variable names, avoid single letters except loop counters.",
]

standards_collection.add(
    documents=standards_docs,
    ids=[f"std_{i}" for i in range(len(standards_docs))]
)

def retrieve_standards(code: str) -> str:
    """RAG: Retrieve relevant standards for code"""
    results = standards_collection.query(
        query_texts=[code],  # Chroma embeds automatically
        n_results=3  # Top 3 most relevant standards
    )
    return "\n".join(results["documents"][0])

#!/usr/bin/env python3
"""AI-Powered Code Review Tool"""
import anthropic
import sys
import chromadb

client = anthropic.Anthropic()
chroma_client = chromadb.Client()

# Setup RAG
collection = chroma_client.create_collection(
    name="standards"
)
collection.add(
    documents=[
        "Use type hints for all functions",
        "Validate all user input",
        "Write tests for critical paths",
        "Use descriptive variable names",
    ],
    ids=["std_1", "std_2", "std_3", "std_4"]
)

SYSTEM_PROMPT = """You are a senior Python code reviewer.
Review for: correctness, style, performance, security, testing.

Standards:
{standards}

Format:
## Summary
[1 sentence overview]

## Issues Found
[List with severity: 🔴 Critical, 🟡 Warning, 🔵 Info]

## Rating
[Excellent/Good/Needs Review/Critical]"""

def review(file_path: str):
    """Review a Python file"""
    # Read code
    with open(file_path) as f:
        code = f.read()

    # Retrieve relevant standards via RAG
    results = collection.query(
        query_texts=[code],
        n_results=2
    )
    standards = "\n".join(
        results["documents"][0]
    )

    # Call Claude
    response = client.messages.create(
        model="claude-opus-4-6",
        max_tokens=800,
        system=SYSTEM_PROMPT.format(
            standards=standards
        ),
        messages=[{
            "role": "user",
            "content": f"""Review this code:

<code>
{code}
</code>"""
        }]
    )

    print(response.content[0].text)

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print("Usage: python solution.py ")
        sys.exit(1)
    review(sys.argv[1])

pip install anthropic chromadb
export ANTHROPIC_API_KEY="..."
python solution.py mycode.py