crucible-mcp 1.1.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

crucible/cli.py

@@ -8,6 +8,7 @@ import sys
 from pathlib import Path
 
 from crucible.enforcement.models import ComplianceConfig
+from crucible.ignore import load_ignore_spec
 
 # Skills directories
 SKILLS_BUNDLED = Path(__file__).parent / "skills"
@@ -541,12 +542,12 @@ def _cmd_review_no_git(args: argparse.Namespace, path: str) -> int:
     if path_obj.is_file():
         files_to_analyze = [str(path_obj)]
     else:
-        # Recursively find files, respecting common ignores
-        ignore_dirs = {".git", "__pycache__", "node_modules", ".venv", "venv", "build", "dist"}
+        # Load ignore patterns (.crucibleignore + defaults)
+        ignore_spec = load_ignore_spec(path_obj)
         for file_path in path_obj.rglob("*"):
             if file_path.is_file():
-                # Skip ignored directories
-                if any(ignored in file_path.parts for ignored in ignore_dirs):
+                rel_path = file_path.relative_to(path_obj)
+                if ignore_spec.is_ignored(str(rel_path), is_dir=False):
                     continue
                 files_to_analyze.append(str(file_path))
 
@@ -1910,6 +1911,113 @@ def cmd_config_show(args: argparse.Namespace) -> int:
     return 0
 
 
+# --- Ignore commands ---
+
+
+def cmd_ignore_show(args: argparse.Namespace) -> int:
+    """Show active ignore patterns and their sources."""
+    from crucible.ignore import (
+        DEFAULT_PATTERNS,
+        IGNORE_PROJECT,
+        IGNORE_USER,
+        clear_ignore_cache,
+        load_ignore_spec,
+    )
+
+    clear_ignore_cache()
+    spec = load_ignore_spec()
+
+    print("Ignore patterns (files/directories excluded from review)")
+    print()
+
+    # Show default patterns
+    print(f"Defaults ({len(DEFAULT_PATTERNS)} patterns):")
+    print("  node_modules/, .git/, __pycache__/, .venv/, dist/, build/,")
+    print("  .next/, .nuxt/, package-lock.json, yarn.lock, *.log, ...")
+    print()
+
+    # Show user patterns
+    print("User (~/.claude/crucible/.crucibleignore):")
+    if IGNORE_USER.exists():
+        user_content = IGNORE_USER.read_text().strip()
+        for line in user_content.splitlines()[:5]:
+            print(f"  {line}")
+        lines = user_content.splitlines()
+        if len(lines) > 5:
+            print(f"  ... and {len(lines) - 5} more")
+    else:
+        print("  (not set)")
+    print()
+
+    # Show project patterns
+    print("Project (.crucible/.crucibleignore):")
+    if IGNORE_PROJECT.exists():
+        proj_content = IGNORE_PROJECT.read_text().strip()
+        for line in proj_content.splitlines()[:5]:
+            print(f"  {line}")
+        lines = proj_content.splitlines()
+        if len(lines) > 5:
+            print(f"  ... and {len(lines) - 5} more")
+    else:
+        print("  (not set)")
+    print()
+
+    print(f"Total: {len(spec.patterns)} patterns active (source: {spec.source})")
+    return 0
+
+
+def cmd_ignore_init(args: argparse.Namespace) -> int:
+    """Initialize a project .crucibleignore file."""
+    from crucible.ignore import IGNORE_PROJECT
+
+    # Create .crucible directory if needed
+    crucible_dir = Path(".crucible")
+    crucible_dir.mkdir(exist_ok=True)
+
+    if IGNORE_PROJECT.exists() and not args.force:
+        print(f"✗ {IGNORE_PROJECT} already exists (use --force to overwrite)")
+        return 1
+
+    template = """# Project-specific ignore patterns for Crucible
+# These are in addition to the built-in defaults (node_modules, .git, etc.)
+# Syntax: gitignore-style patterns
+
+# Large generated files
+# generated/
+
+# Vendor directories not in defaults
+# third_party/
+
+# Project-specific build outputs
+# .output/
+
+# Test fixtures that shouldn't be reviewed
+# fixtures/large-*.json
+"""
+    IGNORE_PROJECT.write_text(template)
+    print(f"✓ Created {IGNORE_PROJECT}")
+    print("\nEdit this file to add project-specific ignore patterns.")
+    return 0
+
+
+def cmd_ignore_test(args: argparse.Namespace) -> int:
+    """Test if a path would be ignored."""
+    from crucible.ignore import clear_ignore_cache, load_ignore_spec
+
+    clear_ignore_cache()
+    spec = load_ignore_spec()
+
+    path = args.path
+    is_dir = Path(path).is_dir() if Path(path).exists() else path.endswith("/")
+
+    if spec.is_ignored(path, is_dir=is_dir):
+        print(f"✓ {path} would be IGNORED")
+        return 0
+    else:
+        print(f"✗ {path} would be INCLUDED in review")
+        return 1
+
+
 # --- Main ---
 
 
@@ -2217,6 +2325,37 @@ def main() -> int:
         help="Show current configuration"
     )
 
+    # === ignore command ===
+    ignore_parser = subparsers.add_parser("ignore", help="Manage file ignore patterns")
+    ignore_sub = ignore_parser.add_subparsers(dest="ignore_command")
+
+    # ignore show
+    ignore_sub.add_parser(
+        "show",
+        help="Show active ignore patterns"
+    )
+
+    # ignore init
+    ignore_init_parser = ignore_sub.add_parser(
+        "init",
+        help="Create a project .crucibleignore file"
+    )
+    ignore_init_parser.add_argument(
+        "--force", "-f",
+        action="store_true",
+        help="Overwrite existing file"
+    )
+
+    # ignore test
+    ignore_test_parser = ignore_sub.add_parser(
+        "test",
+        help="Test if a path would be ignored"
+    )
+    ignore_test_parser.add_argument(
+        "path",
+        help="Path to test"
+    )
+
     args = parser.parse_args()
 
     if args.command == "init":
@@ -2296,6 +2435,16 @@ def main() -> int:
         else:
             config_parser.print_help()
             return 0
+    elif args.command == "ignore":
+        if args.ignore_command == "show":
+            return cmd_ignore_show(args)
+        elif args.ignore_command == "init":
+            return cmd_ignore_init(args)
+        elif args.ignore_command == "test":
+            return cmd_ignore_test(args)
+        else:
+            ignore_parser.print_help()
+            return 0
     else:
         # Default help
         print("crucible - Code review orchestration\n")

crucible/ignore.py

@@ -0,0 +1,294 @@
+"""File ignore patterns for Crucible.
+
+Supports .crucibleignore files with gitignore-style syntax.
+
+Cascade priority (first found wins):
+1. .crucible/.crucibleignore (project)
+2. ~/.claude/crucible/.crucibleignore (user)
+3. Built-in defaults
+
+Pattern syntax (subset of gitignore):
+- Standard glob patterns: *.log, build/
+- Directory markers: node_modules/ matches directory anywhere
+- Negation: !important.log (include despite earlier exclusion)
+- Comments: # this is a comment
+- Blank lines are ignored
+"""
+
+from dataclasses import dataclass, field
+from fnmatch import fnmatch
+from functools import lru_cache
+from pathlib import Path
+
+# Default patterns - always applied as base
+DEFAULT_PATTERNS = [
+    # Version control
+    ".git/",
+    ".hg/",
+    ".svn/",
+    # Dependencies
+    "node_modules/",
+    "vendor/",
+    "bower_components/",
+    # Python
+    "__pycache__/",
+    "*.pyc",
+    "*.pyo",
+    ".venv/",
+    "venv/",
+    ".env/",
+    "env/",
+    ".tox/",
+    ".nox/",
+    ".pytest_cache/",
+    ".mypy_cache/",
+    ".ruff_cache/",
+    "*.egg-info/",
+    # Build outputs
+    "build/",
+    "dist/",
+    "out/",
+    "target/",
+    "_build/",
+    # IDE/Editor
+    ".idea/",
+    ".vscode/",
+    "*.swp",
+    "*.swo",
+    "*~",
+    ".DS_Store",
+    # Coverage/test artifacts
+    "coverage/",
+    ".coverage",
+    "htmlcov/",
+    ".nyc_output/",
+    # Logs
+    "*.log",
+    "logs/",
+    # Lock files (large, not useful to review)
+    "package-lock.json",
+    "yarn.lock",
+    "pnpm-lock.yaml",
+    "poetry.lock",
+    "Cargo.lock",
+    "composer.lock",
+    "Gemfile.lock",
+    # Other common excludes
+    ".next/",
+    ".nuxt/",
+    ".output/",
+    ".cache/",
+    ".parcel-cache/",
+    ".turbo/",
+]
+
+# Ignore file locations (cascade priority)
+IGNORE_PROJECT = Path(".crucible") / ".crucibleignore"
+IGNORE_USER = Path.home() / ".claude" / "crucible" / ".crucibleignore"
+
+
+@dataclass(frozen=True)
+class IgnorePattern:
+    """A parsed ignore pattern."""
+
+    pattern: str
+    negated: bool = False
+    directory_only: bool = False
+
+    def matches(self, path: str, is_dir: bool = False) -> bool:
+        """Check if this pattern matches the given path.
+
+        Args:
+            path: Relative path to check (forward slashes)
+            is_dir: Whether the path is a directory
+
+        Returns:
+            True if pattern matches
+        """
+        # Normalize pattern for matching
+        pattern = self.pattern.rstrip("/")
+
+        # If pattern contains /, match against full path
+        if "/" in pattern:
+            if fnmatch(path, pattern) or fnmatch(path, f"**/{pattern}"):
+                # For directory-only patterns on a file, only match if path is under that dir
+                if self.directory_only and not is_dir:
+                    # Check if pattern matches a parent directory
+                    return f"{pattern}/" in path or path.startswith(f"{pattern}/")
+                return True
+            return False
+
+        # Otherwise, match against any path component
+        parts = path.split("/")
+        for i, part in enumerate(parts):
+            if fnmatch(part, pattern):
+                if self.directory_only:
+                    # Directory-only patterns match if:
+                    # 1. This component is not the last (so it's a directory in the path), OR
+                    # 2. The path itself is a directory
+                    if i < len(parts) - 1 or is_dir:
+                        return True
+                else:
+                    return True
+
+        return False
+
+
+@dataclass
+class IgnoreSpec:
+    """Collection of ignore patterns with match logic."""
+
+    patterns: list[IgnorePattern] = field(default_factory=list)
+    source: str = "default"
+
+    def is_ignored(self, path: str | Path, is_dir: bool = False) -> bool:
+        """Check if a path should be ignored.
+
+        Patterns are evaluated in order. Later patterns can override earlier ones.
+        Negated patterns (starting with !) un-ignore previously ignored paths.
+
+        Args:
+            path: Path to check (relative to project root)
+            is_dir: Whether the path is a directory
+
+        Returns:
+            True if the path should be ignored
+        """
+        if isinstance(path, Path):
+            path = str(path)
+
+        # Normalize path separators and strip ./ prefix (but not lone .)
+        path = path.replace("\\", "/")
+        while path.startswith("./"):
+            path = path[2:]
+
+        ignored = False
+        for pattern in self.patterns:
+            if pattern.matches(path, is_dir):
+                ignored = not pattern.negated
+
+        return ignored
+
+    def filter_paths(self, paths: list[Path], base: Path | None = None) -> list[Path]:
+        """Filter a list of paths, removing ignored ones.
+
+        Args:
+            paths: List of paths to filter
+            base: Base path for computing relative paths
+
+        Returns:
+            List of non-ignored paths
+        """
+        result = []
+        for path in paths:
+            rel_path = path.relative_to(base) if base else path
+            is_dir = path.is_dir()
+            if not self.is_ignored(str(rel_path), is_dir):
+                result.append(path)
+        return result
+
+
+def parse_ignore_file(content: str) -> list[IgnorePattern]:
+    """Parse a .crucibleignore file into patterns.
+
+    Args:
+        content: File content
+
+    Returns:
+        List of parsed patterns
+    """
+    patterns = []
+
+    for line in content.splitlines():
+        # Strip whitespace
+        line = line.strip()
+
+        # Skip empty lines and comments
+        if not line or line.startswith("#"):
+            continue
+
+        # Check for negation
+        negated = False
+        if line.startswith("!"):
+            negated = True
+            line = line[1:]
+
+        # Check for directory-only marker
+        directory_only = line.endswith("/")
+
+        patterns.append(
+            IgnorePattern(
+                pattern=line,
+                negated=negated,
+                directory_only=directory_only,
+            )
+        )
+
+    return patterns
+
+
+def _load_ignore_file(path: Path) -> list[IgnorePattern]:
+    """Load patterns from an ignore file."""
+    try:
+        content = path.read_text()
+        return parse_ignore_file(content)
+    except OSError:
+        return []
+
+
+@lru_cache(maxsize=1)
+def _get_default_patterns() -> list[IgnorePattern]:
+    """Get default patterns (cached)."""
+    return parse_ignore_file("\n".join(DEFAULT_PATTERNS))
+
+
+def load_ignore_spec(project_root: Path | None = None) -> IgnoreSpec:
+    """Load ignore specification with cascade resolution.
+
+    Args:
+        project_root: Project root directory (defaults to cwd)
+
+    Returns:
+        IgnoreSpec with all applicable patterns
+    """
+    if project_root is None:
+        project_root = Path.cwd()
+
+    patterns: list[IgnorePattern] = []
+    source = "default"
+
+    # Start with defaults
+    patterns.extend(_get_default_patterns())
+
+    # Layer user patterns (if exists)
+    if IGNORE_USER.exists():
+        patterns.extend(_load_ignore_file(IGNORE_USER))
+        source = "user"
+
+    # Layer project patterns (highest priority)
+    project_ignore = project_root / IGNORE_PROJECT
+    if project_ignore.exists():
+        patterns.extend(_load_ignore_file(project_ignore))
+        source = "project"
+
+    return IgnoreSpec(patterns=patterns, source=source)
+
+
+def should_ignore(path: str | Path, project_root: Path | None = None) -> bool:
+    """Convenience function to check if a path should be ignored.
+
+    Args:
+        path: Path to check
+        project_root: Project root for loading ignore spec
+
+    Returns:
+        True if path should be ignored
+    """
+    spec = load_ignore_spec(project_root)
+    is_dir = Path(path).is_dir() if isinstance(path, str) else path.is_dir()
+    return spec.is_ignored(path, is_dir)
+
+
+def clear_ignore_cache() -> None:
+    """Clear the ignore pattern cache. Useful for testing."""
+    _get_default_patterns.cache_clear()

crucible/knowledge/loader.py

@@ -247,14 +247,17 @@ def get_custom_knowledge_files() -> set[str]:
 
 
 def load_all_knowledge(
-    include_bundled: bool = False,
+    include_bundled: bool = True,
     filenames: set[str] | None = None,
 ) -> tuple[list[str], str]:
     """Load multiple knowledge files.
 
+    Knowledge follows cascade priority: project > user > bundled.
+    Project/user files override bundled files with the same name.
+
     Args:
-        include_bundled: If True, include bundled knowledge files
-        filenames: Specific files to load (if None, loads based on include_bundled)
+        include_bundled: If True, include bundled knowledge files (default: True)
+        filenames: Specific files to load (if None, loads all from cascade)
 
     Returns:
         Tuple of (list of loaded filenames, combined content)

crucible/models.py

@@ -61,16 +61,3 @@ DOMAIN_HEURISTICS: dict[Domain, dict[str, list[str]]] = {
 }
 
 
-@dataclass(frozen=True)
-class FullReviewResult:
-    """Result from full_review tool."""
-
-    domains_detected: tuple[str, ...]
-    severity_summary: dict[str, int]
-    findings: tuple[ToolFinding, ...]
-    applicable_skills: tuple[str, ...]
-    skill_triggers_matched: dict[str, tuple[str, ...]]
-    principles_loaded: tuple[str, ...]
-    principles_content: str
-    sage_knowledge: str | None = None
-    sage_query_used: str | None = None

crucible/review/core.py

@@ -2,10 +2,12 @@
 
 from __future__ import annotations
 
+import os
 from collections import Counter
 from pathlib import Path
 
 from crucible.enforcement.models import BudgetState, ComplianceConfig
+from crucible.ignore import load_ignore_spec
 from crucible.models import Domain, Severity, ToolFinding
 from crucible.tools.delegation import (
     delegate_bandit,
@@ -64,17 +66,16 @@ def detect_domain(path: str) -> tuple[Domain, list[str]]:
     # Scan files in directory (up to 1000 to avoid huge repos)
     file_count = 0
     max_files = 1000
-    skip_dirs = {"node_modules", "__pycache__", "venv", ".venv", "dist", "build"}
+    ignore_spec = load_ignore_spec(p)
 
     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 skip_dirs for part in file_path.parts):
+        # Use .crucibleignore patterns
+        rel_path = file_path.relative_to(p)
+        if ignore_spec.is_ignored(str(rel_path), is_dir=False):
             continue
 
         domain, tags = detect_domain_for_file(str(file_path))
@@ -189,6 +190,46 @@ def deduplicate_findings(findings: list[ToolFinding]) -> list[ToolFinding]:
     return list(seen.values())
 
 
+def filter_ignored_findings(
+    findings: list[ToolFinding],
+    base_path: str | Path | None = None,
+) -> list[ToolFinding]:
+    """Filter out findings from ignored paths.
+
+    Args:
+        findings: All findings from analysis
+        base_path: Base path for loading ignore spec (defaults to cwd)
+
+    Returns:
+        Findings that are not in ignored paths
+    """
+    if base_path is None:
+        base_path = Path.cwd()
+    elif isinstance(base_path, str):
+        base_path = Path(base_path)
+
+    spec = load_ignore_spec(base_path)
+    filtered: list[ToolFinding] = []
+
+    for finding in findings:
+        # Parse location: "path:line" or "path:line:col" or just "path"
+        parts = finding.location.split(":")
+        file_path = parts[0]
+
+        # Make path relative if it's absolute
+        try:
+            path_obj = Path(file_path)
+            if path_obj.is_absolute():
+                file_path = str(path_obj.relative_to(base_path))
+        except ValueError:
+            pass  # Not under base_path, keep as-is
+
+        if not spec.is_ignored(file_path, is_dir=False):
+            filtered.append(finding)
+
+    return filtered
+
+
 def filter_findings_to_changes(
     findings: list[ToolFinding],
     context: GitContext,
@@ -330,7 +371,6 @@ def run_enforcement(
     Returns:
         (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
@@ -421,10 +461,23 @@ def run_enforcement(
 
     elif os.path.isdir(path):
         # Directory - collect all files for batch processing
-        for root, _, files in os.walk(path):
+        ignore_spec = load_ignore_spec(Path(path))
+        for root, dirs, files in os.walk(path):
+            # Filter out ignored directories in-place (modifies os.walk behavior)
+            rel_root = os.path.relpath(root, path)
+            dirs[:] = [
+                d for d in dirs
+                if not ignore_spec.is_ignored(
+                    os.path.join(rel_root, d) if rel_root != "." else d,
+                    is_dir=True
+                )
+            ]
             for fname in files:
                 fpath = os.path.join(root, fname)
                 rel_path = os.path.relpath(fpath, path)
+                # Skip ignored files
+                if ignore_spec.is_ignored(rel_path, is_dir=False):
+                    continue
                 try:
                     with open(fpath) as f:
                         file_content = f.read()