secondlook 0.1.0__py3-none-any.whl

codereview/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

codereview/config/config.py

@@ -0,0 +1,75 @@
+"""Configuration loading and validation."""
+
+import logging
+import os
+import re
+from pathlib import Path
+from typing import Any
+from pydantic import BaseModel, Field
+import yaml
+
+logger = logging.getLogger(__name__)
+
+
+class ProviderConfig(BaseModel):
+    model: str = ""
+    api_key: str = ""
+    endpoint: str | None = None
+
+
+class DefaultsConfig(BaseModel):
+    mode: str = "raw"
+    focus: str = "all"
+    max_tokens: int = 2048
+    timeout_sec: float = 60.0
+    max_retries: int = 3
+    provider: str = "gemini"
+
+
+class Config(BaseModel):
+    default_provider: str = "gemini"
+    providers: dict[str, ProviderConfig] = Field(default_factory=dict)
+    defaults: DefaultsConfig = Field(default_factory=DefaultsConfig)
+
+
+def _expand_env(value: str) -> str:
+    if not isinstance(value, str):
+        return value
+
+    def _replacer(match: re.Match) -> str:
+        return os.environ.get(match.group(1), "")
+
+    return re.sub(r"\$\{(\w+)\}", _replacer, value)
+
+
+def _find_config_path(path: str | None) -> str:
+    if path:
+        return path
+
+    env_path = os.environ.get("CODEREVIEW_CONFIG")
+    if env_path:
+        return env_path
+
+    xdg = os.environ.get("XDG_CONFIG_HOME", str(Path.home() / ".config"))
+    return str(Path(xdg) / "codereview" / "config.yaml")
+
+
+def load_config(path: str | None = None) -> Config:
+    config_path = _find_config_path(path)
+
+    if os.path.exists(config_path):
+        logger.info("Loading config from %s", config_path)
+        with open(config_path, encoding="utf-8") as f:
+            raw = yaml.safe_load(f) or {}
+    else:
+        logger.info("No config file found at %s, using defaults", config_path)
+        raw = {}
+
+    if "providers" in raw:
+        for name, provider in raw["providers"].items():
+            if isinstance(provider, dict):
+                for key in ("api_key", "model", "endpoint"):
+                    if key in provider and isinstance(provider[key], str):
+                        provider[key] = _expand_env(provider[key])
+
+    return Config(**raw)

codereview/main.py

@@ -0,0 +1,42 @@
+"""secondlook — multi-provider code review via MCP."""
+
+import argparse
+import logging
+import sys
+
+from mcp.server import Server
+from mcp.server.stdio import stdio_server
+
+from codereview.tool.review import register_tools
+
+logger = logging.getLogger("codereview")
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        description="secondlook — multi-provider code review via MCP",
+    )
+    parser.add_argument(
+        "--config",
+        default=None,
+        help="Path to config file (default: ~/.config/codereview/config.yaml)",
+    )
+    args = parser.parse_args()
+
+    logging.basicConfig(
+        level=logging.WARNING,
+        format="%(levelname)s | %(name)s | %(message)s",
+        stream=sys.stderr,
+    )
+
+    server = Server("codereview")
+    register_tools(server, args.config)
+
+    logger.info("codereview-mcp starting")
+    import asyncio
+
+    asyncio.run(stdio_server(server))
+
+
+if __name__ == "__main__":
+    main()

codereview/prompt/prompt.py

@@ -0,0 +1,38 @@
+"""Prompt templates for each review mode."""
+
+RAW = """You are a code reviewer. Review the following code for bugs,
+security issues, performance problems, and style violations.
+Be concise. Use severity markers: [CRITICAL], [HIGH], [MEDIUM], [LOW].
+Reference exact line numbers when possible."""
+
+VERIFY_DIFF = """You are a diff verifier. A developer proposed this change.
+Review it for: correctness, edge cases, regressions, test gaps.
+Do NOT suggest alternative approaches unless the proposed
+approach is actively harmful. Flag false fixes with [FALSE-FIX]."""
+
+SECOND_OPINION = """You are a second-opinion reviewer. A primary model analyzed
+this diff and provided reasoning. Critique the reasoning:
+- Did it miss edge cases?
+- Did it suggest correct but suboptimal solutions?
+- Did it hallucinate any behavior?
+- Is there a simpler approach?
+Be adversarial. Assume the primary model might be wrong."""
+
+COMPARE = """You are a code reviewer from {provider_name}. Review the following
+code/diff for bugs, security issues, performance problems, and style.
+Be concise. Use severity: [CRITICAL], [HIGH], [MEDIUM], [LOW].
+Reference exact line numbers when possible.
+
+Your findings will be compared against reviews from other providers.
+Focus on what YOU uniquely catch. Be specific."""
+
+
+def get_prompt(mode: str, provider_name: str = "") -> str:
+    """Return the system prompt for a given review mode."""
+    prompts = {
+        "raw": RAW,
+        "verify-diff": VERIFY_DIFF,
+        "second-opinion": SECOND_OPINION,
+        "compare": COMPARE.format(provider_name=provider_name),
+    }
+    return prompts.get(mode, RAW)

codereview/provider/base.py

@@ -0,0 +1,137 @@
+"""LLM provider interface with retry, timeout, and structured errors."""
+
+import asyncio
+import logging
+import httpx
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+
+logger = logging.getLogger(__name__)
+
+
+class ErrorKind(Enum):
+    AUTH = "auth"
+    RATE_LIMIT = "rate_limit"
+    TIMEOUT = "timeout"
+    SERVER = "server"
+    CLIENT = "client"
+    UNKNOWN = "unknown"
+
+
+@dataclass
+class ReviewResult:
+    provider: str
+    model: str
+    findings: str = ""
+    error: str | None = None
+    error_kind: ErrorKind | None = None
+    tokens_used: int = 0
+    latency_ms: float = 0.0
+
+
+@dataclass
+class ProviderConfig:
+    api_key: str = ""
+    model: str = ""
+    endpoint: str | None = None
+    max_tokens: int = 2048
+    timeout_sec: float = 60.0
+    max_retries: int = 3
+
+
+class ProviderError(Exception):
+    def __init__(self, message: str, kind: ErrorKind = ErrorKind.UNKNOWN) -> None:
+        super().__init__(message)
+        self.kind = kind
+
+
+class Provider(ABC):
+    def __init__(
+        self,
+        api_key: str = "",
+        model: str = "",
+        endpoint: str | None = None,
+        max_tokens: int = 2048,
+        timeout_sec: float = 60.0,
+        max_retries: int = 3,
+    ) -> None:
+        self.api_key = api_key
+        self.model = model
+        self.endpoint = endpoint
+        self.max_tokens = max_tokens
+        self.timeout_sec = timeout_sec
+        self.max_retries = max_retries
+
+    @property
+    @abstractmethod
+    def name(self) -> str: ...
+
+    @abstractmethod
+    async def _call_api(self, system_prompt: str, user_prompt: str) -> str: ...
+
+    async def review(self, system_prompt: str, user_prompt: str) -> ReviewResult:
+        import time
+
+        t0 = time.monotonic()
+        last_error: Exception | None = None
+
+        for attempt in range(self.max_retries + 1):
+            try:
+                text = await asyncio.wait_for(
+                    self._call_api(system_prompt, user_prompt),
+                    timeout=self.timeout_sec,
+                )
+                latency = (time.monotonic() - t0) * 1000
+                logger.info(
+                    "%s review completed in %.0fms (attempt %d)",
+                    self.name,
+                    latency,
+                    attempt + 1,
+                )
+                return ReviewResult(
+                    provider=self.name,
+                    model=self.model,
+                    findings=text,
+                    latency_ms=latency,
+                )
+            except asyncio.TimeoutError:
+                last_error = ProviderError(
+                    f"Request timed out after {self.timeout_sec}s",
+                    ErrorKind.TIMEOUT,
+                )
+                logger.warning("%s timeout (attempt %d)", self.name, attempt + 1)
+            except httpx.TimeoutException:
+                last_error = ProviderError(
+                    f"HTTP timeout after {self.timeout_sec}s",
+                    ErrorKind.TIMEOUT,
+                )
+                logger.warning("%s HTTP timeout (attempt %d)", self.name, attempt + 1)
+            except ProviderError as e:
+                last_error = e
+                if e.kind == ErrorKind.AUTH:
+                    break
+                if e.kind == ErrorKind.RATE_LIMIT and attempt < self.max_retries:
+                    wait = 2 ** attempt
+                    logger.warning("%s rate limited, retrying in %ds", self.name, wait)
+                    await asyncio.sleep(wait)
+                    continue
+                logger.warning("%s error (attempt %d): %s", self.name, attempt + 1, e)
+            except Exception as e:
+                last_error = e
+                logger.warning("%s error (attempt %d): %s", self.name, attempt + 1, e)
+
+            if attempt < self.max_retries:
+                await asyncio.sleep(1 * (attempt + 1))
+
+        msg = str(last_error) if last_error else "unknown error"
+        kind = last_error.kind if isinstance(last_error, ProviderError) else ErrorKind.UNKNOWN
+
+        return ReviewResult(
+            provider=self.name,
+            model=self.model,
+            findings="",
+            error=msg,
+            error_kind=kind,
+            latency_ms=(time.monotonic() - t0) * 1000,
+        )

codereview/provider/claude.py

@@ -0,0 +1,77 @@
+"""Claude provider via Anthropic Messages API."""
+
+import logging
+import httpx
+from codereview.provider.base import (
+    Provider,
+    ProviderError,
+    ErrorKind,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ClaudeProvider(Provider):
+    @property
+    def name(self) -> str:
+        return "claude"
+
+    def _parse_error(self, status: int, body: dict | str) -> ProviderError:
+        msg = ""
+        if isinstance(body, dict):
+            err = body.get("error", {})
+            msg = err.get("message", str(body))
+            if err.get("type") == "overloaded_error":
+                return ProviderError(f"Claude overloaded: {msg}", ErrorKind.RATE_LIMIT)
+        else:
+            msg = str(body)
+
+        if status == 401 or status == 403:
+            return ProviderError(f"Claude auth error: {msg}", ErrorKind.AUTH)
+        if status == 429 or status == 529:
+            return ProviderError("Claude rate limited / overloaded", ErrorKind.RATE_LIMIT)
+        if status >= 500:
+            return ProviderError(f"Claude server error ({status}): {msg}", ErrorKind.SERVER)
+        return ProviderError(f"Claude error ({status}): {msg}", ErrorKind.CLIENT)
+
+    async def _call_api(self, system_prompt: str, user_prompt: str) -> str:
+        endpoint = self.endpoint or "https://api.anthropic.com"
+        url = f"{endpoint}/v1/messages"
+
+        headers = {
+            "x-api-key": self.api_key,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        }
+
+        payload = {
+            "model": self.model,
+            "max_tokens": self.max_tokens,
+            "temperature": 0.2,
+            "system": system_prompt,
+            "messages": [{"role": "user", "content": user_prompt}],
+        }
+
+        async with httpx.AsyncClient(timeout=self.timeout_sec) as client:
+            resp = await client.post(url, headers=headers, json=payload)
+
+            if resp.status_code != 200:
+                try:
+                    body = resp.json()
+                except Exception:
+                    body = resp.text
+                raise self._parse_error(resp.status_code, body)
+
+            data = resp.json()
+            content = data.get("content", [])
+            if not content:
+                raise ProviderError("Claude returned empty response", ErrorKind.SERVER)
+
+            stop_reason = data.get("stop_reason", "")
+            if stop_reason and stop_reason not in ("end_turn", "max_tokens"):
+                raise ProviderError(
+                    f"Claude stopped: {stop_reason}",
+                    ErrorKind.SERVER,
+                )
+
+            return content[0]["text"]

codereview/provider/deepseek.py

@@ -0,0 +1,75 @@
+"""DeepSeek provider via OpenAI-compatible API."""
+
+import logging
+import httpx
+from codereview.provider.base import (
+    Provider,
+    ProviderError,
+    ErrorKind,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class DeepSeekProvider(Provider):
+    @property
+    def name(self) -> str:
+        return "deepseek"
+
+    def _parse_error(self, status: int, body: dict | str) -> ProviderError:
+        msg = str(body)
+        if isinstance(body, dict):
+            msg = body.get("error", {}).get("message", str(body))
+            code = body.get("error", {}).get("code", "")
+            if code == "insufficient_quota":
+                return ProviderError(f"DeepSeek quota: {msg}", ErrorKind.RATE_LIMIT)
+        if status == 401:
+            return ProviderError(f"DeepSeek auth error: {msg}", ErrorKind.AUTH)
+        if status == 429:
+            return ProviderError("DeepSeek rate limited", ErrorKind.RATE_LIMIT)
+        if status >= 500:
+            return ProviderError(f"DeepSeek server error ({status}): {msg}", ErrorKind.SERVER)
+        return ProviderError(f"DeepSeek error ({status}): {msg}", ErrorKind.CLIENT)
+
+    async def _call_api(self, system_prompt: str, user_prompt: str) -> str:
+        endpoint = self.endpoint or "https://api.deepseek.com"
+        url = f"{endpoint}/v1/chat/completions"
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        payload = {
+            "model": self.model,
+            "max_tokens": self.max_tokens,
+            "temperature": 0.2,
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+            ],
+        }
+
+        async with httpx.AsyncClient(timeout=self.timeout_sec) as client:
+            resp = await client.post(url, headers=headers, json=payload)
+
+            if resp.status_code != 200:
+                try:
+                    body = resp.json()
+                except Exception:
+                    body = resp.text
+                raise self._parse_error(resp.status_code, body)
+
+            data = resp.json()
+            choices = data.get("choices", [])
+            if not choices:
+                raise ProviderError("DeepSeek returned empty response", ErrorKind.SERVER)
+
+            finish_reason = choices[0].get("finish_reason", "")
+            if finish_reason and finish_reason not in ("stop", "length"):
+                raise ProviderError(
+                    f"DeepSeek stopped: {finish_reason}",
+                    ErrorKind.SERVER,
+                )
+
+            return choices[0]["message"]["content"]

codereview/provider/gemini.py

@@ -0,0 +1,73 @@
+"""Gemini provider via Google AI API."""
+
+import logging
+import httpx
+from codereview.provider.base import (
+    Provider,
+    ProviderError,
+    ErrorKind,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class GeminiProvider(Provider):
+    @property
+    def name(self) -> str:
+        return "gemini"
+
+    def _parse_error(self, status: int, body: dict | str) -> ProviderError:
+        msg = str(body) if isinstance(body, str) else body.get("error", {}).get("message", str(body))
+        if status == 401 or status == 403:
+            return ProviderError(f"Gemini auth error: {msg}", ErrorKind.AUTH)
+        if status == 429:
+            return ProviderError("Gemini rate limited", ErrorKind.RATE_LIMIT)
+        if status >= 500:
+            return ProviderError(f"Gemini server error ({status}): {msg}", ErrorKind.SERVER)
+        return ProviderError(f"Gemini error ({status}): {msg}", ErrorKind.CLIENT)
+
+    async def _call_api(self, system_prompt: str, user_prompt: str) -> str:
+        endpoint = self.endpoint or "https://generativelanguage.googleapis.com"
+        url = f"{endpoint}/v1beta/models/{self.model}:generateContent"
+        params = {}
+        if self.api_key:
+            params["key"] = self.api_key
+
+        payload = {
+            "systemInstruction": {"parts": [{"text": system_prompt}]},
+            "contents": [{"role": "user", "parts": [{"text": user_prompt}]}],
+            "generationConfig": {
+                "maxOutputTokens": self.max_tokens,
+                "temperature": 0.2,
+            },
+        }
+
+        async with httpx.AsyncClient(timeout=self.timeout_sec) as client:
+            resp = await client.post(url, params=params, json=payload)
+
+            if resp.status_code != 200:
+                try:
+                    body = resp.json()
+                except Exception:
+                    body = resp.text
+                raise self._parse_error(resp.status_code, body)
+
+            data = resp.json()
+            candidates = data.get("candidates", [])
+            if not candidates:
+                raise ProviderError("Gemini returned empty response", ErrorKind.SERVER)
+
+            finish_reason = candidates[0].get("finishReason", "")
+            if finish_reason and finish_reason not in ("STOP", "MAX_TOKENS"):
+                raise ProviderError(
+                    f"Gemini stopped unexpectedly: {finish_reason}",
+                    ErrorKind.SERVER,
+                )
+
+            try:
+                return candidates[0]["content"]["parts"][0]["text"]
+            except (KeyError, IndexError, TypeError):
+                raise ProviderError(
+                    "Gemini returned unexpected response structure",
+                    ErrorKind.SERVER,
+                )

codereview/provider/ollama.py

@@ -0,0 +1,73 @@
+"""Ollama provider for local models via OpenAI-compatible API."""
+
+import logging
+import httpx
+from codereview.provider.base import (
+    Provider,
+    ProviderError,
+    ErrorKind,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class OllamaProvider(Provider):
+    @property
+    def name(self) -> str:
+        return "ollama"
+
+    async def _call_api(self, system_prompt: str, user_prompt: str) -> str:
+        endpoint = self.endpoint or "http://localhost:11434"
+        url = f"{endpoint}/v1/chat/completions"
+
+        headers = {"Content-Type": "application/json"}
+
+        payload = {
+            "model": self.model,
+            "max_tokens": self.max_tokens,
+            "temperature": 0.2,
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+            ],
+        }
+
+        async with httpx.AsyncClient(timeout=self.timeout_sec) as client:
+            try:
+                resp = await client.post(url, headers=headers, json=payload)
+            except httpx.ConnectError:
+                raise ProviderError(
+                    "Cannot connect to Ollama. Is it running? Try: ollama serve",
+                    ErrorKind.SERVER,
+                )
+
+            if resp.status_code != 200:
+                try:
+                    body = resp.json()
+                    msg = body.get("error", {}).get("message", resp.text)
+                except Exception:
+                    msg = resp.text
+
+                if resp.status_code == 404 and "not found" in msg.lower():
+                    raise ProviderError(
+                        f"Model '{self.model}' not found. Pull it: ollama pull {self.model}",
+                        ErrorKind.CLIENT,
+                    )
+                raise ProviderError(
+                    f"Ollama error ({resp.status_code}): {msg}",
+                    ErrorKind.SERVER if resp.status_code >= 500 else ErrorKind.CLIENT,
+                )
+
+            data = resp.json()
+            choices = data.get("choices", [])
+            if not choices:
+                raise ProviderError("Ollama returned empty response", ErrorKind.SERVER)
+
+            finish_reason = choices[0].get("finish_reason", "")
+            if finish_reason and finish_reason not in ("stop", "length"):
+                raise ProviderError(
+                    f"Ollama stopped: {finish_reason}",
+                    ErrorKind.SERVER,
+                )
+
+            return choices[0]["message"]["content"]

codereview/provider/openai.py

@@ -0,0 +1,81 @@
+"""OpenAI provider via Chat Completions API."""
+
+import logging
+import httpx
+from codereview.provider.base import (
+    Provider,
+    ProviderError,
+    ErrorKind,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class OpenAIProvider(Provider):
+    @property
+    def name(self) -> str:
+        return "openai"
+
+    def _parse_error(self, status: int, body: dict | str) -> ProviderError:
+        msg = ""
+        if isinstance(body, dict):
+            err = body.get("error", {})
+            msg = err.get("message", str(body))
+            code = err.get("code", "")
+            if code == "insufficient_quota":
+                if status == 429:
+                    return ProviderError(f"OpenAI rate/quota: {msg}", ErrorKind.RATE_LIMIT)
+                return ProviderError(f"OpenAI quota error (billing): {msg}", ErrorKind.AUTH)
+        else:
+            msg = str(body)
+
+        if status == 401:
+            return ProviderError(f"OpenAI auth error: {msg}", ErrorKind.AUTH)
+        if status == 429:
+            return ProviderError(f"OpenAI rate limited: {msg}", ErrorKind.RATE_LIMIT)
+        if status >= 500:
+            return ProviderError(f"OpenAI server error ({status}): {msg}", ErrorKind.SERVER)
+        return ProviderError(f"OpenAI error ({status}): {msg}", ErrorKind.CLIENT)
+
+    async def _call_api(self, system_prompt: str, user_prompt: str) -> str:
+        endpoint = self.endpoint or "https://api.openai.com"
+        url = f"{endpoint}/v1/chat/completions"
+
+        headers = {
+            "Authorization": f"Bearer {self.api_key}",
+            "Content-Type": "application/json",
+        }
+
+        payload = {
+            "model": self.model,
+            "max_tokens": self.max_tokens,
+            "temperature": 0.2,
+            "messages": [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt},
+            ],
+        }
+
+        async with httpx.AsyncClient(timeout=self.timeout_sec) as client:
+            resp = await client.post(url, headers=headers, json=payload)
+
+            if resp.status_code != 200:
+                try:
+                    body = resp.json()
+                except Exception:
+                    body = resp.text
+                raise self._parse_error(resp.status_code, body)
+
+            data = resp.json()
+            choices = data.get("choices", [])
+            if not choices:
+                raise ProviderError("OpenAI returned empty response", ErrorKind.SERVER)
+
+            finish_reason = choices[0].get("finish_reason", "")
+            if finish_reason and finish_reason not in ("stop", "length"):
+                raise ProviderError(
+                    f"OpenAI stopped: {finish_reason}",
+                    ErrorKind.SERVER,
+                )
+
+            return choices[0]["message"]["content"]

codereview/provider/vertexai.py

@@ -0,0 +1,149 @@
+"""Vertex AI provider via Google Cloud platform.
+
+Auth via gcloud ADC (Application Default Credentials):
+  gcloud auth application-default login
+  gcloud config set project YOUR_PROJECT
+
+Or set GOOGLE_APPLICATION_CREDENTIALS to a service account key.
+"""
+
+import asyncio
+import logging
+import httpx
+from codereview.provider.base import (
+    Provider,
+    ProviderError,
+    ErrorKind,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class VertexAIProvider(Provider):
+    def __init__(
+        self,
+        api_key: str = "",
+        model: str = "gemini-2.5-pro",
+        endpoint: str | None = None,
+        max_tokens: int = 2048,
+        timeout_sec: float = 60.0,
+        max_retries: int = 3,
+    ) -> None:
+        super().__init__(api_key, model, endpoint, max_tokens, timeout_sec, max_retries)
+        self._project: str = ""
+        self._location: str = "us-central1"
+        self._credentials: object | None = None
+
+        if self.endpoint:
+            parts = self.endpoint.split(",")
+            if len(parts) >= 1 and parts[0].strip():
+                self._project = parts[0].strip()
+            if len(parts) >= 2 and parts[1].strip():
+                self._location = parts[1].strip()
+
+    @property
+    def name(self) -> str:
+        return "vertexai"
+
+    async def _get_credentials(self) -> tuple[str, str]:
+        if self._credentials is not None and self._project:
+            from google.auth.transport.requests import Request
+            await asyncio.to_thread(self._credentials.refresh, Request())
+            return self._credentials.token, self._project
+
+        try:
+            from google.auth import default
+            from google.auth.transport.requests import Request
+
+            credentials, project = default()
+            if not credentials:
+                raise ProviderError(
+                    "No Google Cloud credentials found. Run: gcloud auth application-default login",
+                    ErrorKind.AUTH,
+                )
+            if not project and not self._project:
+                raise ProviderError(
+                    "No GCP project configured. Run: gcloud config set project YOUR_PROJECT",
+                    ErrorKind.AUTH,
+                )
+
+            await asyncio.to_thread(credentials.refresh, Request())
+            self._credentials = credentials
+            if project:
+                self._project = project
+
+            return credentials.token, self._project
+        except ProviderError:
+            raise
+        except ImportError:
+            raise ProviderError(
+                "google-auth not installed. Run: pip install codereview-mcp[vertexai]",
+                ErrorKind.AUTH,
+            )
+        except Exception as e:
+            raise ProviderError(
+                f"Failed to get GCP credentials: {e}",
+                ErrorKind.AUTH,
+            )
+
+    async def _call_api(self, system_prompt: str, user_prompt: str) -> str:
+        token, project = await self._get_credentials()
+
+        location = self._location
+        url = (
+            f"https://{location}-aiplatform.googleapis.com"
+            f"/v1/projects/{project}/locations/{location}"
+            f"/publishers/google/models/{self.model}:generateContent"
+        )
+
+        headers = {
+            "Authorization": f"Bearer {token}",
+            "Content-Type": "application/json",
+        }
+
+        payload = {
+            "systemInstruction": {"parts": [{"text": system_prompt}]},
+            "contents": [{"role": "user", "parts": [{"text": user_prompt}]}],
+            "generationConfig": {
+                "maxOutputTokens": self.max_tokens,
+                "temperature": 0.2,
+            },
+        }
+
+        async with httpx.AsyncClient(timeout=self.timeout_sec) as client:
+            resp = await client.post(url, headers=headers, json=payload)
+
+            if resp.status_code != 200:
+                try:
+                    body = resp.json()
+                    msg = body.get("error", {}).get("message", resp.text)
+                except Exception:
+                    msg = resp.text
+
+                if resp.status_code == 401 or resp.status_code == 403:
+                    raise ProviderError(f"Vertex AI auth error: {msg}", ErrorKind.AUTH)
+                if resp.status_code == 429:
+                    raise ProviderError("Vertex AI rate limited", ErrorKind.RATE_LIMIT)
+                if resp.status_code >= 500:
+                    raise ProviderError(f"Vertex AI server error ({resp.status_code}): {msg}", ErrorKind.SERVER)
+                raise ProviderError(f"Vertex AI error ({resp.status_code}): {msg}", ErrorKind.CLIENT)
+
+            data = resp.json()
+            candidates = data.get("candidates", [])
+            if not candidates:
+                raise ProviderError("Vertex AI returned empty response", ErrorKind.SERVER)
+
+            finish_reason = candidates[0].get("finishReason", "")
+            if finish_reason and finish_reason not in ("STOP", "MAX_TOKENS"):
+                raise ProviderError(
+                    f"Vertex AI stopped: {finish_reason}",
+                    ErrorKind.SERVER,
+                )
+
+            try:
+                return candidates[0]["content"]["parts"][0]["text"]
+            except (KeyError, IndexError, TypeError):
+                raise ProviderError(
+                    "Vertex AI returned unexpected response structure",
+                    ErrorKind.SERVER,
+                )

codereview/tool/review.py

@@ -0,0 +1,316 @@
+"""MCP tool registration and handler for code review."""
+
+import asyncio
+import logging
+import re
+from pathlib import Path
+
+from mcp.server import Server
+from mcp.types import Tool, TextContent
+
+from codereview.config.config import load_config, Config
+from codereview.prompt.prompt import get_prompt
+from codereview.provider.base import Provider, ReviewResult, ErrorKind
+from codereview.provider.gemini import GeminiProvider
+from codereview.provider.claude import ClaudeProvider
+from codereview.provider.openai import OpenAIProvider
+from codereview.provider.deepseek import DeepSeekProvider
+from codereview.provider.ollama import OllamaProvider
+from codereview.provider.vertexai import VertexAIProvider
+
+logger = logging.getLogger(__name__)
+
+PROVIDER_MAP: dict[str, type[Provider]] = {
+    "gemini": GeminiProvider,
+    "claude": ClaudeProvider,
+    "openai": OpenAIProvider,
+    "deepseek": DeepSeekProvider,
+    "vertexai": VertexAIProvider,
+    "ollama": OllamaProvider,
+}
+
+SEVERITY_RE = re.compile(r"\[(CRITICAL|HIGH|MEDIUM|LOW)\]", re.IGNORECASE)
+MAX_CONCURRENT = 5
+_review_semaphore = asyncio.Semaphore(MAX_CONCURRENT)
+
+
+def _make_provider(name: str, cfg: Config) -> Provider | None:
+    if name not in cfg.providers:
+        logger.warning("Provider '%s' not in config", name)
+        return None
+    pc = cfg.providers[name]
+    cls = PROVIDER_MAP.get(name)
+    if cls is None:
+        return None
+    return cls(
+        api_key=pc.api_key,
+        model=pc.model or cls.__name__.replace("Provider", "").lower(),
+        endpoint=pc.endpoint,
+        max_tokens=cfg.defaults.max_tokens,
+        timeout_sec=cfg.defaults.timeout_sec,
+        max_retries=cfg.defaults.max_retries,
+    )
+
+
+def _read_files(files: list[str]) -> str:
+    parts: list[str] = []
+    for f in files:
+        path = Path(f)
+        if path.exists() and path.is_file():
+            try:
+                content = path.read_text()
+                parts.append(f"--- {f} ---\n{content}")
+            except UnicodeDecodeError:
+                parts.append(f"--- {f} ---\n[BINARY FILE — skipped]")
+                logger.warning("Binary file skipped: %s", f)
+        else:
+            parts.append(f"--- {f} ---\n[FILE NOT FOUND]")
+            logger.warning("File not found: %s", f)
+    return "\n\n".join(parts)
+
+
+def _build_user_prompt(
+    mode: str,
+    files_content: str,
+    diff: str = "",
+    explanation: str = "",
+    focus: str = "all",
+) -> str:
+    base = f"Review the following:\n\n{files_content}"
+
+    if diff:
+        base += f"\n\n## Proposed Diff\n\n{diff}"
+
+    if mode == "second-opinion" and explanation:
+        base += f"\n\n## Primary Model's Reasoning\n\n{explanation}"
+        base += "\n\nCritique the reasoning above. What did it miss?"
+
+    if mode == "verify-diff":
+        base += "\n\nIs this diff correct? Does it introduce bugs, regressions, or edge case failures?"
+
+    if focus and focus != "all":
+        base += f"\n\nFocus your review on: {focus}."
+
+    return base
+
+
+def _count_severities(text: str) -> dict[str, int]:
+    counts: dict[str, int] = {"CRITICAL": 0, "HIGH": 0, "MEDIUM": 0, "LOW": 0, "total": 0}
+    for match in SEVERITY_RE.finditer(text):
+        sev = match.group(1).upper()
+        counts[sev] += 1
+        counts["total"] += 1
+    return counts
+
+
+def _format_single(result: ReviewResult) -> str:
+    header = f"## Code Review — {result.provider} ({result.model})"
+    timing = f"*{result.latency_ms:.0f}ms*"
+    return f"{header} {timing}\n\n{result.findings}"
+
+
+def _format_compare(explanation: str, results: list[ReviewResult]) -> str:
+    if not results:
+        return "No results."
+
+    lines = ["## Multi-Provider Code Review\n"]
+
+    if explanation:
+        lines.append(f"**Primary reasoning:** {explanation[:300]}\n")
+
+    # Individual reviews
+    for r in results:
+        if r.error:
+            lines.append(f"### {r.provider} — ERROR ({r.error_kind.value if r.error_kind else 'unknown'})")
+            lines.append(f"```\n{r.error}\n```\n")
+        else:
+            lines.append(f"### {r.provider} ({r.model}) — {r.latency_ms:.0f}ms\n")
+            lines.append(r.findings)
+            lines.append("")
+
+    # Severity summary table
+    lines.append("---\n")
+    lines.append("## Summary\n")
+
+    sevs: dict[str, dict[str, int]] = {}
+    for r in results:
+        if not r.error:
+            sevs[r.provider] = _count_severities(r.findings)
+
+    all_providers = list(sevs.keys())
+    if all_providers:
+        header = "| Provider | CRITICAL | HIGH | MEDIUM | LOW | Total |"
+        sep = "|----------|----------|------|--------|-----|-------|"
+        lines.append(header)
+        lines.append(sep)
+        for p in all_providers:
+            c = sevs[p]
+            row = f"| {p} | {c.get('CRITICAL', 0)} | {c.get('HIGH', 0)} | {c.get('MEDIUM', 0)} | {c.get('LOW', 0)} | {c['total']} |"
+            lines.append(row)
+
+        lines.append("")
+        total_issues = sum(sevs[p]["total"] for p in all_providers)
+        provider_count = len(all_providers)
+        avg = total_issues / provider_count if provider_count > 0 else 0
+        lines.append(
+            f"**{total_issues} total issues across {provider_count} providers "
+            f"(avg {avg:.1f}/provider).** "
+        )
+
+    # Timing table
+    lines.append("\n### Latency")
+    lines.append("| Provider | Time |")
+    lines.append("|----------|------|")
+    for r in results:
+        if r.error:
+            lines.append(f"| {r.provider} | ⚠ {r.latency_ms:.0f}ms (failed) |")
+        else:
+            lines.append(f"| {r.provider} | {r.latency_ms:.0f}ms |")
+
+    return "\n".join(lines)
+
+
+async def _run_single_review(
+    mode: str,
+    provider_name: str,
+    system_prompt: str,
+    user_prompt: str,
+    cfg: Config,
+) -> ReviewResult:
+    provider = _make_provider(provider_name, cfg)
+    if provider is None:
+        return ReviewResult(
+            provider=provider_name,
+            model="?",
+            error=f"Provider '{provider_name}' not configured. Add it to config.yaml.",
+            error_kind=ErrorKind.AUTH,
+        )
+    logger.info("Running review with %s (mode=%s)", provider_name, mode)
+    async with _review_semaphore:
+        return await provider.review(system_prompt, user_prompt)
+
+
+def register_tools(server: Server, config_path: str | None = None) -> None:
+    cfg = load_config(config_path)
+
+    @server.list_tools()
+    async def list_tools() -> list[Tool]:
+        return [
+            Tool(
+                name="code_review",
+                description=(
+                    "Review code using a secondary LLM provider. "
+                    "Supports raw review, diff verification, second-opinion critique, "
+                    "and multi-provider comparison with severity-tracking matrix."
+                ),
+                inputSchema={
+                    "type": "object",
+                    "properties": {
+                        "files": {
+                            "type": "array",
+                            "items": {"type": "string"},
+                            "description": "File paths or inline code snippets to review.",
+                        },
+                        "diff": {
+                            "type": "string",
+                            "description": "Git diff or proposed change to verify.",
+                        },
+                        "explanation": {
+                            "type": "string",
+                            "description": "Primary model's reasoning to critique (second-opinion mode).",
+                        },
+                        "provider": {
+                            "type": "string",
+                            "enum": list(PROVIDER_MAP.keys()),
+                            "description": "Which LLM to use for review. Defaults to config default.",
+                        },
+                        "providers": {
+                            "type": "array",
+                            "items": {"type": "string", "enum": list(PROVIDER_MAP.keys())},
+                            "description": "List of providers for compare mode. Runs all concurrently.",
+                        },
+                        "mode": {
+                            "type": "string",
+                            "enum": ["raw", "verify-diff", "second-opinion", "compare"],
+                            "description": "Review mode.",
+                        },
+                        "focus": {
+                            "type": "string",
+                            "enum": ["bugs", "security", "performance", "style", "all"],
+                            "description": "Review focus area.",
+                        },
+                    },
+                    "required": ["files", "mode"],
+                },
+            )
+        ]
+
+    @server.call_tool()
+    async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+        if name != "code_review":
+            return [TextContent(type="text", text=f"Unknown tool: {name}")]
+
+        files: list[str] = arguments.get("files", [])
+        if isinstance(files, str):
+            files = [files]
+        diff = arguments.get("diff", "")
+        explanation = arguments.get("explanation", "")
+        provider_name = arguments.get("provider", cfg.default_provider)
+        providers_list = arguments.get("providers", [])
+        if isinstance(providers_list, str):
+            providers_list = [s.strip() for s in providers_list.split(",") if s.strip()]
+        mode = arguments.get("mode", "raw")
+        focus = arguments.get("focus", "all")
+
+        if not files:
+            return [TextContent(type="text", text="Error: 'files' is required.")]
+
+        if mode == "compare" and not providers_list:
+            return [TextContent(type="text", text="Error: 'providers' list required for compare mode.")]
+
+        files_content = _read_files(files)
+        user_prompt = _build_user_prompt(mode, files_content, diff, explanation, focus)
+
+        # Compare mode: run multiple providers concurrently
+        if mode == "compare" and providers_list:
+            tasks = [
+                _run_single_review(
+                    "compare",
+                    p,
+                    get_prompt("compare", p),
+                    user_prompt,
+                    cfg,
+                )
+                for p in providers_list
+            ]
+            results: list[ReviewResult] = await asyncio.gather(*tasks, return_exceptions=True)
+            parsed: list[ReviewResult] = []
+            for r in results:
+                if isinstance(r, Exception):
+                    parsed.append(ReviewResult(
+                        provider="unknown",
+                        model="?",
+                        error=str(r),
+                    ))
+                else:
+                    parsed.append(r)
+            output = _format_compare(explanation, parsed)
+            return [TextContent(type="text", text=output)]
+
+        # Single-provider mode
+        system_prompt = get_prompt(mode, provider_name)
+        result = await _run_single_review(mode, provider_name, system_prompt, user_prompt, cfg)
+
+        if result.error:
+            error_text = (
+                f"## Code Review — ERROR\n\n"
+                f"**Provider:** {result.provider}\n"
+                f"**Error:** {result.error}\n"
+            )
+            if result.error_kind == ErrorKind.AUTH:
+                error_text += "\nCheck your API key in `~/.config/codereview/config.yaml`."
+            elif result.error_kind == ErrorKind.RATE_LIMIT:
+                error_text += "\nRate limited. Wait and retry."
+            return [TextContent(type="text", text=error_text)]
+
+        return [TextContent(type="text", text=_format_single(result))]

secondlook-0.1.0.dist-info/METADATA

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: secondlook
+Version: 0.1.0
+Summary: Multi-provider code review via MCP. Get a second look on your code from any LLM.
+Author: Cleverson Lopes Ledur
+License: MIT
+Keywords: ai,claude,code-review,deepseek,gemini,llm,mcp,multi-provider,openai,second-opinion
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.12
+Requires-Dist: httpx>=0.28
+Requires-Dist: mcp>=1.0
+Requires-Dist: pydantic>=2.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.12; extra == 'dev'
+Provides-Extra: vertexai
+Requires-Dist: google-auth>=2.0; extra == 'vertexai'
+Description-Content-Type: text/markdown
+
+# secondlook
+
+Multi-provider code review via MCP. Get a second look on your code from any LLM.
+
+## Install
+
+```bash
+uvx secondlook
+```
+
+Add to Claude Code / Cursor MCP config:
+
+```json
+{
+  "mcpServers": {
+    "codereview": {
+      "command": "uvx",
+      "args": ["secondlook"]
+    }
+  }
+}
+```
+
+## Quick Start
+
+Create `~/.config/codereview/config.yaml`:
+
+```yaml
+default_provider: gemini
+
+providers:
+  gemini:
+    model: gemini-2.5-pro
+    api_key: ${GEMINI_API_KEY}
+  claude:
+    model: claude-sonnet-4-20250514
+    api_key: ${ANTHROPIC_API_KEY}
+```
+
+Then in your editor:
+
+```
+> code_review files:["src/auth.go"] provider:"gemini"
+> code_review files:["src/auth.go"] providers:["gemini","claude","deepseek"] mode:"compare"
+```
+
+## Modes
+
+| Mode | Use case |
+|---|---|
+| `raw` | Fresh review from a secondary LLM |
+| `verify-diff` | "Is Claude's proposed change correct?" |
+| `second-opinion` | "Critique Claude's reasoning on this fix" |
+| `compare` | Run 2+ models, merge findings, show agreement matrix |
+
+## Providers
+
+Gemini | Claude | OpenAI | DeepSeek | Vertex AI | Ollama (local)

secondlook-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+codereview/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+codereview/main.py,sha256=L_ZaWtaGB9Riiuxism8e47isxaVjpAb6VKtBm9NfopU,953
+codereview/config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codereview/config/config.py,sha256=nKTw30awgfLbar7aL-_1G7qJGGMBjf7ESfsTlVXPpRc,2020
+codereview/prompt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codereview/prompt/prompt.py,sha256=X_CQhOYwYnOmPu7PcpGcwBS7rFTJ79hLVvdZGvQr3g0,1621
+codereview/provider/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codereview/provider/base.py,sha256=t-CD4_F5C_H7NUNINPl8uqf5eNUbXYWswZ1gAm94LHk,4266
+codereview/provider/claude.py,sha256=NOx9wBDE3U8mytf67YFGfSAj-m5C17_ZZBz55IFB-SU,2650
+codereview/provider/deepseek.py,sha256=dIV0hKEUI1X0XlHPJOOppI_Dmtiyjzx05WitjL7-6Ug,2661
+codereview/provider/gemini.py,sha256=0ob5Bo1_Lc5E4vNr-JM2ZEyuowbEDYBAWNAELvEmEos,2726
+codereview/provider/ollama.py,sha256=YbsTbGzJrg6YFgGatyfZRDwkfydQsXA_tGtsJk4jFmU,2508
+codereview/provider/openai.py,sha256=5DdV7YGTq9p8db6S8Fjin7U_CJuzOCt_H4q3ie6vCYc,2822
+codereview/provider/vertexai.py,sha256=XwPIVeJBD3MhTGKm9C_Z_kwFgpqRWL90J2Ky8mB8jaU,5422
+codereview/tool/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+codereview/tool/review.py,sha256=LkTA4GuWEhY210Z_Ks02V3Ox-hSyQ129hBtxzLa7MTc,11723
+secondlook-0.1.0.dist-info/METADATA,sha256=afGl-AAnuI_D687CQajTbttEGonuUk73KOF_J51iOVU,1976
+secondlook-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+secondlook-0.1.0.dist-info/entry_points.txt,sha256=nX04tGYhvgrGojCDZNk-A2ZHmTkDxRXjgz5FdCVeDZM,52
+secondlook-0.1.0.dist-info/RECORD,,

secondlook-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

secondlook-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+secondlook = codereview.main:main