Analyze Project

display_name: Rigor Analyze / Rigor Audit
short_description: Rigor Analyze / Rigor Audit read-only mode for repository mapping and suspicious pattern review.
default_prompt: Analyze this deep learning project conservatively. Explain model structure, training and inference entrypoints, config relationships, likely insertion points, and suspicious implementation patterns without modifying code.


# Analysis Policy

## Default stance

Prefer structural understanding over action.

## Required behavior

- identify likely training, inference, and evaluation entrypoints
- summarize config and script layout
- highlight insertion points conservatively
- flag suspicious implementation patterns as unverified heuristics
- keep recommendations low-ego and review-friendly

## Forbidden behavior

- patching repository code
- claiming a suspicious pattern is a confirmed bug without evidence
- running heavy training or evaluation jobs by default


#!/usr/bin/env python3
"""Read-only analysis for deep learning research repositories."""

from __future__ import annotations

import argparse
import ast
import json
import re
from pathlib import Path
from typing import Any, Dict, Iterable, List, Optional


ENTRYPOINT_PATTERNS = {
    "train": re.compile(r"(train|trainer|fit|pretrain)", re.IGNORECASE),
    "infer": re.compile(r"(infer|inference|demo|predict|serve)", re.IGNORECASE),
    "eval": re.compile(r"(eval|evaluate|validation|test|benchmark|metric)", re.IGNORECASE),
    "model": re.compile(r"(model|network|backbone|encoder|decoder|head|adapter|lora|loss)", re.IGNORECASE),
    "config": re.compile(r"(config|configs)", re.IGNORECASE),
}
TASK_KEYWORDS = {
    "classification": ("class", "imagenet", "log_regression", "linear", "knn"),
    "segmentation": ("seg", "segment", "mask", "ade20k", "m2f", "mask2former"),
    "detection": ("det", "detect", "coco", "detr", "box"),
    "depth": ("depth", "nyu", "dpt", "depther"),
    "text": ("text", "clip", "token", "dinotxt"),
    "pretrain": ("ssl", "pretrain", "teacher", "student", "distillation", "gram"),
}
OUTPUT_HINTS = ("checkpoint", "results", "metrics", "tensorboard", "events", "log", "output")
SKIP_PARTS = {
    "tmp",
    "artifacts",
    "repro_outputs",
    "train_outputs",
    "analysis_outputs",
    "debug_outputs",
    "explore_outputs",
    "__pycache__",
    ".git",
    ".claude",
    ".codex",
}
COMMON_FOCUS_TOKENS = {"py", "yaml", "yml", "json", "toml", "ini", "md", "run", "train", "eval", "config", "configs"}


def load_context(path: Optional[str]) -> Dict[str, Any]:
    if not path:
        return {}
    context_path = Path(path).resolve()
    text = context_path.read_text(encoding="utf-8-sig")
    if context_path.suffix.lower() == ".json":
        return json.loads(text)
    try:
        import yaml  # type: ignore
    except ImportError as exc:
        raise ValueError(f"YAML analysis context requires PyYAML: {context_path}") from exc
    payload = yaml.safe_load(text)
    return payload if isinstance(payload, dict) else {}


def normalize_task_family(value: Any) -> Optional[str]:
    text = str(value or "").strip().lower()
    return text or None


def normalize_scalar_string(value: Any) -> str:
    if isinstance(value, dict):
        name = value.get("name")
        if name:
            return str(name)
        return json.dumps(value, ensure_ascii=False)
    return str(value or "")


def metric_goal(value: Any) -> str:
    text = str(value or "maximize").strip().lower()
    if text in {"min", "minimize", "lower", "lower_is_better"}:
        return "minimize"
    return "maximize"


def first_existing(root: Path, names: Iterable[str]) -> Optional[Path]:
    for name in names:
        candidate = root / name
        if candidate.exists():
            return candidate
    return None


def command_paths(command: str) -> List[str]:
    paths: List[str] = []
    for token in re.findall(r"[\w./\\-]+\.(?:py|ya?ml|json|toml|ini|csv|pth|pt)", command):
        token = token.strip().strip("\"