claude-dev-env 1.0.0

package/hooks/validators/output_formatter.py

@@ -0,0 +1,266 @@
+"""Output formatting for validators.
+
+Provides:
+- Colored terminal output
+- Contextual diff display
+- Progress indicators
+- JSON output for CI
+"""
+
+import json
+import sys
+from dataclasses import dataclass
+from enum import Enum
+from typing import Dict, List, TypedDict
+
+
+class ViolationDict(TypedDict):
+    file: str
+    line: int
+    message: str
+
+
+class ValidatorResultDict(TypedDict):
+    name: str
+    checks: str
+    passed: bool
+    output: str
+
+
+class OutputMode(Enum):
+    TEXT = "text"
+    JSON = "json"
+    COMPACT = "compact"
+
+
+def colorize(text: str, color: str, enabled: bool = True) -> str:
+    """Add ANSI color codes to text.
+
+    Args:
+        text: Text to colorize
+        color: Color name (red, green, yellow, blue)
+        enabled: Whether to apply colors
+
+    Returns:
+        Colorized text or original if disabled
+    """
+    if not enabled:
+        return text
+
+    colors = {
+        "red": "\033[91m",
+        "green": "\033[92m",
+        "yellow": "\033[93m",
+        "blue": "\033[94m",
+        "bold": "\033[1m",
+        "reset": "\033[0m",
+    }
+
+    color_code = colors.get(color, "")
+    reset = colors["reset"]
+
+    return f"{color_code}{text}{reset}"
+
+
+def format_violation_with_context(
+    source: str,
+    line_num: int,
+    message: str,
+    context_lines: int = 2,
+    use_colors: bool = True,
+) -> str:
+    """Format a violation with surrounding code context.
+
+    Args:
+        source: Full source code
+        line_num: Line number of violation (1-indexed)
+        message: Violation message
+        context_lines: Number of context lines before/after
+        use_colors: Whether to use ANSI colors
+
+    Returns:
+        Formatted violation with context
+    """
+    lines = source.splitlines()
+    start = max(0, line_num - context_lines - 1)
+    end = min(len(lines), line_num + context_lines)
+
+    output_lines: List[str] = []
+    output_lines.append(colorize(f"  {message}", "red", use_colors))
+    output_lines.append("")
+
+    for i in range(start, end):
+        line_number = i + 1
+        line_content = lines[i]
+        prefix = ">" if line_number == line_num else " "
+
+        if line_number == line_num:
+            formatted = colorize(
+                f"  {prefix} {line_number:4d} | {line_content}",
+                "red",
+                use_colors,
+            )
+        else:
+            formatted = f"    {line_number:4d} | {line_content}"
+
+        output_lines.append(formatted)
+
+    output_lines.append("")
+    return "\n".join(output_lines)
+
+
+@dataclass(frozen=True)
+class OutputFormatter:
+    """Formats validator output for display."""
+
+    mode: OutputMode = OutputMode.TEXT
+    use_colors: bool = True
+    show_context: bool = True
+    context_lines: int = 2
+
+    @property
+    def effective_use_colors(self) -> bool:
+        """Return whether colors should be used, accounting for TTY detection."""
+        return self.use_colors and sys.stdout.isatty()
+
+    def format_header(self, title: str) -> str:
+        """Format a section header."""
+        if self.mode == OutputMode.JSON:
+            return ""
+
+        separator = "=" * 60
+        return f"\n{separator}\n{title}\n{separator}\n"
+
+    def format_progress(self, current: int, total: int, name: str) -> str:
+        """Format a progress indicator."""
+        if self.mode == OutputMode.JSON:
+            return ""
+
+        bar_width = 20
+        filled = int(bar_width * current / total)
+        bar = "#" * filled + "-" * (bar_width - filled)
+
+        return f"[{bar}] {current}/{total} {name}"
+
+    def format_result(
+        self,
+        name: str,
+        checks: str,
+        passed: bool,
+        output: str,
+    ) -> str:
+        """Format a single validator result."""
+        if self.mode == OutputMode.JSON:
+            return ""
+
+        use_colors = self.effective_use_colors
+        status = colorize("[PASS]", "green", use_colors) if passed else colorize("[FAIL]", "red", use_colors)
+
+        lines = [f"{status} {name} (checks {checks})"]
+
+        if not passed and output:
+            for line in output.strip().split("\n"):
+                if line:
+                    lines.append(f"       {line}")
+
+        return "\n".join(lines)
+
+    def format_results(self, results: List[ValidatorResultDict]) -> str:
+        """Format all validator results."""
+        if self.mode == OutputMode.JSON:
+            return json.dumps({"results": results}, indent=2)
+
+        output_lines: List[str] = []
+
+        for result in results:
+            output_lines.append(
+                self.format_result(
+                    name=result["name"],
+                    checks=result.get("checks", ""),
+                    passed=result["passed"],
+                    output=result.get("output", ""),
+                )
+            )
+
+        return "\n".join(output_lines)
+
+    def format_summary(self, passed: int, failed: int) -> str:
+        """Format the final summary."""
+        if self.mode == OutputMode.JSON:
+            return ""
+
+        use_colors = self.effective_use_colors
+        separator = "=" * 60
+
+        if failed == 0:
+            verdict = colorize("READY TO PUSH", "green", use_colors)
+            detail = "All automated checks passed"
+        else:
+            verdict = colorize("VIOLATIONS FOUND", "red", use_colors)
+            detail = f"{failed} check(s) failed"
+
+        return f"\n{separator}\nVERDICT: {verdict} - {detail}\n{separator}\n"
+
+    def format_stats(
+        self,
+        files_checked: int,
+        violations_found: int,
+        time_elapsed: float,
+    ) -> str:
+        """Format statistics."""
+        if self.mode == OutputMode.JSON:
+            return ""
+
+        return (
+            f"\nStats: {files_checked} files checked, "
+            f"{violations_found} violations found, "
+            f"{time_elapsed:.2f}s elapsed\n"
+        )
+
+
+def group_violations_by_file(violations: List[ViolationDict]) -> Dict[str, List[ViolationDict]]:
+    """Group violations by file path.
+
+    Args:
+        violations: List of violation dicts with 'file' key
+
+    Returns:
+        Dict mapping file paths to their violations
+    """
+    grouped: Dict[str, List[ViolationDict]] = {}
+
+    for violation in violations:
+        file_path = violation.get("file", "unknown")
+        if file_path not in grouped:
+            grouped[file_path] = []
+        grouped[file_path].append(violation)
+
+    return grouped
+
+
+def format_grouped_violations(
+    grouped: Dict[str, List[ViolationDict]],
+    use_colors: bool = True,
+) -> str:
+    """Format violations grouped by file.
+
+    Args:
+        grouped: Dict from group_violations_by_file
+        use_colors: Whether to use ANSI colors
+
+    Returns:
+        Formatted string with file headers
+    """
+    output_lines: List[str] = []
+
+    for file_path, violations in sorted(grouped.items()):
+        output_lines.append("")
+        output_lines.append(colorize(f"  {file_path}", "bold", use_colors))
+        output_lines.append("  " + "-" * (len(file_path) + 2))
+
+        for violation in sorted(violations, key=lambda v: v.get("line", 0)):
+            line = violation.get("line", "?")
+            message = violation.get("message", "Unknown violation")
+            output_lines.append(f"    Line {line}: {message}")
+
+    return "\n".join(output_lines)

package/hooks/validators/pr_reference_checks.py

@@ -0,0 +1,72 @@
+"""PR and commit reference detection validator.
+
+Implements check 6: No PR/commit references in comments.
+Code comments must be timeless - no historical context.
+"""
+
+import re
+import sys
+from pathlib import Path
+from typing import List
+
+from validator_base import Violation
+
+
+PR_PATTERN = re.compile(r"#.*\bPR\s*#?\d+", re.IGNORECASE)
+COMMIT_PATTERN = re.compile(r"#.*\bcommit\b", re.IGNORECASE)
+ISSUE_PATTERN = re.compile(r"#.*(?:addresses|fixes|closes|resolves)\s*#\d+", re.IGNORECASE)
+HASH_REF_PATTERN = re.compile(r"#\s*#\d+")
+
+
+def check_pr_references(source: str, filename: str) -> List[Violation]:
+    violations: List[Violation] = []
+    lines = source.splitlines()
+
+    for line_num, line in enumerate(lines, start=1):
+        if PR_PATTERN.search(line):
+            violations.append(
+                Violation(filename, line_num, "PR reference in comment - comments should be timeless")
+            )
+        elif COMMIT_PATTERN.search(line):
+            violations.append(
+                Violation(filename, line_num, "Commit reference in comment - comments should be timeless")
+            )
+        elif ISSUE_PATTERN.search(line) or HASH_REF_PATTERN.search(line):
+            violations.append(
+                Violation(filename, line_num, "Issue reference in comment - comments should be timeless")
+            )
+
+    return violations
+
+
+def validate_file(file_path: Path) -> List[Violation]:
+    filename = str(file_path)
+    try:
+        source = file_path.read_text(encoding="utf-8")
+    except Exception as error:
+        return [Violation(filename, 0, f"Error reading file: {error}")]
+
+    return check_pr_references(source, filename)
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        print("Usage: pr_reference_checks.py <file1> [file2 ...]", file=sys.stderr)
+        return 1
+
+    all_violations: List[Violation] = []
+    for file_arg in sys.argv[1:]:
+        file_path = Path(file_arg)
+        if not file_path.exists():
+            print(f"Error: File not found: {file_path}", file=sys.stderr)
+            return 1
+        all_violations.extend(validate_file(file_path))
+
+    for violation in all_violations:
+        print(violation)
+
+    return 1 if all_violations else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

package/hooks/validators/python_antipattern_checks.py

@@ -0,0 +1,110 @@
+"""Python anti-pattern detection validator.
+
+Implements:
+- Check 33: Mutable default arguments
+- Check 34: Bare except clauses
+- Check 35: Print in production code
+"""
+
+import ast
+import sys
+from pathlib import Path
+from typing import List
+
+from validator_base import Violation
+
+
+def check_mutable_default_args(tree: ast.AST, filename: str) -> List[Violation]:
+    violations: List[Violation] = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+            for default in node.args.defaults:
+                if isinstance(default, (ast.List, ast.Dict, ast.Set)):
+                    violations.append(
+                        Violation(
+                            filename,
+                            node.lineno,
+                            f"Mutable default argument in '{node.name}' - use None and initialize inside",
+                        )
+                    )
+
+    return violations
+
+
+def check_bare_except(tree: ast.AST, filename: str) -> List[Violation]:
+    violations: List[Violation] = []
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.ExceptHandler):
+            if node.type is None:
+                violations.append(
+                    Violation(
+                        filename,
+                        node.lineno,
+                        "Bare except clause - specify exception type",
+                    )
+                )
+
+    return violations
+
+
+def check_print_in_production(tree: ast.AST, filename: str) -> List[Violation]:
+    violations: List[Violation] = []
+
+    if "test" in filename.lower():
+        return violations
+
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Call):
+            if isinstance(node.func, ast.Name) and node.func.id == "print":
+                violations.append(
+                    Violation(
+                        filename,
+                        node.lineno,
+                        "print() in production code - use logging instead",
+                    )
+                )
+
+    return violations
+
+
+def validate_file(file_path: Path) -> List[Violation]:
+    violations: List[Violation] = []
+    filename = str(file_path)
+
+    try:
+        source = file_path.read_text(encoding="utf-8")
+        tree = ast.parse(source)
+    except Exception as error:
+        return [Violation(filename, 0, f"Error: {error}")]
+
+    violations.extend(check_mutable_default_args(tree, filename))
+    violations.extend(check_bare_except(tree, filename))
+    violations.extend(check_print_in_production(tree, filename))
+
+    return violations
+
+
+def main() -> int:
+    if len(sys.argv) < 2:
+        print("Usage: python_antipattern_checks.py <file1.py> [file2.py ...]", file=sys.stderr)
+        return 1
+
+    all_violations: List[Violation] = []
+
+    for file_arg in sys.argv[1:]:
+        file_path = Path(file_arg)
+        if not file_path.exists():
+            print(f"Error: File not found: {file_path}", file=sys.stderr)
+            return 1
+        all_violations.extend(validate_file(file_path))
+
+    for violation in all_violations:
+        print(violation)
+
+    return 1 if all_violations else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())