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

crucible/server.py

@@ -13,6 +13,15 @@ from crucible.knowledge.loader import (
     load_principles,
 )
 from crucible.models import Domain, FullReviewResult, Severity, ToolFinding
+from crucible.review.core import (
+    compute_severity_counts,
+    deduplicate_findings,
+    detect_domain,
+    filter_findings_to_changes,
+    load_skills_and_knowledge,
+    run_enforcement,
+    run_static_analysis,
+)
 from crucible.skills import get_knowledge_for_skills, load_skill, match_skills_for_domain
 from crucible.tools.delegation import (
     check_all_tools,
@@ -61,45 +70,59 @@ def _format_findings(findings: list[ToolFinding]) -> str:
     return "\n".join(parts) if parts else "No findings."
 
 
-def _deduplicate_findings(findings: list[ToolFinding]) -> list[ToolFinding]:
-    """Deduplicate findings by location and message.
-
-    When multiple tools report the same issue at the same location,
-    keep only the highest severity finding.
-    """
-    # Group by (location, normalized_message)
-    seen: dict[tuple[str, str], ToolFinding] = {}
-
-    for f in findings:
-        # Normalize the message for comparison (lowercase, strip whitespace)
-        norm_msg = f.message.lower().strip()
-        key = (f.location, norm_msg)
-
-        if key not in seen:
-            seen[key] = f
-        else:
-            # Keep the higher severity finding
-            existing = seen[key]
-            severity_order = [
-                Severity.CRITICAL,
-                Severity.HIGH,
-                Severity.MEDIUM,
-                Severity.LOW,
-                Severity.INFO,
-            ]
-            if severity_order.index(f.severity) < severity_order.index(existing.severity):
-                seen[key] = f
-
-    return list(seen.values())
-
-
 @server.list_tools()  # type: ignore[misc]
 async def list_tools() -> list[Tool]:
     """List available tools."""
     return [
+        Tool(
+            name="review",
+            description="Unified code review tool. Supports path-based review OR git-aware review. Runs static analysis, matches skills, loads knowledge.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "File or directory path to review. If not provided, uses git mode.",
+                    },
+                    "mode": {
+                        "type": "string",
+                        "enum": ["staged", "unstaged", "branch", "commits"],
+                        "description": "Git mode: staged (about to commit), unstaged (working dir), branch (PR diff), commits (recent N)",
+                    },
+                    "base": {
+                        "type": "string",
+                        "description": "Base branch for 'branch' mode (default: main) or commit count for 'commits' mode (default: 1)",
+                    },
+                    "include_context": {
+                        "type": "boolean",
+                        "description": "For git modes: include findings near (within 5 lines of) changes (default: false)",
+                    },
+                    "skills": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Override skill selection (default: auto-detect based on domain)",
+                    },
+                    "include_skills": {
+                        "type": "boolean",
+                        "description": "Load skills and checklists (default: true). Set false for quick analysis only.",
+                        "default": True,
+                    },
+                    "include_knowledge": {
+                        "type": "boolean",
+                        "description": "Load knowledge files (default: true). Set false for quick analysis only.",
+                        "default": True,
+                    },
+                    "enforce": {
+                        "type": "boolean",
+                        "description": "Run pattern assertions from .crucible/assertions/ (default: true).",
+                        "default": True,
+                    },
+                },
+            },
+        ),
         Tool(
             name="quick_review",
-            description="Run static analysis tools on code. Returns findings with domain metadata for skill selection.",
+            description="[DEPRECATED: use review(path, include_skills=false)] Run static analysis only.",
             inputSchema={
                 "type": "object",
                 "properties": {
@@ -116,6 +139,57 @@ async def list_tools() -> list[Tool]:
                 "required": ["path"],
             },
         ),
+        Tool(
+            name="full_review",
+            description="[DEPRECATED: use review(path)] Comprehensive code review with skills and knowledge.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "path": {
+                        "type": "string",
+                        "description": "File or directory path to review",
+                    },
+                    "skills": {
+                        "type": "array",
+                        "items": {"type": "string"},
+                        "description": "Override skill selection (default: auto-detect based on domain)",
+                    },
+                    "include_sage": {
+                        "type": "boolean",
+                        "description": "Include Sage knowledge recall (not yet implemented)",
+                        "default": True,
+                    },
+                },
+                "required": ["path"],
+            },
+        ),
+        Tool(
+            name="review_changes",
+            description="[DEPRECATED: use review(mode='staged')] Review git changes.",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "mode": {
+                        "type": "string",
+                        "enum": ["staged", "unstaged", "branch", "commits"],
+                        "description": "What changes to review",
+                    },
+                    "base": {
+                        "type": "string",
+                        "description": "Base branch for 'branch' mode or commit count for 'commits' mode",
+                    },
+                    "path": {
+                        "type": "string",
+                        "description": "Repository path (default: current directory)",
+                    },
+                    "include_context": {
+                        "type": "boolean",
+                        "description": "Include findings near changes (default: false)",
+                    },
+                },
+                "required": ["mode"],
+            },
+        ),
         Tool(
             name="get_principles",
             description="Load engineering principles by topic",
@@ -203,57 +277,6 @@ async def list_tools() -> list[Tool]:
                 "properties": {},
             },
         ),
-        Tool(
-            name="review_changes",
-            description="Review git changes (staged, unstaged, branch diff, commits). Runs analysis on changed files and filters findings to changed lines only.",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "mode": {
-                        "type": "string",
-                        "enum": ["staged", "unstaged", "branch", "commits"],
-                        "description": "What changes to review: staged (about to commit), unstaged (working dir), branch (PR diff vs base), commits (recent N commits)",
-                    },
-                    "base": {
-                        "type": "string",
-                        "description": "Base branch for 'branch' mode (default: main) or commit count for 'commits' mode (default: 1)",
-                    },
-                    "path": {
-                        "type": "string",
-                        "description": "Repository path (default: current directory)",
-                    },
-                    "include_context": {
-                        "type": "boolean",
-                        "description": "Include findings near (within 5 lines of) changes, not just in changed lines (default: false)",
-                    },
-                },
-                "required": ["mode"],
-            },
-        ),
-        Tool(
-            name="full_review",
-            description="Comprehensive code review: runs static analysis, matches applicable skills based on domain, loads linked knowledge. Returns unified report for synthesis.",
-            inputSchema={
-                "type": "object",
-                "properties": {
-                    "path": {
-                        "type": "string",
-                        "description": "File or directory path to review",
-                    },
-                    "skills": {
-                        "type": "array",
-                        "items": {"type": "string"},
-                        "description": "Override skill selection (default: auto-detect based on domain)",
-                    },
-                    "include_sage": {
-                        "type": "boolean",
-                        "description": "Include Sage knowledge recall (not yet implemented)",
-                        "default": True,
-                    },
-                },
-                "required": ["path"],
-            },
-        ),
         Tool(
             name="load_knowledge",
             description="Load knowledge/principles files without running static analysis. Useful for getting guidance on patterns, best practices, or domain-specific knowledge. Automatically includes project and user knowledge files.",
@@ -280,6 +303,306 @@ async def list_tools() -> list[Tool]:
     ]
 
 
+def _format_review_output(
+    path: str | None,
+    git_context: GitContext | None,
+    domains: list[str],
+    severity_counts: dict[str, int],
+    findings: list[ToolFinding],
+    tool_errors: list[str],
+    matched_skills: list[tuple[str, list[str]]] | None,
+    skill_content: dict[str, str] | None,
+    knowledge_files: set[str] | None,
+    knowledge_content: dict[str, str] | None,
+    enforcement_findings: list | None = None,
+    enforcement_errors: list[str] | None = None,
+    assertions_checked: int = 0,
+    assertions_skipped: int = 0,
+) -> str:
+    """Format unified review output."""
+    parts: list[str] = ["# Code Review\n"]
+
+    # Header based on mode
+    if git_context:
+        parts.append(f"**Mode:** {git_context.mode}")
+        if git_context.base_ref:
+            parts.append(f"**Base:** {git_context.base_ref}")
+    elif path:
+        parts.append(f"**Path:** `{path}`")
+
+    parts.append(f"**Domains:** {', '.join(domains)}")
+    parts.append(f"**Severity summary:** {severity_counts or 'No findings'}\n")
+
+    # Files changed (git mode)
+    if git_context and git_context.changes:
+        added = [c for c in git_context.changes if c.status == "A"]
+        modified = [c for c in git_context.changes if c.status == "M"]
+        deleted = [c for c in git_context.changes if c.status == "D"]
+        renamed = [c for c in git_context.changes if c.status == "R"]
+
+        total = len(git_context.changes)
+        parts.append(f"## Files Changed ({total})")
+        for c in added:
+            parts.append(f"- `+` {c.path}")
+        for c in modified:
+            parts.append(f"- `~` {c.path}")
+        for c in renamed:
+            parts.append(f"- `R` {c.old_path} -> {c.path}")
+        for c in deleted:
+            parts.append(f"- `-` {c.path}")
+        parts.append("")
+
+        # Commit messages
+        if git_context.commit_messages:
+            parts.append("## Commits")
+            for msg in git_context.commit_messages:
+                parts.append(f"- {msg}")
+            parts.append("")
+
+    # Tool errors
+    if tool_errors:
+        parts.append("## Tool Errors\n")
+        for error in tool_errors:
+            parts.append(f"- {error}")
+        parts.append("")
+
+    # Applicable skills
+    if matched_skills:
+        parts.append("## Applicable Skills\n")
+        for skill_name, triggers in matched_skills:
+            parts.append(f"- **{skill_name}**: matched on {', '.join(triggers)}")
+        parts.append("")
+
+    # Knowledge loaded
+    if knowledge_files:
+        parts.append("## Knowledge Loaded\n")
+        parts.append(f"Files: {', '.join(sorted(knowledge_files))}")
+        parts.append("")
+
+    # Findings
+    parts.append("## Static Analysis Findings\n")
+    if findings:
+        parts.append(_format_findings(findings))
+    else:
+        parts.append("No issues found.")
+    parts.append("")
+
+    # Enforcement assertions
+    if enforcement_findings is not None:
+        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")
+
+        if enforcement_errors:
+            parts.append("**Errors:**")
+            for err in enforcement_errors:
+                parts.append(f"- {err}")
+            parts.append("")
+
+        if active:
+            # Group by severity
+            by_sev: dict[str, list] = {}
+            for f in active:
+                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")
+                    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.")
+
+        if suppressed:
+            parts.append(f"\n*Suppressed: {len(suppressed)}*")
+            for f in suppressed:
+                reason = f" ({f.suppression_reason})" if f.suppression_reason else ""
+                parts.append(f"- {f.assertion_id}: {f.location}{reason}")
+
+        parts.append("")
+
+    # Review checklists from skills
+    if skill_content:
+        parts.append("---\n")
+        parts.append("## Review Checklists\n")
+        for skill_name, content in skill_content.items():
+            parts.append(f"### {skill_name}\n")
+            parts.append(content)
+            parts.append("")
+
+    # Knowledge reference
+    if knowledge_content:
+        parts.append("---\n")
+        parts.append("## Principles Reference\n")
+        for filename, content in sorted(knowledge_content.items()):
+            parts.append(f"### {filename}\n")
+            parts.append(content)
+            parts.append("")
+
+    return "\n".join(parts)
+
+
+def _handle_review(arguments: dict[str, Any]) -> list[TextContent]:
+    """Handle unified review tool."""
+    import os
+
+    path = arguments.get("path")
+    mode = arguments.get("mode")
+    base = arguments.get("base")
+    include_context = arguments.get("include_context", False)
+    skills_override = arguments.get("skills")
+    include_skills = arguments.get("include_skills", True)
+    include_knowledge = arguments.get("include_knowledge", True)
+    enforce = arguments.get("enforce", True)
+
+    # Determine if this is path-based or git-based review
+    git_context: GitContext | None = None
+    changed_files: list[str] = []
+
+    if mode:
+        # Git-based review
+        repo_path = path if path else os.getcwd()
+        root_result = get_repo_root(repo_path)
+        if root_result.is_err:
+            return [TextContent(type="text", text=f"Error: {root_result.error}")]
+        repo_path = root_result.value
+
+        # Get git context based on mode
+        if mode == "staged":
+            context_result = get_staged_changes(repo_path)
+        elif mode == "unstaged":
+            context_result = get_unstaged_changes(repo_path)
+        elif mode == "branch":
+            base_branch = base if base else "main"
+            context_result = get_branch_diff(repo_path, base_branch)
+        elif mode == "commits":
+            try:
+                count = int(base) if base else 1
+            except ValueError:
+                return [TextContent(type="text", text=f"Error: Invalid commit count '{base}'")]
+            context_result = get_recent_commits(repo_path, count)
+        else:
+            return [TextContent(type="text", text=f"Error: Unknown mode '{mode}'")]
+
+        if context_result.is_err:
+            return [TextContent(type="text", text=f"Error: {context_result.error}")]
+
+        git_context = context_result.value
+
+        if not git_context.changes:
+            if mode == "staged":
+                return [TextContent(type="text", text="No changes to review. Stage files with `git add` first.")]
+            elif mode == "unstaged":
+                return [TextContent(type="text", text="No unstaged changes to review.")]
+            else:
+                return [TextContent(type="text", text="No changes found.")]
+
+        changed_files = get_changed_files(git_context)
+        if not changed_files:
+            return [TextContent(type="text", text="No files to analyze (only deletions).")]
+
+    elif not path:
+        return [TextContent(type="text", text="Error: Either 'path' or 'mode' is required.")]
+
+    # Detect domains and run analysis
+    all_findings: list[ToolFinding] = []
+    tool_errors: list[str] = []
+    domains_detected: set[Domain] = set()
+    all_domain_tags: set[str] = set()
+
+    if git_context:
+        # Git mode: analyze each changed file
+        repo_path = get_repo_root(path if path else os.getcwd()).value
+        for file_path in changed_files:
+            full_path = f"{repo_path}/{file_path}"
+            domain, domain_tags = detect_domain(file_path)
+            domains_detected.add(domain)
+            all_domain_tags.update(domain_tags)
+
+            findings, errors = run_static_analysis(full_path, domain, domain_tags)
+            all_findings.extend(findings)
+            tool_errors.extend([f"{e} ({file_path})" for e in errors])
+
+        # Filter findings to changed lines
+        all_findings = filter_findings_to_changes(all_findings, git_context, include_context)
+    else:
+        # Path mode: analyze the path directly
+        domain, domain_tags = detect_domain(path)
+        domains_detected.add(domain)
+        all_domain_tags.update(domain_tags)
+
+        findings, errors = run_static_analysis(path, domain, domain_tags)
+        all_findings.extend(findings)
+        tool_errors.extend(errors)
+
+    # Deduplicate findings
+    all_findings = deduplicate_findings(all_findings)
+
+    # Run pattern assertions
+    enforcement_findings = []
+    enforcement_errors: list[str] = []
+    assertions_checked = 0
+    assertions_skipped = 0
+
+    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)
+            )
+        elif path:
+            enforcement_findings, enforcement_errors, assertions_checked, assertions_skipped = (
+                run_enforcement(path)
+            )
+
+    # Compute severity summary
+    severity_counts = compute_severity_counts(all_findings)
+
+    # Load skills and knowledge
+    matched_skills: list[tuple[str, list[str]]] | None = None
+    skill_content: dict[str, str] | None = None
+    knowledge_files: set[str] | None = None
+    knowledge_content: dict[str, str] | None = None
+
+    if include_skills or include_knowledge:
+        primary_domain = next(iter(domains_detected)) if domains_detected else Domain.UNKNOWN
+        matched, s_content, k_files, k_content = load_skills_and_knowledge(
+            primary_domain, list(all_domain_tags), skills_override
+        )
+        if include_skills:
+            matched_skills = matched
+            skill_content = s_content
+        if include_knowledge:
+            knowledge_files = k_files
+            knowledge_content = k_content
+
+    # Format output
+    output = _format_review_output(
+        path,
+        git_context,
+        list(all_domain_tags) if all_domain_tags else ["unknown"],
+        severity_counts,
+        all_findings,
+        tool_errors,
+        matched_skills,
+        skill_content,
+        knowledge_files,
+        knowledge_content,
+        enforcement_findings if enforce else None,
+        enforcement_errors if enforce else None,
+        assertions_checked,
+        assertions_skipped,
+    )
+
+    return [TextContent(type="text", text=output)]
+
+
 def _handle_get_principles(arguments: dict[str, Any]) -> list[TextContent]:
     """Handle get_principles tool."""
     topic = arguments.get("topic")
@@ -396,89 +719,13 @@ def _handle_check_tools(arguments: dict[str, Any]) -> list[TextContent]:
     return [TextContent(type="text", text="\n".join(parts))]
 
 
-def _detect_domain_for_file(path: str) -> tuple[Domain, list[str]]:
-    """Detect domain from a single file path.
-
-    Returns (domain, list of domain tags for skill matching).
-    """
-    if path.endswith(".sol"):
-        return Domain.SMART_CONTRACT, ["solidity", "smart_contract", "web3"]
-    elif path.endswith(".vy"):
-        return Domain.SMART_CONTRACT, ["vyper", "smart_contract", "web3"]
-    elif path.endswith(".py"):
-        return Domain.BACKEND, ["python", "backend"]
-    elif path.endswith((".ts", ".tsx")):
-        return Domain.FRONTEND, ["typescript", "frontend"]
-    elif path.endswith((".js", ".jsx")):
-        return Domain.FRONTEND, ["javascript", "frontend"]
-    elif path.endswith(".go"):
-        return Domain.BACKEND, ["go", "backend"]
-    elif path.endswith(".rs"):
-        return Domain.BACKEND, ["rust", "backend"]
-    elif path.endswith((".tf", ".yaml", ".yml")):
-        return Domain.INFRASTRUCTURE, ["infrastructure", "devops"]
-    else:
-        return Domain.UNKNOWN, []
-
-
-def _detect_domain(path: str) -> tuple[Domain, list[str]]:
-    """Detect domain from file or directory path.
-
-    For directories, scans contained files and aggregates domains.
-    Returns (primary_domain, list of all domain tags).
-    """
-    from collections import Counter
-    from pathlib import Path
-
-    p = Path(path)
-
-    # Single file - use direct detection
-    if p.is_file():
-        return _detect_domain_for_file(path)
-
-    # Directory - scan and aggregate
-    if not p.is_dir():
-        return Domain.UNKNOWN, ["unknown"]
-
-    domain_counts: Counter[Domain] = Counter()
-    all_tags: set[str] = set()
-
-    # Scan files in directory (up to 1000 to avoid huge repos)
-    file_count = 0
-    max_files = 1000
-
-    for file_path in p.rglob("*"):
-        if file_count >= max_files:
-            break
-        if not file_path.is_file():
-            continue
-        # Skip hidden files and common non-code directories
-        if any(part.startswith(".") for part in file_path.parts):
-            continue
-        if any(part in ("node_modules", "__pycache__", "venv", ".venv", "dist", "build") for part in file_path.parts):
-            continue
-
-        domain, tags = _detect_domain_for_file(str(file_path))
-        if domain != Domain.UNKNOWN:
-            domain_counts[domain] += 1
-            all_tags.update(tags)
-        file_count += 1
-
-    # Return most common domain, or UNKNOWN if none found
-    if not domain_counts:
-        return Domain.UNKNOWN, ["unknown"]
-
-    primary_domain = domain_counts.most_common(1)[0][0]
-    return primary_domain, sorted(all_tags) if all_tags else ["unknown"]
-
-
 def _handle_quick_review(arguments: dict[str, Any]) -> list[TextContent]:
     """Handle quick_review tool - returns findings with domain metadata."""
     path = arguments.get("path", "")
     tools = arguments.get("tools")
 
     # Internal domain detection
-    domain, domain_tags = _detect_domain(path)
+    domain, domain_tags = detect_domain(path)
 
     # Select tools based on domain
     if domain == Domain.SMART_CONTRACT:
@@ -531,7 +778,7 @@ def _handle_quick_review(arguments: dict[str, Any]) -> list[TextContent]:
             tool_results.append(f"## Bandit\nError: {result.error}")
 
     # Deduplicate findings
-    all_findings = _deduplicate_findings(all_findings)
+    all_findings = deduplicate_findings(all_findings)
 
     # Compute severity summary
     severity_counts: dict[str, int] = {}
@@ -550,65 +797,15 @@ def _handle_quick_review(arguments: dict[str, Any]) -> list[TextContent]:
     return [TextContent(type="text", text="\n".join(output_parts))]
 
 
-def _filter_findings_to_changes(
-    findings: list[ToolFinding],
-    context: GitContext,
-    include_context: bool = False,
-) -> list[ToolFinding]:
-    """Filter findings to only those in changed lines."""
-    # Build a lookup of file -> changed line ranges
-    changed_ranges: dict[str, list[tuple[int, int]]] = {}
-    for change in context.changes:
-        if change.status == "D":
-            continue  # Skip deleted files
-        ranges = [(r.start, r.end) for r in change.added_lines]
-        changed_ranges[change.path] = ranges
-
-    context_lines = 5 if include_context else 0
-    filtered: list[ToolFinding] = []
-
-    for finding in findings:
-        # Parse location: "path:line" or "path:line:col"
-        parts = finding.location.split(":")
-        if len(parts) < 2:
-            continue
-
-        file_path = parts[0]
-        try:
-            line_num = int(parts[1])
-        except ValueError:
-            continue
-
-        # Check if file is in changes
-        # Handle both absolute and relative paths
-        matching_file = None
-        for changed_file in changed_ranges:
-            if file_path.endswith(changed_file) or changed_file.endswith(file_path):
-                matching_file = changed_file
-                break
-
-        if not matching_file:
-            continue
-
-        # Check if line is in changed ranges
-        ranges = changed_ranges[matching_file]
-        in_range = False
-        for start, end in ranges:
-            if start - context_lines <= line_num <= end + context_lines:
-                in_range = True
-                break
-
-        if in_range:
-            filtered.append(finding)
-
-    return filtered
-
-
 def _format_change_review(
     context: GitContext,
     findings: list[ToolFinding],
     severity_counts: dict[str, int],
     tool_errors: list[str] | None = None,
+    matched_skills: list[tuple[str, list[str]]] | None = None,
+    skill_content: dict[str, str] | None = None,
+    knowledge_files: set[str] | None = None,
+    knowledge_content: dict[str, str] | None = None,
 ) -> str:
     """Format change review output."""
     parts: list[str] = ["# Change Review\n"]
@@ -642,6 +839,19 @@ def _format_change_review(
             parts.append(f"- {msg}")
         parts.append("")
 
+    # Applicable skills
+    if matched_skills:
+        parts.append("## Applicable Skills\n")
+        for skill_name, triggers in matched_skills:
+            parts.append(f"- **{skill_name}**: matched on {', '.join(triggers)}")
+        parts.append("")
+
+    # Knowledge loaded
+    if knowledge_files:
+        parts.append("## Knowledge Loaded\n")
+        parts.append(f"Files: {', '.join(sorted(knowledge_files))}")
+        parts.append("")
+
     # Tool errors (if any)
     if tool_errors:
         parts.append("## Tool Errors\n")
@@ -657,6 +867,25 @@ def _format_change_review(
     else:
         parts.append("## Findings in Changed Code\n")
         parts.append("No issues found in changed code.")
+    parts.append("")
+
+    # Review checklists from skills
+    if skill_content:
+        parts.append("---\n")
+        parts.append("## Review Checklists\n")
+        for skill_name, content in skill_content.items():
+            parts.append(f"### {skill_name}\n")
+            parts.append(content)
+            parts.append("")
+
+    # Knowledge reference
+    if knowledge_content:
+        parts.append("---\n")
+        parts.append("## Principles Reference\n")
+        for filename, content in sorted(knowledge_content.items()):
+            parts.append(f"### {filename}\n")
+            parts.append(content)
+            parts.append("")
 
     return "\n".join(parts)
 
@@ -716,12 +945,16 @@ def _handle_review_changes(arguments: dict[str, Any]) -> list[TextContent]:
     # Run analysis on changed files
     all_findings: list[ToolFinding] = []
     tool_errors: list[str] = []
+    domains_detected: set[Domain] = set()
+    all_domain_tags: set[str] = set()
 
     for file_path in changed_files:
         full_path = f"{repo_path}/{file_path}"
 
         # Detect domain for this file
-        domain, domain_tags = _detect_domain(file_path)
+        domain, domain_tags = detect_domain(file_path)
+        domains_detected.add(domain)
+        all_domain_tags.update(domain_tags)
 
         # Select tools based on domain
         if domain == Domain.SMART_CONTRACT:
@@ -764,10 +997,10 @@ def _handle_review_changes(arguments: dict[str, Any]) -> list[TextContent]:
                 tool_errors.append(f"bandit ({file_path}): {result.error}")
 
     # Filter findings to changed lines
-    filtered_findings = _filter_findings_to_changes(all_findings, context, include_context)
+    filtered_findings = filter_findings_to_changes(all_findings, context, include_context)
 
     # Deduplicate findings
-    filtered_findings = _deduplicate_findings(filtered_findings)
+    filtered_findings = deduplicate_findings(filtered_findings)
 
     # Compute severity summary
     severity_counts: dict[str, int] = {}
@@ -775,62 +1008,63 @@ def _handle_review_changes(arguments: dict[str, Any]) -> list[TextContent]:
         sev = f.severity.value
         severity_counts[sev] = severity_counts.get(sev, 0) + 1
 
+    # Match skills and load knowledge based on detected domains
+    from crucible.knowledge.loader import load_knowledge_file
+    from crucible.skills.loader import (
+        get_knowledge_for_skills,
+        load_skill,
+        match_skills_for_domain,
+    )
+
+    primary_domain = next(iter(domains_detected)) if domains_detected else Domain.UNKNOWN
+    matched_skills = match_skills_for_domain(
+        primary_domain, list(all_domain_tags), override=None
+    )
+
+    skill_names = [name for name, _ in matched_skills]
+    skill_content: dict[str, str] = {}
+    for skill_name, _triggers in matched_skills:
+        result = load_skill(skill_name)
+        if result.is_ok:
+            _, content = result.value
+            skill_content[skill_name] = content
+
+    knowledge_files = get_knowledge_for_skills(skill_names)
+    knowledge_content: dict[str, str] = {}
+    for filename in knowledge_files:
+        result = load_knowledge_file(filename)
+        if result.is_ok:
+            knowledge_content[filename] = result.value
+
     # Format output
-    output = _format_change_review(context, filtered_findings, severity_counts, tool_errors)
+    output = _format_change_review(
+        context,
+        filtered_findings,
+        severity_counts,
+        tool_errors,
+        matched_skills,
+        skill_content,
+        knowledge_files,
+        knowledge_content,
+    )
     return [TextContent(type="text", text=output)]
 
 
 def _handle_full_review(arguments: dict[str, Any]) -> list[TextContent]:
-    """Handle full_review tool - comprehensive code review."""
+    """Handle full_review tool - comprehensive code review.
+
+    DEPRECATED: Use _handle_review with path parameter instead.
+    """
+    from crucible.review.core import run_static_analysis
+
     path = arguments.get("path", "")
     skills_override = arguments.get("skills")
-    # include_sage is accepted but not yet implemented
-    # _ = arguments.get("include_sage", True)
 
     # 1. Detect domain
-    domain, domain_tags = _detect_domain(path)
+    domain, domain_tags = detect_domain(path)
 
-    # 2. Run static analysis (reuse quick_review logic)
-    if domain == Domain.SMART_CONTRACT:
-        default_tools = ["slither", "semgrep"]
-    elif domain == Domain.BACKEND and "python" in domain_tags:
-        default_tools = ["ruff", "bandit", "semgrep"]
-    elif domain == Domain.FRONTEND:
-        default_tools = ["semgrep"]
-    else:
-        default_tools = ["semgrep"]
-
-    all_findings: list[ToolFinding] = []
-    tool_errors: list[str] = []
-
-    if "semgrep" in default_tools:
-        config = get_semgrep_config(domain)
-        result = delegate_semgrep(path, config)
-        if result.is_ok:
-            all_findings.extend(result.value)
-        elif result.is_err:
-            tool_errors.append(f"semgrep: {result.error}")
-
-    if "ruff" in default_tools:
-        result = delegate_ruff(path)
-        if result.is_ok:
-            all_findings.extend(result.value)
-        elif result.is_err:
-            tool_errors.append(f"ruff: {result.error}")
-
-    if "slither" in default_tools:
-        result = delegate_slither(path)
-        if result.is_ok:
-            all_findings.extend(result.value)
-        elif result.is_err:
-            tool_errors.append(f"slither: {result.error}")
-
-    if "bandit" in default_tools:
-        result = delegate_bandit(path)
-        if result.is_ok:
-            all_findings.extend(result.value)
-        elif result.is_err:
-            tool_errors.append(f"bandit: {result.error}")
+    # 2. Run static analysis using shared core function
+    all_findings, tool_errors = run_static_analysis(path, domain, domain_tags)
 
     # 3. Match applicable skills
     matched_skills = match_skills_for_domain(domain, domain_tags, skills_override)
@@ -864,13 +1098,10 @@ def _handle_full_review(arguments: dict[str, Any]) -> list[TextContent]:
     )
 
     # 7. Deduplicate findings
-    all_findings = _deduplicate_findings(all_findings)
+    all_findings = deduplicate_findings(all_findings)
 
     # 8. Compute severity summary
-    severity_counts: dict[str, int] = {}
-    for f in all_findings:
-        sev = f.severity.value
-        severity_counts[sev] = severity_counts.get(sev, 0) + 1
+    severity_counts = compute_severity_counts(all_findings)
 
     # 8. Build result
     review_result = FullReviewResult(
@@ -937,16 +1168,20 @@ def _handle_full_review(arguments: dict[str, Any]) -> list[TextContent]:
 async def call_tool(name: str, arguments: dict[str, Any]) -> list[TextContent]:
     """Handle tool calls."""
     handlers = {
+        # Unified review tool
+        "review": _handle_review,
+        # Deprecated tools (kept for backwards compatibility)
+        "quick_review": _handle_quick_review,
+        "full_review": _handle_full_review,
+        "review_changes": _handle_review_changes,
+        # Other tools
         "get_principles": _handle_get_principles,
         "load_knowledge": _handle_load_knowledge,
         "delegate_semgrep": _handle_delegate_semgrep,
         "delegate_ruff": _handle_delegate_ruff,
         "delegate_slither": _handle_delegate_slither,
         "delegate_bandit": _handle_delegate_bandit,
-        "quick_review": _handle_quick_review,
         "check_tools": _handle_check_tools,
-        "review_changes": _handle_review_changes,
-        "full_review": _handle_full_review,
     }
 
     handler = handlers.get(name)