Build an AI Code Linter with Python and Claude

mkdir ailint && cd ailint
pip install anthropic

export EZAI_API_KEY="sk-your-key-here"

import anthropic, json, sys, os
from pathlib import Path

client = anthropic.Anthropic(
    api_key=os.environ["EZAI_API_KEY"],
    base_url="https://ezaiapi.com",
)

SYSTEM_PROMPT = """You are a senior code reviewer. Analyze the given source file
and return a JSON array of findings. Each finding must have:
- "severity": "error" | "warning" | "info"
- "line": integer line number (1-indexed)
- "rule": short rule id like "sql-injection" or "race-condition"
- "message": one-sentence description of the issue
- "suggestion": concrete code fix or refactor advice

Focus on logic bugs, security issues, performance anti-patterns,
and race conditions. Ignore style/formatting — traditional linters
handle that. Return [] if the code is clean.
Return ONLY the JSON array, no markdown fences."""

def lint_file(filepath: str) -> list[dict]:
    code = Path(filepath).read_text()
    numbered = "\n".join(
        f"{i+1:4d} | {line}"
        for i, line in enumerate(code.splitlines())
    )

    resp = client.messages.create(
        model="claude-sonnet-4-5",
        max_tokens=4096,
        system=SYSTEM_PROMPT,
        messages=[{
            "role": "user",
            "content": f"File: {filepath}\n\n{numbered}"
        }],
    )

    return json.loads(resp.content[0].text)

if __name__ == "__main__":
    for f in sys.argv[1:]:
        findings = lint_file(f)
        if not findings:
            print(f"✅ {f}: clean")
            continue
        print(f"\n🔍 {f}: {len(findings)} finding(s)")
        for item in findings:
            icon = {"error": "🔴", "warning": "🟡"}.get(
                item["severity"], "🔵"
            )
            print(f"  {icon} L{item['line']} [{item['rule']}] {item['message']}")
            print(f"     → {item['suggestion']}")

🔍 app/routes.py: 3 finding(s)
  🔴 L42 [sql-injection] f-string interpolation in SQL query bypasses ORM parameterization
     → Use db.execute(text("SELECT * FROM users WHERE id = :id"), {"id": user_id})
  🟡 L87 [n-plus-one] Loading related orders inside a loop — triggers N+1 queries
     → Use joinedload() or selectinload() in the initial query
  🔵 L15 [unused-import] 'datetime' imported but only used in commented-out code
     → Remove the import or uncomment the code that needs it

import anthropic, asyncio, json, sys, os
from pathlib import Path

aclient = anthropic.AsyncAnthropic(
    api_key=os.environ["EZAI_API_KEY"],
    base_url="https://ezaiapi.com",
)
sem = asyncio.Semaphore(5)  # 5 concurrent requests

SYSTEM_PROMPT = """You are a senior code reviewer. Return a JSON array of findings.
Each: {"severity":"error"|"warning"|"info","line":int,"rule":"slug",
"message":"one sentence","suggestion":"fix"}. Return [] if clean.
Focus on logic bugs, security, performance. Skip style issues.
Return ONLY the JSON array."""

async def lint_one(filepath: str) -> tuple[str, list]:
    code = Path(filepath).read_text()
    numbered = "\n".join(
        f"{i+1:4d} | {ln}"
        for i, ln in enumerate(code.splitlines())
    )
    async with sem:
        resp = await aclient.messages.create(
            model="claude-sonnet-4-5",
            max_tokens=4096,
            system=SYSTEM_PROMPT,
            messages=[{"role": "user",
                       "content": f"File: {filepath}\n\n{numbered}"}],
        )
    findings = json.loads(resp.content[0].text)
    return filepath, findings

async def main(files: list[str]):
    tasks = [lint_one(f) for f in files]
    total_issues = 0
    for coro in asyncio.as_completed(tasks):
        filepath, findings = await coro
        if findings:
            total_issues += len(findings)
            print(f"\n🔍 {filepath}: {len(findings)} issue(s)")
            for f in findings:
                icon = {"error":"🔴","warning":"🟡"}.get(f["severity"],"🔵")
                print(f"  {icon} L{f['line']} [{f['rule']}] {f['message']}")
    print(f"\n{'='*40}\nTotal: {total_issues} issues in {len(files)} files")
    sys.exit(1 if total_issues else 0)

if __name__ == "__main__":
    asyncio.run(main(sys.argv[1:]))

name: AI Code Lint
on:
  pull_request:
    paths: ['**.py', '**.js', '**.ts']

jobs:
  ai-lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0
      - uses: actions/setup-python@v5
        with:
          python-version: '3.12'
      - run: pip install anthropic
      - name: Lint changed files
        env:
          EZAI_API_KEY: ${{ secrets.EZAI_API_KEY }}
        run: |
          CHANGED=$(git diff --name-only origin/main -- '*.py' '*.js' '*.ts')
          if [ -n "$CHANGED" ]; then
            python ailint_batch.py $CHANGED
          fi

# Load project-specific lint rules from .ailintrc
import json
from pathlib import Path

def load_rules() -> str:
    rc = Path(".ailintrc")
    if rc.exists():
        config = json.loads(rc.read_text())
        extra = "\n".join(config.get("rules", []))
        ignore = ", ".join(config.get("ignore", []))
        return f"""{SYSTEM_PROMPT}

Additional rules for this project:
{extra}

Ignore these patterns: {ignore}"""
    return SYSTEM_PROMPT

{
  "rules": [
    "Flag any use of float for monetary values — use Decimal",
    "All database writes must be inside a transaction context manager",
    "API endpoints must validate Content-Type header"
  ],
  "ignore": ["test_*.py", "migrations/"]
}