crucible-mcp 1.2.0__tar.gz → 1.3.0__tar.gz

{crucible_mcp-1.2.0 → crucible_mcp-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crucible-mcp
-Version: 1.2.0
+Version: 1.3.0
 Summary: Code review MCP server for Claude. Not affiliated with Atlassian.
 Author: be.nvy
 License-Expression: MIT

{crucible_mcp-1.2.0 → crucible_mcp-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "crucible-mcp"
-version = "1.2.0"
+version = "1.3.0"
 description = "Code review MCP server for Claude. Not affiliated with Atlassian."
 readme = "README.md"
 requires-python = ">=3.11"

{crucible_mcp-1.2.0 → crucible_mcp-1.3.0}/src/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_mcp-1.3.0/src/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_mcp-1.2.0 → crucible_mcp-1.3.0}/src/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()

{crucible_mcp-1.2.0 → crucible_mcp-1.3.0}/src/crucible/server.py

@@ -18,6 +18,7 @@ from crucible.review.core import (
     deduplicate_findings,
     detect_domain,
     filter_findings_to_changes,
+    filter_ignored_findings,
     load_skills_and_knowledge,
     run_enforcement,
     run_static_analysis,
@@ -509,6 +510,14 @@ def _handle_review(arguments: dict[str, Any]) -> list[TextContent]:
         if not changed_files:
             return [TextContent(type="text", text="No files to analyze (only deletions).")]
 
+        # Filter out ignored files (.crucibleignore)
+        from crucible.ignore import load_ignore_spec
+        repo_path_for_ignore = get_repo_root(path if path else os.getcwd()).value
+        ignore_spec = load_ignore_spec(repo_path_for_ignore)
+        changed_files = [f for f in changed_files if not ignore_spec.is_ignored(f, is_dir=False)]
+        if not changed_files:
+            return [TextContent(type="text", text="No files to analyze (all changes are in ignored paths).")]
+
     elif not path:
         return [TextContent(type="text", text="Error: Either 'path' or 'mode' is required.")]
 
@@ -546,6 +555,10 @@ def _handle_review(arguments: dict[str, Any]) -> list[TextContent]:
     # Deduplicate findings
     all_findings = deduplicate_findings(all_findings)
 
+    # Filter out findings from ignored paths (.crucibleignore)
+    base_path = path if path else os.getcwd()
+    all_findings = filter_ignored_findings(all_findings, base_path)
+
     # Run pattern and LLM assertions
     enforcement_findings = []
     enforcement_errors: list[str] = []

crucible_mcp-1.3.0/src/crucible/skills/code-hygiene/SKILL.md

@@ -0,0 +1,83 @@
+---
+version: "1.0"
+triggers: [cleanup, refactor, deprecate, dead-code, unused, tech-debt, maintenance]
+always_run: false
+always_run_for_domains: []
+knowledge: []
+---
+
+# Code Hygiene Engineer
+
+You are reviewing code for cleanliness and maintainability. Your job is to identify dead code, deprecated patterns, stale task markers, and cleanup opportunities.
+
+## Key Questions
+
+Ask yourself these questions about the code:
+
+- Is this code still used? By what?
+- Are these imports actually needed?
+- Is this marked deprecated but still present?
+- Are there task markers (FIXME/XXX) that reference completed work?
+- Is there commented-out code that should be deleted?
+
+## Red Flags
+
+Watch for these patterns:
+
+- Functions/classes with no callers
+- Imports that are never used
+- `DEPRECATED` or `@deprecated` markers
+- Stale task markers like `FIXME: remove` or `XXX: delete`
+- Large blocks of commented-out code
+- Feature flags for features that shipped long ago
+- Backwards-compatibility shims that are no longer needed
+- Variables assigned but never read
+- Unreachable code after return/raise/break
+
+## Before Approving
+
+Verify these criteria:
+
+- [ ] No deprecated code introduced
+- [ ] No unused imports added
+- [ ] Task markers have actionable context (ticket/date/owner)
+- [ ] Commented-out code removed or justified
+- [ ] No dead code paths
+- [ ] Backwards-compat shims have removal dates
+- [ ] Feature flags have cleanup tickets
+
+## Cleanup Opportunities
+
+When reviewing, note opportunities to:
+
+- Remove unused parameters
+- Delete deprecated functions after migration
+- Clean up old feature flags
+- Remove backwards-compat code after version bump
+- Consolidate duplicate code
+- Remove redundant comments
+
+## Output Format
+
+Structure your hygiene review as:
+
+### Dead Code Found
+List unused or unreachable code with confidence level.
+
+### Deprecation Issues
+Code marked deprecated or using deprecated patterns.
+
+### Stale Task Markers
+FIXME/XXX comments that appear outdated or reference completed work.
+
+### Cleanup Opportunities
+Suggestions for improving code cleanliness.
+
+### Approval Status
+- APPROVE: Code is clean
+- REQUEST CHANGES: Dead code or deprecated patterns must be addressed
+- COMMENT: Minor cleanup suggestions
+
+---
+
+*Template. Adapt to your needs.*

{crucible_mcp-1.2.0 → crucible_mcp-1.3.0}/src/crucible_mcp.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crucible-mcp
-Version: 1.2.0
+Version: 1.3.0
 Summary: Code review MCP server for Claude. Not affiliated with Atlassian.
 Author: be.nvy
 License-Expression: MIT

{crucible_mcp-1.2.0 → crucible_mcp-1.3.0}/src/crucible_mcp.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ pyproject.toml
 src/crucible/__init__.py
 src/crucible/cli.py
 src/crucible/errors.py
+src/crucible/ignore.py
 src/crucible/models.py
 src/crucible/server.py
 src/crucible/domain/__init__.py
@@ -41,6 +42,7 @@ src/crucible/skills/__init__.py
 src/crucible/skills/loader.py
 src/crucible/skills/accessibility-engineer/SKILL.md
 src/crucible/skills/backend-engineer/SKILL.md
+src/crucible/skills/code-hygiene/SKILL.md
 src/crucible/skills/customer-success/SKILL.md
 src/crucible/skills/data-engineer/SKILL.md
 src/crucible/skills/devops-engineer/SKILL.md
@@ -74,6 +76,7 @@ tests/test_enforcement.py
 tests/test_full_review.py
 tests/test_git.py
 tests/test_hooks_cli.py
+tests/test_ignore.py
 tests/test_integration.py
 tests/test_knowledge.py
 tests/test_precommit.py

crucible_mcp-1.3.0/tests/test_ignore.py

@@ -0,0 +1,194 @@
+"""Tests for crucible.ignore module."""
+
+from pathlib import Path
+
+import pytest
+
+from crucible.ignore import (
+    DEFAULT_PATTERNS,
+    IgnorePattern,
+    IgnoreSpec,
+    clear_ignore_cache,
+    load_ignore_spec,
+    parse_ignore_file,
+    should_ignore,
+)
+
+
+class TestIgnorePattern:
+    """Tests for IgnorePattern matching."""
+
+    def test_simple_glob(self) -> None:
+        """Simple glob patterns match files."""
+        pattern = IgnorePattern(pattern="*.log")
+        assert pattern.matches("error.log", is_dir=False)
+        assert pattern.matches("logs/error.log", is_dir=False)
+        assert not pattern.matches("error.txt", is_dir=False)
+
+    def test_directory_pattern(self) -> None:
+        """Directory patterns match directories and files inside them."""
+        pattern = IgnorePattern(pattern="node_modules/", directory_only=True)
+        # Matches files inside the directory
+        assert pattern.matches("node_modules/foo.js", is_dir=False)
+        assert pattern.matches("src/node_modules/bar.js", is_dir=False)
+        # Matches the directory itself
+        assert pattern.matches("node_modules", is_dir=True)
+        # Does not match files with similar names
+        assert not pattern.matches("node_modules_backup.txt", is_dir=False)
+
+    def test_dot_directory(self) -> None:
+        """Directories starting with . are matched correctly."""
+        pattern = IgnorePattern(pattern=".next/", directory_only=True)
+        assert pattern.matches(".next/build.js", is_dir=False)
+        assert pattern.matches("apps/web/.next/cache.js", is_dir=False)
+        assert pattern.matches(".next", is_dir=True)
+
+    def test_hidden_files(self) -> None:
+        """Hidden files are matched."""
+        pattern = IgnorePattern(pattern=".DS_Store")
+        assert pattern.matches(".DS_Store", is_dir=False)
+        assert pattern.matches("src/.DS_Store", is_dir=False)
+
+    def test_nested_path(self) -> None:
+        """Nested path patterns match correctly."""
+        pattern = IgnorePattern(pattern="__pycache__/", directory_only=True)
+        assert pattern.matches("src/__pycache__/mod.pyc", is_dir=False)
+        assert pattern.matches("__pycache__/mod.pyc", is_dir=False)
+
+
+class TestIgnoreSpec:
+    """Tests for IgnoreSpec collection."""
+
+    def test_is_ignored_basic(self) -> None:
+        """Basic ignore checking works."""
+        spec = IgnoreSpec(
+            patterns=[
+                IgnorePattern(pattern="*.log"),
+                IgnorePattern(pattern="node_modules/", directory_only=True),
+            ]
+        )
+        assert spec.is_ignored("error.log")
+        assert spec.is_ignored("node_modules/foo.js")
+        assert not spec.is_ignored("src/main.py")
+
+    def test_negation(self) -> None:
+        """Negated patterns un-ignore files."""
+        spec = IgnoreSpec(
+            patterns=[
+                IgnorePattern(pattern="*.log"),
+                IgnorePattern(pattern="important.log", negated=True),
+            ]
+        )
+        assert spec.is_ignored("error.log")
+        assert not spec.is_ignored("important.log")
+
+    def test_filter_paths(self) -> None:
+        """Filter paths removes ignored ones."""
+        spec = IgnoreSpec(
+            patterns=[IgnorePattern(pattern="*.pyc")],
+        )
+        base = Path("/project")
+        paths = [
+            Path("/project/main.py"),
+            Path("/project/__pycache__/main.pyc"),
+            Path("/project/util.py"),
+        ]
+        filtered = spec.filter_paths(paths, base)
+        assert len(filtered) == 2
+        assert Path("/project/main.py") in filtered
+        assert Path("/project/util.py") in filtered
+
+
+class TestParseIgnoreFile:
+    """Tests for parsing .crucibleignore files."""
+
+    def test_parse_simple(self) -> None:
+        """Simple patterns are parsed."""
+        content = """
+*.log
+node_modules/
+"""
+        patterns = parse_ignore_file(content)
+        assert len(patterns) == 2
+        assert patterns[0].pattern == "*.log"
+        assert patterns[1].pattern == "node_modules/"
+        assert patterns[1].directory_only
+
+    def test_parse_comments(self) -> None:
+        """Comments and blank lines are ignored."""
+        content = """
+# This is a comment
+*.log
+
+# Another comment
+build/
+"""
+        patterns = parse_ignore_file(content)
+        assert len(patterns) == 2
+
+    def test_parse_negation(self) -> None:
+        """Negated patterns are parsed."""
+        content = """
+*.log
+!important.log
+"""
+        patterns = parse_ignore_file(content)
+        assert len(patterns) == 2
+        assert not patterns[0].negated
+        assert patterns[1].negated
+        assert patterns[1].pattern == "important.log"
+
+
+class TestLoadIgnoreSpec:
+    """Tests for loading ignore specs."""
+
+    def test_default_patterns_included(self) -> None:
+        """Default patterns are always included."""
+        clear_ignore_cache()
+        spec = load_ignore_spec()
+        assert len(spec.patterns) >= len(DEFAULT_PATTERNS)
+        # Check some key defaults
+        assert spec.is_ignored("node_modules/foo.js")
+        assert spec.is_ignored(".git/config")
+        assert spec.is_ignored("__pycache__/mod.pyc")
+
+    def test_project_file_override(self, tmp_path: Path) -> None:
+        """Project .crucibleignore overrides defaults."""
+        clear_ignore_cache()
+        crucible_dir = tmp_path / ".crucible"
+        crucible_dir.mkdir()
+        ignore_file = crucible_dir / ".crucibleignore"
+        ignore_file.write_text("custom_ignore/\n")
+
+        spec = load_ignore_spec(tmp_path)
+        assert spec.source == "project"
+        assert spec.is_ignored("custom_ignore/file.txt")
+        # Defaults still apply
+        assert spec.is_ignored("node_modules/foo.js")
+
+
+class TestDefaultPatterns:
+    """Tests for default ignore patterns."""
+
+    @pytest.mark.parametrize(
+        "path,expected",
+        [
+            ("node_modules/react/index.js", True),
+            (".next/build/manifest.json", True),
+            (".git/objects/abc123", True),
+            ("__pycache__/module.cpython-311.pyc", True),
+            (".venv/lib/python3.11/site.py", True),
+            ("dist/bundle.js", True),
+            ("build/output.o", True),
+            ("package-lock.json", True),
+            ("yarn.lock", True),
+            ("src/main.py", False),
+            ("components/Button.tsx", False),
+            ("contracts/Token.sol", False),
+        ],
+    )
+    def test_default_ignore_patterns(self, path: str, expected: bool) -> None:
+        """Default patterns ignore common non-source files."""
+        clear_ignore_cache()
+        spec = load_ignore_spec()
+        assert spec.is_ignored(path) == expected, f"{path} should be {'ignored' if expected else 'included'}"

{crucible_mcp-1.2.0 → crucible_mcp-1.3.0}/tests/test_skills.py

@@ -1,4 +1,4 @@
-"""Tests for bundled skills - validates all 18 skills have proper structure."""
+"""Tests for bundled skills - validates all 19 skills have proper structure."""
 
 import re
 
@@ -26,6 +26,7 @@ EXPECTED_SKILLS = {
     "mev-researcher",
     "formal-verification",
     "incident-responder",
+    "code-hygiene",
 }
 
 
@@ -38,13 +39,13 @@ class TestSkillsExist:
         for skill in EXPECTED_SKILLS:
             assert skill in actual, f"Missing skill: {skill}"
 
-    def test_exactly_18_bundled_skills(self) -> None:
-        """Should have exactly 18 bundled skills."""
+    def test_exactly_19_bundled_skills(self) -> None:
+        """Should have exactly 19 bundled skills."""
         bundled = set()
         for skill_dir in SKILLS_BUNDLED.iterdir():
             if skill_dir.is_dir() and (skill_dir / "SKILL.md").exists():
                 bundled.add(skill_dir.name)
-        assert len(bundled) == 18, f"Expected 18 skills, got {len(bundled)}: {bundled}"
+        assert len(bundled) == 19, f"Expected 19 skills, got {len(bundled)}: {bundled}"
 
     def test_skills_directory_exists(self) -> None:
         """Skills bundled directory should exist."""