crucible-mcp 0.4.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

crucible/enforcement/models.py

@@ -1,6 +1,6 @@
 """Data models for the enforcement module."""
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from enum import Enum
 from typing import Literal
 
@@ -12,6 +12,14 @@ class AssertionType(Enum):
     LLM = "llm"
 
 
+class OverflowBehavior(Enum):
+    """Behavior when token budget is exceeded."""
+
+    SKIP = "skip"  # Skip remaining assertions silently
+    WARN = "warn"  # Skip with warning
+    FAIL = "fail"  # Fail the review
+
+
 class Priority(Enum):
     """Assertion priority levels for budget management."""
 
@@ -105,3 +113,65 @@ class EnforcementFinding:
     match_text: str | None = None
     suppressed: bool = False
     suppression_reason: str | None = None
+    source: Literal["pattern", "llm"] = "pattern"
+    llm_reasoning: str | None = None  # LLM's explanation for the finding
+
+
+@dataclass(frozen=True)
+class ComplianceConfig:
+    """Configuration for LLM-based compliance checking."""
+
+    enabled: bool = True
+    model: str = "sonnet"  # Default model (sonnet or opus)
+    token_budget: int = 10000  # 0 = unlimited
+    priority_order: tuple[str, ...] = ("critical", "high", "medium", "low")
+    overflow_behavior: OverflowBehavior = OverflowBehavior.WARN
+
+
+@dataclass
+class BudgetState:
+    """Mutable state for tracking token budget during compliance run."""
+
+    total_budget: int
+    tokens_used: int = 0
+    assertions_run: int = 0
+    assertions_skipped: int = 0
+    overflow_triggered: bool = False
+    skipped_assertions: list[str] = field(default_factory=list)
+
+    @property
+    def tokens_remaining(self) -> int:
+        """Tokens remaining in budget."""
+        if self.total_budget == 0:
+            return float("inf")  # type: ignore[return-value]
+        return max(0, self.total_budget - self.tokens_used)
+
+    @property
+    def is_exhausted(self) -> bool:
+        """Whether budget is exhausted."""
+        if self.total_budget == 0:
+            return False
+        return self.tokens_used >= self.total_budget
+
+    def consume(self, tokens: int) -> None:
+        """Consume tokens from budget."""
+        self.tokens_used += tokens
+        self.assertions_run += 1
+
+    def skip(self, assertion_id: str) -> None:
+        """Record a skipped assertion."""
+        self.assertions_skipped += 1
+        self.skipped_assertions.append(assertion_id)
+        self.overflow_triggered = True
+
+
+@dataclass(frozen=True)
+class LLMAssertionResult:
+    """Result from running a single LLM assertion."""
+
+    assertion_id: str
+    passed: bool
+    findings: tuple["EnforcementFinding", ...]
+    tokens_used: int
+    model_used: str
+    error: str | None = None

crucible/review/core.py

@@ -1,8 +1,11 @@
 """Core review functionality shared between CLI and MCP server."""
 
+from __future__ import annotations
+
 from collections import Counter
 from pathlib import Path
 
+from crucible.enforcement.models import BudgetState, ComplianceConfig
 from crucible.models import Domain, Severity, ToolFinding
 from crucible.tools.delegation import (
     delegate_bandit,
@@ -313,31 +316,42 @@ def run_enforcement(
     content: str | None = None,
     changed_files: list[str] | None = None,
     repo_root: str | None = None,
-) -> tuple[list, list[str], int, int]:
-    """Run pattern assertions.
+    compliance_config: ComplianceConfig | None = None,
+) -> tuple[list, list[str], int, int, BudgetState | None]:
+    """Run pattern and LLM assertions.
 
     Args:
         path: File or directory path
         content: File content (for single file mode)
         changed_files: List of changed files (for git mode)
         repo_root: Repository root path (for git mode)
+        compliance_config: Configuration for LLM compliance checking (optional)
 
     Returns:
-        (enforcement_findings, errors, assertions_checked, assertions_skipped)
+        (enforcement_findings, errors, assertions_checked, assertions_skipped, budget_state)
     """
     import os
 
     from crucible.enforcement.assertions import load_assertions
+    from crucible.enforcement.compliance import run_llm_assertions, run_llm_assertions_batch
     from crucible.enforcement.models import EnforcementFinding
     from crucible.enforcement.patterns import run_pattern_assertions
 
     assertions, errors = load_assertions()
     if not assertions:
-        return [], errors, 0, 0
+        return [], errors, 0, 0, None
 
     findings: list[EnforcementFinding] = []
     checked = 0
     skipped = 0
+    budget_state: BudgetState | None = None
+
+    # Default compliance config if not provided
+    if compliance_config is None:
+        compliance_config = ComplianceConfig()
+
+    # Collect files for batch LLM processing
+    files_for_llm: list[tuple[str, str]] = []
 
     if changed_files and repo_root:
         # Git mode: check each changed file
@@ -346,26 +360,67 @@ def run_enforcement(
             try:
                 with open(full_path) as f:
                     file_content = f.read()
+
+                # Run pattern assertions
                 f_findings, c, s = run_pattern_assertions(file_path, file_content, assertions)
                 findings.extend(f_findings)
                 checked = max(checked, c)
                 skipped = max(skipped, s)
+
+                # Collect for LLM processing
+                if compliance_config.enabled:
+                    files_for_llm.append((file_path, file_content))
             except OSError:
                 pass  # File may have been deleted
+
+        # Run LLM assertions in batch
+        if files_for_llm and compliance_config.enabled:
+            llm_findings, budget_state, llm_errors = run_llm_assertions_batch(
+                files_for_llm, assertions, compliance_config
+            )
+            findings.extend(llm_findings)
+            errors.extend(llm_errors)
+            if budget_state:
+                skipped += budget_state.assertions_skipped
+
     elif content is not None:
         # Single file with provided content
         f_findings, checked, skipped = run_pattern_assertions(path, content, assertions)
         findings.extend(f_findings)
+
+        # Run LLM assertions
+        if compliance_config.enabled:
+            llm_findings, budget_state, llm_errors = run_llm_assertions(
+                path, content, assertions, compliance_config
+            )
+            findings.extend(llm_findings)
+            errors.extend(llm_errors)
+            if budget_state:
+                skipped += budget_state.assertions_skipped
+
     elif os.path.isfile(path):
         # Single file
         try:
             with open(path) as f:
                 file_content = f.read()
-            findings, checked, skipped = run_pattern_assertions(path, file_content, assertions)
+
+            p_findings, checked, skipped = run_pattern_assertions(path, file_content, assertions)
+            findings.extend(p_findings)
+
+            # Run LLM assertions
+            if compliance_config.enabled:
+                llm_findings, budget_state, llm_errors = run_llm_assertions(
+                    path, file_content, assertions, compliance_config
+                )
+                findings.extend(llm_findings)
+                errors.extend(llm_errors)
+                if budget_state:
+                    skipped += budget_state.assertions_skipped
         except OSError as e:
             errors.append(f"Failed to read {path}: {e}")
+
     elif os.path.isdir(path):
-        # Directory
+        # Directory - collect all files for batch processing
         for root, _, files in os.walk(path):
             for fname in files:
                 fpath = os.path.join(root, fname)
@@ -373,11 +428,27 @@ def run_enforcement(
                 try:
                     with open(fpath) as f:
                         file_content = f.read()
+
+                    # Run pattern assertions
                     f_findings, c, s = run_pattern_assertions(rel_path, file_content, assertions)
                     findings.extend(f_findings)
                     checked = max(checked, c)
                     skipped = max(skipped, s)
+
+                    # Collect for LLM processing
+                    if compliance_config.enabled:
+                        files_for_llm.append((rel_path, file_content))
                 except (OSError, UnicodeDecodeError):
                     pass  # Skip unreadable files
 
-    return findings, errors, checked, skipped
+        # Run LLM assertions in batch
+        if files_for_llm and compliance_config.enabled:
+            llm_findings, budget_state, llm_errors = run_llm_assertions_batch(
+                files_for_llm, assertions, compliance_config
+            )
+            findings.extend(llm_findings)
+            errors.extend(llm_errors)
+            if budget_state:
+                skipped += budget_state.assertions_skipped
+
+    return findings, errors, checked, skipped, budget_state

crucible/server.py

@@ -117,6 +117,20 @@ async def list_tools() -> list[Tool]:
                         "description": "Run pattern assertions from .crucible/assertions/ (default: true).",
                         "default": True,
                     },
+                    "compliance_enabled": {
+                        "type": "boolean",
+                        "description": "Enable LLM compliance assertions (default: true).",
+                        "default": True,
+                    },
+                    "compliance_model": {
+                        "type": "string",
+                        "enum": ["sonnet", "opus", "haiku"],
+                        "description": "Model for LLM compliance assertions (default: sonnet).",
+                    },
+                    "token_budget": {
+                        "type": "integer",
+                        "description": "Token budget for LLM assertions (0 = unlimited, default: 10000).",
+                    },
                 },
             },
         ),
@@ -318,6 +332,7 @@ def _format_review_output(
     enforcement_errors: list[str] | None = None,
     assertions_checked: int = 0,
     assertions_skipped: int = 0,
+    budget_state: Any = None,
 ) -> str:
     """Format unified review output."""
     parts: list[str] = ["# Code Review\n"]
@@ -392,9 +407,22 @@ def _format_review_output(
         active = [f for f in enforcement_findings if not f.suppressed]
         suppressed = [f for f in enforcement_findings if f.suppressed]
 
-        parts.append("## Pattern Assertions\n")
-        if assertions_checked > 0 or assertions_skipped > 0:
-            parts.append(f"*Checked: {assertions_checked}, Skipped (LLM): {assertions_skipped}*\n")
+        # Separate pattern vs LLM findings
+        pattern_findings = [f for f in active if getattr(f, "source", "pattern") == "pattern"]
+        llm_findings = [f for f in active if getattr(f, "source", "pattern") == "llm"]
+
+        parts.append("## Enforcement Assertions\n")
+
+        # Summary line
+        summary_parts = []
+        if assertions_checked > 0:
+            summary_parts.append(f"Checked: {assertions_checked}")
+        if assertions_skipped > 0:
+            summary_parts.append(f"Skipped: {assertions_skipped}")
+        if budget_state and budget_state.tokens_used > 0:
+            summary_parts.append(f"LLM tokens: {budget_state.tokens_used}")
+        if summary_parts:
+            parts.append(f"*{', '.join(summary_parts)}*\n")
 
         if enforcement_errors:
             parts.append("**Errors:**")
@@ -402,22 +430,40 @@ def _format_review_output(
                 parts.append(f"- {err}")
             parts.append("")
 
-        if active:
-            # Group by severity
+        # Pattern assertions
+        if pattern_findings:
+            parts.append("### Pattern Assertions\n")
             by_sev: dict[str, list] = {}
-            for f in active:
+            for f in pattern_findings:
                 by_sev.setdefault(f.severity.upper(), []).append(f)
 
             for sev in ["ERROR", "WARNING", "INFO"]:
                 if sev in by_sev:
-                    parts.append(f"### {sev} ({len(by_sev[sev])})\n")
+                    parts.append(f"#### {sev} ({len(by_sev[sev])})\n")
                     for f in by_sev[sev]:
                         parts.append(f"- **[{f.assertion_id}]** {f.message}")
                         parts.append(f"  - Location: `{f.location}`")
                         if f.match_text:
                             parts.append(f"  - Match: `{f.match_text}`")
-        else:
-            parts.append("No pattern violations found.")
+
+        # LLM compliance assertions
+        if llm_findings:
+            parts.append("### LLM Compliance Assertions\n")
+            by_sev_llm: dict[str, list] = {}
+            for f in llm_findings:
+                by_sev_llm.setdefault(f.severity.upper(), []).append(f)
+
+            for sev in ["ERROR", "WARNING", "INFO"]:
+                if sev in by_sev_llm:
+                    parts.append(f"#### {sev} ({len(by_sev_llm[sev])})\n")
+                    for f in by_sev_llm[sev]:
+                        parts.append(f"- **[{f.assertion_id}]** {f.message}")
+                        parts.append(f"  - Location: `{f.location}`")
+                        if getattr(f, "llm_reasoning", None):
+                            parts.append(f"  - Reasoning: {f.llm_reasoning}")
+
+        if not pattern_findings and not llm_findings:
+            parts.append("No assertion violations found.")
 
         if suppressed:
             parts.append(f"\n*Suppressed: {len(suppressed)}*")
@@ -452,6 +498,8 @@ def _handle_review(arguments: dict[str, Any]) -> list[TextContent]:
     """Handle unified review tool."""
     import os
 
+    from crucible.enforcement.models import ComplianceConfig, OverflowBehavior
+
     path = arguments.get("path")
     mode = arguments.get("mode")
     base = arguments.get("base")
@@ -461,6 +509,18 @@ def _handle_review(arguments: dict[str, Any]) -> list[TextContent]:
     include_knowledge = arguments.get("include_knowledge", True)
     enforce = arguments.get("enforce", True)
 
+    # Build compliance config
+    compliance_enabled = arguments.get("compliance_enabled", True)
+    compliance_model = arguments.get("compliance_model", "sonnet")
+    token_budget = arguments.get("token_budget", 10000)
+
+    compliance_config = ComplianceConfig(
+        enabled=compliance_enabled,
+        model=compliance_model,
+        token_budget=token_budget,
+        overflow_behavior=OverflowBehavior.WARN,
+    )
+
     # Determine if this is path-based or git-based review
     git_context: GitContext | None = None
     changed_files: list[str] = []
@@ -544,21 +604,27 @@ def _handle_review(arguments: dict[str, Any]) -> list[TextContent]:
     # Deduplicate findings
     all_findings = deduplicate_findings(all_findings)
 
-    # Run pattern assertions
+    # Run pattern and LLM assertions
     enforcement_findings = []
     enforcement_errors: list[str] = []
     assertions_checked = 0
     assertions_skipped = 0
+    budget_state = None
 
     if enforce:
         if git_context:
             repo_path = get_repo_root(path if path else os.getcwd()).value
-            enforcement_findings, enforcement_errors, assertions_checked, assertions_skipped = (
-                run_enforcement(path or "", changed_files=changed_files, repo_root=repo_path)
+            enforcement_findings, enforcement_errors, assertions_checked, assertions_skipped, budget_state = (
+                run_enforcement(
+                    path or "",
+                    changed_files=changed_files,
+                    repo_root=repo_path,
+                    compliance_config=compliance_config,
+                )
             )
         elif path:
-            enforcement_findings, enforcement_errors, assertions_checked, assertions_skipped = (
-                run_enforcement(path)
+            enforcement_findings, enforcement_errors, assertions_checked, assertions_skipped, budget_state = (
+                run_enforcement(path, compliance_config=compliance_config)
             )
 
     # Compute severity summary
@@ -598,6 +664,7 @@ def _handle_review(arguments: dict[str, Any]) -> list[TextContent]:
         enforcement_errors if enforce else None,
         assertions_checked,
         assertions_skipped,
+        budget_state,
     )
 
     return [TextContent(type="text", text=output)]

crucible/tools/git.py

@@ -42,11 +42,17 @@ class GitContext:
 
 
 def is_git_repo(path: str | Path) -> bool:
-    """Check if the path is inside a git repository."""
+    """Check if the path is inside a git repository.
+
+    Works with both files and directories.
+    """
+    path = Path(path)
+    # Use parent directory if path is a file
+    check_dir = path.parent if path.is_file() else path
     try:
         result = subprocess.run(
             ["git", "rev-parse", "--git-dir"],
-            cwd=str(path),
+            cwd=str(check_dir),
             capture_output=True,
             text=True,
             timeout=5,
@@ -57,14 +63,21 @@ def is_git_repo(path: str | Path) -> bool:
 
 
 def get_repo_root(path: str | Path) -> Result[str, str]:
-    """Get the root directory of the git repository."""
+    """Get the root directory of the git repository.
+
+    Works with both files and directories.
+    """
     if not shutil.which("git"):
         return err("git not found")
 
+    path = Path(path)
+    # Use parent directory if path is a file
+    check_dir = path.parent if path.is_file() else path
+
     try:
         result = subprocess.run(
             ["git", "rev-parse", "--show-toplevel"],
-            cwd=str(path),
+            cwd=str(check_dir),
             capture_output=True,
             text=True,
             timeout=5,

{crucible_mcp-0.4.0.dist-info → crucible_mcp-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crucible-mcp
-Version: 0.4.0
+Version: 0.5.0
 Summary: Code review MCP server for Claude. Not affiliated with Atlassian.
 Author: be.nvy
 License-Expression: MIT
@@ -9,6 +9,7 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 Requires-Dist: mcp>=1.0.0
 Requires-Dist: pyyaml>=6.0
+Requires-Dist: anthropic>=0.40.0
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0; extra == "dev"
 Requires-Dist: pytest-asyncio>=0.23; extra == "dev"

{crucible_mcp-0.4.0.dist-info → crucible_mcp-0.5.0.dist-info}/RECORD

@@ -1,28 +1,30 @@
 crucible/__init__.py,sha256=M4v_CsJVOdiAAPgmd54mxkkbnes8e5ifMznDuOJhzzY,77
-crucible/cli.py,sha256=8rmzsh92h1kFSCFBGfd50pKWTdd7r2c3W_klk9c5JnY,60527
+crucible/cli.py,sha256=NwYbIUAW4zfPUIOw1tsASsV0rtEjiillvdO1tslkH_Y,74932
 crucible/errors.py,sha256=HrX_yvJEhXJoKodXGo_iY9wqx2J3ONYy0a_LbrVC5As,819
 crucible/models.py,sha256=jaxbiPc1E7bJxKPLadZe1dbSJdq-WINsxjveeSNNqeg,2066
-crucible/server.py,sha256=rzSi1sfuu1o5CpjMUgxFjJB6zjra9-M9WFmmelmORWA,43817
+crucible/server.py,sha256=oyfDl5-Ih3eoXBGDZ0ud7H3m2v0tn-Mc7mo19Bd-d00,46756
 crucible/domain/__init__.py,sha256=2fsoB5wH2Pl3vtGRt4voYOSZ04-zLoW8pNq6nvzVMgU,118
 crucible/domain/detection.py,sha256=TNeLB_VQgS1AsT5BKDf_tIpGa47THrFoRXwU4u54VB0,1797
 crucible/enforcement/__init__.py,sha256=FOaGSrE1SWFPxBJ1L5VoDhQDmlJgRXXs_iiI20wHf2Q,867
 crucible/enforcement/assertions.py,sha256=ay5QvJIr_YaqWYbrJNhbouafJOiy4ZhwiX7E9VAY3s4,8166
-crucible/enforcement/models.py,sha256=aIuxjqZfACpabT2lB1J3LKVzkcc1RTdbr7mAuBEAreU,2435
+crucible/enforcement/budget.py,sha256=-wFTlVY80c3-eJhvmlWrdlS8LB8E25aMnhtYpwR38sQ,4706
+crucible/enforcement/compliance.py,sha256=tkK-lSC5OMGOgt5xXY_APVSr-qHGB9kE8dUtoTF_n5w,14889
+crucible/enforcement/models.py,sha256=dEcPiUL6JEOBtxWOgKd_PZnsW_nUIaFsx18L70fM59M,4574
 crucible/enforcement/patterns.py,sha256=hE4Z-JJ9OBruSFPBDxw_aNaSJbyUPD2SWCEwA1KzDmI,9720
 crucible/hooks/__init__.py,sha256=k5oEWhTJKEQi-QWBfTbp1p6HaKg55_wVCBVD5pZzdqw,271
 crucible/hooks/precommit.py,sha256=OAwvjEACopcrTmWmZMO0S8TqZkvFY_392pJBFCHGSaQ,21561
 crucible/knowledge/__init__.py,sha256=unb7kyO1MtB3Zt-TGx_O8LE79KyrGrNHoFFHgUWUvGU,40
 crucible/knowledge/loader.py,sha256=DD4gqU6xkssaWvEkbymMOu6YtHab7YLEk-tU9cPTeaE,6666
 crucible/review/__init__.py,sha256=Ssva6Yaqcc44AqL9OUMjxypu5R1PPkrmLGk6OKtP15w,547
-crucible/review/core.py,sha256=Yl7NFFrUtzwjonovhv6sP2fDoplosAjxLvi5vASx08o,12671
+crucible/review/core.py,sha256=OdJd3kIY0MNkwJ-oUnopogeJ02vtXegPmGqLC1UvKmE,15482
 crucible/skills/__init__.py,sha256=L3heXWF0T3aR9yYLFphs1LNlkxAFSPkPuRFMH-S1taI,495
 crucible/skills/loader.py,sha256=iC0_V1s6CIse5NXyFGtpLbON8xDxYh8xXmHH7hAX5O0,8642
 crucible/synthesis/__init__.py,sha256=CYrkZG4bdAjp8XdOh1smfKscd3YU5lZlaDLGwLE9c-0,46
 crucible/tools/__init__.py,sha256=gFRThTk1E-fHzpe8bB5rtBG6Z6G-ysPzjVEHfKGbEYU,400
 crucible/tools/delegation.py,sha256=_x1y76No3qkmGjjROVvMx1pSKKwU59aRu5R-r07lVFU,12871
-crucible/tools/git.py,sha256=EmxRUt0jSFLa_mm_2Czt5rHdiFC0YK9IpaPDfRwlXVo,10051
-crucible_mcp-0.4.0.dist-info/METADATA,sha256=hmhKr9GR0M9x0qV-edCMibj8lFrgKb4Bgv-Kx-cJoSY,5168
-crucible_mcp-0.4.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-crucible_mcp-0.4.0.dist-info/entry_points.txt,sha256=18BZaH1OlFSFYtKuHq0Z8yYX8Wmx7Ikfqay-P00ZX3Q,83
-crucible_mcp-0.4.0.dist-info/top_level.txt,sha256=4hzuFgqbFPOO-WiU_DYxTm8VYIxTXh7Wlp0gRcWR0Cs,9
-crucible_mcp-0.4.0.dist-info/RECORD,,
+crucible/tools/git.py,sha256=7-aJCesoQe3ZEBFcRxHBhY8RpZrBlNtHSns__RqiG04,10406
+crucible_mcp-0.5.0.dist-info/METADATA,sha256=d0ui9gJweDBJox6HvWiW6LvWAfaB9tOjXZJhF6eksuE,5201
+crucible_mcp-0.5.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+crucible_mcp-0.5.0.dist-info/entry_points.txt,sha256=18BZaH1OlFSFYtKuHq0Z8yYX8Wmx7Ikfqay-P00ZX3Q,83
+crucible_mcp-0.5.0.dist-info/top_level.txt,sha256=4hzuFgqbFPOO-WiU_DYxTm8VYIxTXh7Wlp0gRcWR0Cs,9
+crucible_mcp-0.5.0.dist-info/RECORD,,