codespy-ai 0.2.2__tar.gz → 0.2.3__tar.gz

{codespy_ai-0.2.2 → codespy_ai-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codespy-ai
-Version: 0.2.2
+Version: 0.2.3
 Summary: Code review agent powered by DSPy
 License: MIT
 License-File: LICENSE
@@ -254,7 +254,7 @@ docker run --rm \
 
 Add CodeSpy to your repository for automatic PR reviews:
 
-**Trigger on `@codespy review` comment:**
+**Trigger on `/codespy review` comment:**
 
 ```yaml
 # .github/workflows/codespy-review.yml
@@ -266,10 +266,10 @@ on:
 
 jobs:
   review:
-    # Only run on PR comments containing '@codespy review'
+    # Only run on PR comments containing '/codespy review'
     if: |
       github.event.issue.pull_request &&
-      contains(github.event.comment.body, '@codespy review')
+      contains(github.event.comment.body, '/codespy review')
     runs-on: ubuntu-latest
     permissions:
       contents: read

{codespy_ai-0.2.2 → codespy_ai-0.2.3}/README.md

@@ -203,7 +203,7 @@ docker run --rm \
 
 Add CodeSpy to your repository for automatic PR reviews:
 
-**Trigger on `@codespy review` comment:**
+**Trigger on `/codespy review` comment:**
 
 ```yaml
 # .github/workflows/codespy-review.yml
@@ -215,10 +215,10 @@ on:
 
 jobs:
   review:
-    # Only run on PR comments containing '@codespy review'
+    # Only run on PR comments containing '/codespy review'
     if: |
       github.event.issue.pull_request &&
-      contains(github.event.comment.body, '@codespy review')
+      contains(github.event.comment.body, '/codespy review')
     runs-on: ubuntu-latest
     permissions:
       contents: read

{codespy_ai-0.2.2 → codespy_ai-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "codespy-ai"
-version = "0.2.2"
+version = "0.2.3"
 description = "Code review agent powered by DSPy"
 readme = "README.md"
 license = "MIT"

{codespy_ai-0.2.2 → codespy_ai-0.2.3}/src/codespy/__init__.py

@@ -1,3 +1,3 @@
 """codespy - Code review agent powered by DSPy."""
 
-__version__ = "0.2.2"
+__version__ = "0.2.3"

{codespy_ai-0.2.2 → codespy_ai-0.2.3}/src/codespy/agents/reviewer/modules/code_and_doc_reviewer.py

@@ -9,7 +9,7 @@ import dspy  # type: ignore[import-untyped]
 
 from codespy.agents import SignatureContext, get_cost_tracker
 from codespy.agents.reviewer.models import Issue, IssueCategory, ScopeResult
-from codespy.agents.reviewer.modules.helpers import MIN_CONFIDENCE
+from codespy.agents.reviewer.modules.helpers import MIN_CONFIDENCE, make_scope_relative, resolve_scope_root, restore_repo_paths
 from codespy.config import get_settings
 from codespy.tools.mcp_utils import cleanup_mcp_contexts, connect_mcp_server
 
@@ -21,16 +21,16 @@ class CodeAndDocReviewSignature(dspy.Signature):
 
     You are a busy Principal Engineer with very little time.
     Be extremely terse. Use imperative mood ("Fix X", not "You should fix X").
-    You have tools to explore the repository filesystem, search for text, and analyze code.
-    All file paths are relative to the repository root.
+    You have tools to explore the scope's filesystem, search for text, and analyze code.
+    All file paths are relative to the scope root directory (the current tool root).
+    Tools are restricted to this scope — you cannot access files outside it.
 
     ═══════════════════════════════════════════════════════════════════════════════
     PHASE 1 — READ DOCUMENTATION (MANDATORY FIRST STEP)
     ═══════════════════════════════════════════════════════════════════════════════
 
     Use read_file to read the README at the scope root:
-    - Path: {scope.subroot}/readme.md OR {scope.subroot}/README.md
-    - If scope.subroot is "peaks/svc/authenticator-v1", read "peaks/svc/authenticator-v1/readme.md"
+    - Path: readme.md OR README.md (paths are relative to scope root)
     - This file provides essential context about the scope's purpose, API contracts,
       configuration, and expected behavior. Use it to inform BOTH documentation
       review AND defect detection.
@@ -126,7 +126,7 @@ class CodeAndDocReviewSignature(dspy.Signature):
     OUTPUT RULES
     ═══════════════════════════════════════════════════════════════════════════════
 
-    - Set category to "bug", "security", or "documentation" per issue
+    - Set category to one of the values provided in the categories input
     - For security issues, include cwe_id where applicable
     - Reference files by name and line number only — never copy source code into issues
     - Do not repeat patch content in reasoning steps. Keep each reasoning step to 1-2 sentences
@@ -138,12 +138,17 @@ class CodeAndDocReviewSignature(dspy.Signature):
 
     scope: ScopeResult = dspy.InputField(
         desc="Scope with changed files. Has: subroot, scope_type, "
-        "changed_files (filename + patch - analyze patch first), language, package_manifest."
+        "changed_files (filename + patch - analyze patch first), language, package_manifest. "
+        "File paths in changed_files are relative to the scope root (tool root)."
+    )
+    categories: list[IssueCategory] = dspy.InputField(
+        desc="Allowed issue categories. Use only these values for the 'category' field on each issue."
     )
 
     issues: list[Issue] = dspy.OutputField(
-        desc="Verified defects and documentation issues. Set category to 'bug', 'security', or 'documentation' per issue. "
-        "Titles <10 words. Descriptions ≤25 words, imperative. Empty list if none."
+        desc="Verified defects and documentation issues. Category must be one of the provided categories. "
+        "Titles <10 words. Descriptions ≤25 words, imperative. Empty list if none. "
+        "File paths must be relative to scope root."
     )
 
 
@@ -152,6 +157,9 @@ class CodeAndDocReviewer(dspy.Module):
 
     Merges the responsibilities of DefectDetector and DocumentationReviewer
     to share MCP tool overhead and README context across both concerns.
+
+    MCP tools are scope-restricted: for each scope, tools are rooted at
+    repo_path/scope.subroot so the agent cannot access files outside the scope.
     """
 
     def __init__(self) -> None:
@@ -160,11 +168,11 @@ class CodeAndDocReviewer(dspy.Module):
         self._cost_tracker = get_cost_tracker()
         self._settings = get_settings()
 
-    async def _create_mcp_tools(self, repo_path: Path) -> tuple[list[Any], list[Any]]:
-        """Create DSPy tools from MCP servers.
+    async def _create_mcp_tools(self, scope_root: Path) -> tuple[list[Any], list[Any]]:
+        """Create DSPy tools from MCP servers, rooted at scope directory.
 
         Args:
-            repo_path: Path to the repository root
+            scope_root: Path to the scope root directory (repo_path / scope.subroot)
 
         Returns:
             Tuple of (tools list, contexts list for cleanup)
@@ -172,24 +180,24 @@ class CodeAndDocReviewer(dspy.Module):
         tools: list[Any] = []
         contexts: list[Any] = []
         tools_dir = Path(__file__).parent.parent.parent.parent / "tools"
-        repo_path_str = str(repo_path)
+        scope_root_str = str(scope_root)
         caller = "code_and_doc_reviewer"
         # Filesystem tools: read_file, list_directory, get_tree, file_exists, get_file_info
         tools.extend(
             await connect_mcp_server(
-                tools_dir / "filesystem" / "server.py", [repo_path_str], contexts, caller
+                tools_dir / "filesystem" / "server.py", [scope_root_str], contexts, caller
             )
         )
         # Ripgrep tools: search_literal, find_function_usages, find_type_usages, etc.
         tools.extend(
             await connect_mcp_server(
-                tools_dir / "parsers" / "ripgrep" / "server.py", [repo_path_str], contexts, caller
+                tools_dir / "parsers" / "ripgrep" / "server.py", [scope_root_str], contexts, caller
             )
         )
         # Treesitter tools: find_function_definitions, find_function_calls, etc.
         tools.extend(
             await connect_mcp_server(
-                tools_dir / "parsers" / "treesitter" / "server.py", [repo_path_str], contexts, caller
+                tools_dir / "parsers" / "treesitter" / "server.py", [scope_root_str], contexts, caller
             )
         )
         return tools, contexts
@@ -199,9 +207,13 @@ class CodeAndDocReviewer(dspy.Module):
     ) -> list[Issue]:
         """Analyze scopes for code defects and documentation issues.
 
+        For each scope, MCP tools are created rooted at repo_path/scope.subroot
+        so the agent can only access files within the scope boundary. This prevents
+        unnecessary out-of-scope tool calls that waste tokens and cost.
+
         Args:
             scopes: List of identified scopes with their changed files
-            repo_path: Path to the cloned repository (used for MCP tool initialization)
+            repo_path: Path to the cloned repository
 
         Returns:
             List of issues (bugs, security, documentation) found across all scopes
@@ -216,46 +228,53 @@ class CodeAndDocReviewer(dspy.Module):
             return []
 
         all_issues: list[Issue] = []
-        tools, contexts = await self._create_mcp_tools(repo_path)
-
-        try:
-            max_iters = self._settings.get_max_iters("code_and_doc_review")
-            agent = dspy.ReAct(
-                signature=CodeAndDocReviewSignature,
-                tools=tools,
-                max_iters=max_iters,
-            )
+        max_iters = self._settings.get_max_iters("code_and_doc_review")
 
-            total_files = sum(len(s.changed_files) for s in changed_scopes)
-            logger.info(
-                f"Reviewing code and docs for {len(changed_scopes)} scopes "
-                f"({total_files} changed files)..."
-            )
+        total_files = sum(len(s.changed_files) for s in changed_scopes)
+        logger.info(
+            f"Reviewing code and docs for {len(changed_scopes)} scopes "
+            f"({total_files} changed files)..."
+        )
 
-            for scope in changed_scopes:
-                try:
-                    logger.info(
-                        f"  Reviewing scope {scope.subroot} "
-                        f"({len(scope.changed_files)} files)"
-                    )
-                    async with SignatureContext("code_and_doc_review", self._cost_tracker):
-                        result = await agent.acall(scope=scope)
-
-                    issues = [
-                        issue for issue in (result.issues or [])
-                        if issue.confidence >= MIN_CONFIDENCE
-                    ]
-                    all_issues.extend(issues)
-                    logger.debug(
-                        f"  Scope {scope.subroot}: {len(issues)} issues"
+        for scope in changed_scopes:
+            # Scope-restrict MCP tools to the scope's subroot directory
+            scope_root = resolve_scope_root(repo_path, scope.subroot)
+            tools, contexts = await self._create_mcp_tools(scope_root)
+            try:
+                agent = dspy.ReAct(
+                    signature=CodeAndDocReviewSignature,
+                    tools=tools,
+                    max_iters=max_iters,
+                )
+                # Create scope-relative copy so file paths match the scoped tool root
+                scoped = make_scope_relative(scope)
+                logger.info(
+                    f"  Reviewing scope {scope.subroot} "
+                    f"({len(scope.changed_files)} files)"
+                )
+                async with SignatureContext("code_and_doc_review", self._cost_tracker):
+                    result = await agent.acall(
+                        scope=scoped,
+                        categories=[IssueCategory.BUG, IssueCategory.SECURITY, IssueCategory.DOCUMENTATION],
                     )
-                except Exception as e:
-                    logger.error(f"Review failed for scope {scope.subroot}: {e}")
 
-            logger.info(f"Code and doc review found {len(all_issues)} issues")
-            return all_issues
-        finally:
-            await cleanup_mcp_contexts(contexts)
+                issues = [
+                    issue for issue in (result.issues or [])
+                    if issue.confidence >= MIN_CONFIDENCE
+                ]
+                # Restore repo-root-relative paths in reported issues
+                restore_repo_paths(issues, scope.subroot)
+                all_issues.extend(issues)
+                logger.debug(
+                    f"  Scope {scope.subroot}: {len(issues)} issues"
+                )
+            except Exception as e:
+                logger.error(f"Review failed for scope {scope.subroot}: {e}")
+            finally:
+                await cleanup_mcp_contexts(contexts)
+
+        logger.info(f"Code and doc review found {len(all_issues)} issues")
+        return all_issues
 
     def forward(
         self, scopes: Sequence[ScopeResult], repo_path: Path

codespy_ai-0.2.3/src/codespy/agents/reviewer/modules/helpers.py

@@ -0,0 +1,189 @@
+"""Helper functions for DSPy review modules."""
+
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from codespy.tools.git.models import ChangedFile
+from codespy.agents.reviewer.models import Issue
+
+if TYPE_CHECKING:
+    from codespy.agents.reviewer.models import ScopeResult
+
+logger = logging.getLogger(__name__)
+
+
+# Language detection based on file extension
+EXTENSION_TO_LANGUAGE = {
+    "py": "Python",
+    "js": "JavaScript",
+    "ts": "TypeScript",
+    "jsx": "JavaScript (React)",
+    "tsx": "TypeScript (React)",
+    "go": "Go",
+    "rs": "Rust",
+    "java": "Java",
+    "kt": "Kotlin",
+    "c": "C",
+    "cpp": "C++",
+    "h": "C/C++ Header",
+    "hpp": "C++ Header",
+    "cs": "C#",
+    "rb": "Ruby",
+    "php": "PHP",
+    "swift": "Swift",
+    "scala": "Scala",
+    "sh": "Shell",
+    "bash": "Bash",
+    "sql": "SQL",
+    "vue": "Vue",
+    "svelte": "Svelte",
+}
+
+# Minimum confidence threshold
+MIN_CONFIDENCE = 0.5
+
+# Markdown file extensions to review
+MARKDOWN_EXTENSIONS = {".md", ".markdown", ".mdx", ".rst", ".txt"}
+
+
+def is_markdown_file(filename: str) -> bool:
+    """Check if the file is a markdown documentation file."""
+    _, ext = os.path.splitext(filename.lower())
+    return ext in MARKDOWN_EXTENSIONS
+
+
+def get_language(file: ChangedFile) -> str:
+    """Get the programming language for a file based on extension.
+    
+    Args:
+        file: The changed file
+        
+    Returns:
+        Language name or "Unknown"
+    """
+    return EXTENSION_TO_LANGUAGE.get(file.extension, "Unknown")
+
+
+def strip_prefix(path: str, prefix: str) -> str:
+    """Strip a directory prefix from a file path.
+
+    Args:
+        path: Original file path (e.g., "packages/auth/src/index.ts")
+        prefix: Prefix to strip (e.g., "packages/auth")
+
+    Returns:
+        Relative path (e.g., "src/index.ts"). Returns path unchanged
+        if prefix is "." or path doesn't start with the prefix.
+    """
+    if prefix == "." or not prefix:
+        return path
+    # Normalize: ensure prefix ends with "/" for clean stripping
+    normalized = prefix.rstrip("/") + "/"
+    if path.startswith(normalized):
+        return path[len(normalized):]
+    # Exact match (file at scope root)
+    if path == prefix:
+        return os.path.basename(path)
+    return path
+
+
+def resolve_scope_root(repo_path: Path, subroot: str) -> Path:
+    """Resolve the absolute path for a scope root directory.
+
+    Args:
+        repo_path: Path to the repository root
+        subroot: Scope subroot relative to repo root (e.g., "packages/auth" or ".")
+
+    Returns:
+        repo_path unchanged if subroot is ".", otherwise repo_path / subroot
+    """
+    return repo_path if subroot == "." else repo_path / subroot
+
+
+def make_scope_relative(scope: ScopeResult) -> ScopeResult:
+    """Create a copy of a ScopeResult with file paths relative to scope.subroot.
+
+    When MCP tools are rooted at repo_path/scope.subroot, the agent needs file
+    paths relative to the scope root (not the repo root). This function creates
+    a shallow copy of the scope with adjusted filenames.
+
+    Args:
+        scope: Original scope with repo-root-relative file paths
+
+    Returns:
+        New ScopeResult with scope-relative file paths in changed_files.
+        The subroot is set to "." since paths are now relative to it.
+    """
+    from codespy.agents.reviewer.models import PackageManifest, ScopeResult as SR
+
+    if scope.subroot == ".":
+        return scope  # Already at repo root, no transformation needed
+
+    relative_files = [
+        ChangedFile(
+            filename=strip_prefix(f.filename, scope.subroot),
+            status=f.status,
+            additions=f.additions,
+            deletions=f.deletions,
+            patch=f.patch,
+            previous_filename=(
+                strip_prefix(f.previous_filename, scope.subroot)
+                if f.previous_filename
+                else None
+            ),
+        )
+        for f in scope.changed_files
+    ]
+
+    # Adjust manifest paths too
+    manifest = None
+    if scope.package_manifest:
+        manifest = PackageManifest(
+            manifest_path=strip_prefix(scope.package_manifest.manifest_path, scope.subroot),
+            lock_file_path=(
+                strip_prefix(scope.package_manifest.lock_file_path, scope.subroot)
+                if scope.package_manifest.lock_file_path
+                else None
+            ),
+            package_manager=scope.package_manifest.package_manager,
+            dependencies_changed=scope.package_manifest.dependencies_changed,
+        )
+
+    return SR(
+        subroot=".",
+        scope_type=scope.scope_type,
+        has_changes=scope.has_changes,
+        is_dependency=scope.is_dependency,
+        confidence=scope.confidence,
+        language=scope.language,
+        package_manifest=manifest,
+        changed_files=relative_files,
+        reason=scope.reason,
+    )
+
+
+def restore_repo_paths(issues: list[Issue], subroot: str) -> None:
+    """Restore repo-root-relative paths in issue filenames (in-place).
+
+    After the agent reports issues with scope-relative paths, this function
+    prepends the scope subroot so filenames are repo-root-relative again.
+
+    Args:
+        issues: List of issues to modify in-place
+        subroot: Scope subroot to prepend (e.g., "packages/auth")
+    """
+    if subroot == "." or not subroot:
+        return
+
+    prefix = subroot.rstrip("/") + "/"
+    for issue in issues:
+        if issue.filename and not issue.filename.startswith(prefix):
+            issue.filename = prefix + issue.filename
+
+
+
+

{codespy_ai-0.2.2 → codespy_ai-0.2.3}/src/codespy/agents/reviewer/modules/supply_chain_auditor.py

@@ -9,7 +9,7 @@ import dspy  # type: ignore[import-untyped]
 
 from codespy.agents import SignatureContext, get_cost_tracker
 from codespy.agents.reviewer.models import Issue, IssueCategory, ScopeResult
-from codespy.agents.reviewer.modules.helpers import MIN_CONFIDENCE
+from codespy.agents.reviewer.modules.helpers import MIN_CONFIDENCE, resolve_scope_root, strip_prefix, restore_repo_paths
 from codespy.config import get_settings
 from codespy.tools.mcp_utils import cleanup_mcp_contexts, connect_mcp_server
 
@@ -22,16 +22,19 @@ class SupplyChainSecuritySignature(dspy.Signature):
     You are a busy Principal Engineer reviewing supply chain security. Focus on critical risks only.
     Be extremely terse. Use imperative mood.
     You have access to:
-    - Filesystem tools to read files and explore the codebase
+    - Filesystem tools to read files and explore the scope (rooted at scope directory)
     - OSV (Open Source Vulnerabilities) tools to query real vulnerability data
 
+    All file paths are relative to the scope root directory (the current tool root).
+    Tools are restricted to this scope — you cannot access files outside it.
+
     You will analyze TWO types of supply chain security concerns:
 
     ## 1. DOCKERFILE SECURITY
 
     FIRST, search for Dockerfiles in the scope using filesystem tools:
     - Use get_tree or list_directory to find Dockerfile, Dockerfile.*, *.Dockerfile, Containerfile
-    - Common locations: scope root, docker/, build/, .docker/ directories
+    - Common locations: root (""), docker/, build/, .docker/ directories
     - Once found, use read_file to get the contents
 
     For each Dockerfile found, check for:
@@ -51,11 +54,12 @@ class SupplyChainSecuritySignature(dspy.Signature):
     - description: ≤25 words, imperative tone, no filler ("Fix X", "Pin Y").
     - No polite or conversational language ("I suggest", "Please consider", "Great").
     - Do not populate code_snippet—use line numbers instead.
+    - File paths in issues must be relative to the scope root.
 
     ## 2. DEPENDENCY SECURITY (package manifests)
 
     If manifest info is provided:
-    1. Use read_file to read the manifest file at manifest_path
+    1. Use read_file to read the manifest file at manifest_path (relative to scope root)
     2. Extract ALL dependencies with their names and versions
     3. Use OSV tools to scan dependencies for vulnerabilities
     4. Only report vulnerabilities actually found by OSV queries
@@ -104,14 +108,11 @@ class SupplyChainSecuritySignature(dspy.Signature):
     - CWE ID if applicable
     """
 
-    scope_subroot: str = dspy.InputField(
-        desc="Path to scope root relative to repo root. Search here for Dockerfiles."
-    )
     manifest_path: str = dspy.InputField(
-        desc="Path to manifest file (e.g., package.json, go.mod). Empty string if none."
+        desc="Path to manifest file relative to scope root (e.g., package.json, go.mod). Empty string if none."
     )
     lock_file_path: str = dspy.InputField(
-        desc="Path to lock file (e.g., package-lock.json, go.sum). Empty string if none."
+        desc="Path to lock file relative to scope root (e.g., package-lock.json, go.sum). Empty string if none."
     )
     package_manager: str = dspy.InputField(
         desc="Package manager name (e.g., npm, pip, go). Empty string if no manifest."
@@ -121,14 +122,18 @@ class SupplyChainSecuritySignature(dspy.Signature):
     )
 
     issues: list[Issue] = dspy.OutputField(
-        desc="Verified supply chain issues only. Titles <10 words. Descriptions ≤25 words, imperative. Empty list if none."
+        desc="Verified supply chain issues only. Titles <10 words. Descriptions ≤25 words, imperative. "
+        "File paths must be relative to scope root. Empty list if none."
     )
 
 
 class SupplyChainAuditor(dspy.Module):
-    """Analyzes supply chain security (Dockerfiles and dependencies) using DSPy."""
+    """Analyzes supply chain security (Dockerfiles and dependencies) using DSPy.
 
-    category = IssueCategory.SECURITY
+    MCP tools are scope-restricted: for each scope, filesystem/parser tools are
+    rooted at repo_path/scope.subroot so the agent cannot access files outside
+    the scope. OSV tools (no filesystem root) are shared across scopes.
+    """
 
     def __init__(self) -> None:
         """Initialize the security auditor."""
@@ -142,22 +147,30 @@ class SupplyChainAuditor(dspy.Module):
         Returns True if any scope has dependency changes or Dockerfile modifications.
         Avoids spinning up MCP servers when there's nothing to audit.
         """
+        return any(self._scope_needs_analysis(s) for s in scopes)
+
+    def _scope_needs_analysis(self, scope: ScopeResult) -> bool:
+        """Check if a specific scope has supply-chain-relevant changes.
+
+        Returns True if the scope has dependency changes or Dockerfile modifications.
+        """
         scan_unchanged = self._settings.get_scan_unchanged("supply_chain")
-        for scope in scopes:
-            if scope.package_manifest:
-                if scan_unchanged or scope.package_manifest.dependencies_changed:
-                    return True
-            for cf in scope.changed_files:
-                fname = cf.filename.rsplit("/", 1)[-1].lower()
-                if "dockerfile" in fname or fname == "containerfile":
-                    return True
+        if scope.package_manifest:
+            if scan_unchanged or scope.package_manifest.dependencies_changed:
+                return True
+        for cf in scope.changed_files:
+            fname = cf.filename.rsplit("/", 1)[-1].lower()
+            if "dockerfile" in fname or fname == "containerfile":
+                return True
         return False
 
-    async def _create_mcp_tools(self, repo_path: Path) -> tuple[list[Any], list[Any]]:
-        """Create DSPy tools from filesystem, parser, and OSV MCP servers.
+    async def _create_scoped_tools(
+        self, scope_root: Path
+    ) -> tuple[list[Any], list[Any]]:
+        """Create scope-restricted DSPy tools from filesystem and parser MCP servers.
 
         Args:
-            repo_path: Path to the repository root
+            scope_root: Path to the scope root directory (repo_path / scope.subroot)
 
         Returns:
             Tuple of (tools, contexts) for cleanup
@@ -165,13 +178,13 @@ class SupplyChainAuditor(dspy.Module):
         tools: list[Any] = []
         contexts: list[Any] = []
         tools_dir = Path(__file__).parent.parent.parent.parent / "tools"
-        repo_path_str = str(repo_path)
+        scope_root_str = str(scope_root)
         caller = "supply_chain_auditor"
 
         # Add filesystem tools for reading files and exploring structure
         tools.extend(await connect_mcp_server(
             tools_dir / "filesystem" / "server.py",
-            [repo_path_str],
+            [scope_root_str],
             contexts,
             caller,
         ))
@@ -179,7 +192,7 @@ class SupplyChainAuditor(dspy.Module):
         # Add tree-sitter tools for parsing code structure
         tools.extend(await connect_mcp_server(
             tools_dir / "parsers" / "treesitter" / "server.py",
-            [repo_path_str],
+            [scope_root_str],
             contexts,
             caller,
         ))
@@ -187,12 +200,24 @@ class SupplyChainAuditor(dspy.Module):
         # Add ripgrep tools for searching code patterns
         tools.extend(await connect_mcp_server(
             tools_dir / "parsers" / "ripgrep" / "server.py",
-            [repo_path_str],
+            [scope_root_str],
             contexts,
             caller,
         ))
 
-        # Add OSV tools for querying real vulnerability data
+        return tools, contexts
+
+    async def _create_osv_tools(self) -> tuple[list[Any], list[Any]]:
+        """Create OSV tools (no filesystem root, can be shared).
+
+        Returns:
+            Tuple of (tools, contexts) for cleanup
+        """
+        tools: list[Any] = []
+        contexts: list[Any] = []
+        tools_dir = Path(__file__).parent.parent.parent.parent / "tools"
+        caller = "supply_chain_auditor"
+
         tools.extend(await connect_mcp_server(
             tools_dir / "cyber" / "osv" / "server.py",
             [],
@@ -205,6 +230,11 @@ class SupplyChainAuditor(dspy.Module):
     async def aforward(self, scopes: Sequence[ScopeResult], repo_path: Path) -> list[Issue]:
         """Analyze scopes for supply chain security vulnerabilities and return issues.
 
+        For each scope, filesystem/parser tools are created rooted at
+        repo_path/scope.subroot so the agent can only access files within the
+        scope boundary. OSV tools are shared across scopes since they don't
+        access the filesystem.
+
         Args:
             scopes: The scopes containing changed files to analyze
             repo_path: Path to the cloned repository for reading manifest files
@@ -223,30 +253,53 @@ class SupplyChainAuditor(dspy.Module):
             return []
 
         all_issues: list[Issue] = []
-        tools, contexts = await self._create_mcp_tools(repo_path)
-
         supply_chain_max_iters = self._settings.get_max_iters("supply_chain")
-        supply_chain_agent = dspy.ReAct(
-            signature=SupplyChainSecuritySignature,
-            tools=tools,
-            max_iters=supply_chain_max_iters,
-        )
+
+        # Create OSV tools once (shared across scopes, no filesystem root)
+        osv_tools, osv_contexts = await self._create_osv_tools()
 
         try:
             for scope in scopes:
+                # Skip scopes with no supply-chain-relevant changes
+                if not self._scope_needs_analysis(scope):
+                    continue
+
                 # Check if we should scan unchanged manifests
                 scan_unchanged = self._settings.get_scan_unchanged("supply_chain")
 
                 # Get manifest info (skip if unchanged and scan_unchanged=False)
                 manifest = scope.package_manifest
                 should_scan_manifest = manifest and (scan_unchanged or manifest.dependencies_changed)
-                manifest_path = manifest.manifest_path if should_scan_manifest else ""
-                lock_file_path = (manifest.lock_file_path or "") if should_scan_manifest else ""
-                package_manager = manifest.package_manager if should_scan_manifest else ""
-                if manifest and not should_scan_manifest:
-                    logger.debug(f"Skipping unchanged manifest: {manifest.manifest_path}")
-                # Run supply chain analysis — agent will search for Dockerfiles itself
+
+                # Convert manifest paths to scope-relative
+                if should_scan_manifest:
+                    manifest_path = strip_prefix(manifest.manifest_path, scope.subroot)
+                    lock_file_path = (
+                        strip_prefix(manifest.lock_file_path, scope.subroot)
+                        if manifest.lock_file_path
+                        else ""
+                    )
+                    package_manager = manifest.package_manager
+                else:
+                    manifest_path = ""
+                    lock_file_path = ""
+                    package_manager = ""
+                    if manifest:
+                        logger.debug(f"Skipping unchanged manifest: {manifest.manifest_path}")
+
+                # Scope-restrict filesystem/parser tools to the scope's subroot
+                scope_root = resolve_scope_root(repo_path, scope.subroot)
+                scoped_tools, scoped_contexts = await self._create_scoped_tools(scope_root)
+
                 try:
+                    # Combine scoped filesystem tools with shared OSV tools
+                    all_tools = scoped_tools + osv_tools
+                    supply_chain_agent = dspy.ReAct(
+                        signature=SupplyChainSecuritySignature,
+                        tools=all_tools,
+                        max_iters=supply_chain_max_iters,
+                    )
+
                     logger.debug(
                         f"Analyzing supply chain in scope {scope.subroot}: "
                         f"manifest={bool(manifest_path)}"
@@ -254,22 +307,26 @@ class SupplyChainAuditor(dspy.Module):
                     # Track supply_chain signature costs separately
                     async with SignatureContext("supply_chain", self._cost_tracker):
                         result = await supply_chain_agent.acall(
-                            scope_subroot=scope.subroot,
                             manifest_path=manifest_path,
                             lock_file_path=lock_file_path,
                             package_manager=package_manager,
-                            category=self.category,
+                            category=IssueCategory.SECURITY,
                         )
                     issues = [
                         issue for issue in result.issues
                         if issue.confidence >= MIN_CONFIDENCE
                     ]
+                    # Restore repo-root-relative paths in reported issues
+                    restore_repo_paths(issues, scope.subroot)
                     all_issues.extend(issues)
                     logger.debug(f"  Supply chain security in scope {scope.subroot}: {len(issues)} issues")
                 except Exception as e:
                     logger.error(f"Error analyzing supply chain in scope {scope.subroot}: {e}")
+                finally:
+                    await cleanup_mcp_contexts(scoped_contexts)
         finally:
-            await cleanup_mcp_contexts(contexts)
+            await cleanup_mcp_contexts(osv_contexts)
+
         logger.info(f"Security audit found {len(all_issues)} issues")
         return all_issues
 

codespy_ai-0.2.2/src/codespy/agents/reviewer/modules/helpers.py

@@ -1,65 +0,0 @@
-"""Helper functions for DSPy review modules."""
-
-import logging
-import os
-
-from codespy.tools.git.models import ChangedFile
-from codespy.agents.reviewer.models import Issue
-
-logger = logging.getLogger(__name__)
-
-
-# Language detection based on file extension
-EXTENSION_TO_LANGUAGE = {
-    "py": "Python",
-    "js": "JavaScript",
-    "ts": "TypeScript",
-    "jsx": "JavaScript (React)",
-    "tsx": "TypeScript (React)",
-    "go": "Go",
-    "rs": "Rust",
-    "java": "Java",
-    "kt": "Kotlin",
-    "c": "C",
-    "cpp": "C++",
-    "h": "C/C++ Header",
-    "hpp": "C++ Header",
-    "cs": "C#",
-    "rb": "Ruby",
-    "php": "PHP",
-    "swift": "Swift",
-    "scala": "Scala",
-    "sh": "Shell",
-    "bash": "Bash",
-    "sql": "SQL",
-    "vue": "Vue",
-    "svelte": "Svelte",
-}
-
-# Minimum confidence threshold
-MIN_CONFIDENCE = 0.5
-
-# Markdown file extensions to review
-MARKDOWN_EXTENSIONS = {".md", ".markdown", ".mdx", ".rst", ".txt"}
-
-
-def is_markdown_file(filename: str) -> bool:
-    """Check if the file is a markdown documentation file."""
-    _, ext = os.path.splitext(filename.lower())
-    return ext in MARKDOWN_EXTENSIONS
-
-
-def get_language(file: ChangedFile) -> str:
-    """Get the programming language for a file based on extension.
-    
-    Args:
-        file: The changed file
-        
-    Returns:
-        Language name or "Unknown"
-    """
-    return EXTENSION_TO_LANGUAGE.get(file.extension, "Unknown")
-
-
-
-