sourcecode 1.31.0__py3-none-any.whl → 1.31.2__py3-none-any.whl

sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Deterministic codebase context maps for AI coding agents."""
 
-__version__ = "1.31.0"
+__version__ = "1.31.2"

sourcecode/cli.py

@@ -165,7 +165,7 @@ Compressed AI-ready context for Java/Spring enterprise codebases.
 # Known subcommand names — tokens matching these are routed as subcommands,
 # not consumed as a repository path.
 _SUBCOMMANDS: frozenset[str] = frozenset(
-    {"telemetry", "prepare-context", "version", "config", "analyze", "repo-ir", "mcp"}
+    {"telemetry", "prepare-context", "version", "config", "analyze", "repo-ir", "mcp", "endpoints"}
 )
 
 # Mutable container holding the path extracted by _preprocess_argv().
@@ -2037,6 +2037,27 @@ def prepare_context_cmd(
         out["changed_files"] = output.changed_files
     if _task_include("affected_entry_points") and output.affected_entry_points:
         out["affected_entry_points"] = output.affected_entry_points
+    # compact_base fields — included for all non-delta/review-pr tasks (Fix #1)
+    if task not in ("delta", "review-pr"):
+        if output.entry_points_structured:
+            out["entry_points"] = output.entry_points_structured
+        if output.deployment:
+            out["deployment"] = output.deployment
+        if output.deployment_risks:
+            out["deployment_risks"] = output.deployment_risks
+        if output.security_surface:
+            out["security_surface"] = output.security_surface
+        if output.mybatis:
+            out["mybatis"] = output.mybatis
+        if output.transactional_boundaries:
+            out["transactional_boundaries"] = output.transactional_boundaries
+        if output.spring_profiles_info:
+            out["spring_profiles"] = output.spring_profiles_info
+        if output.angular_analysis and (
+            output.angular_analysis.get("component_count", 0) > 0
+            or output.angular_analysis.get("angular_version")
+        ):
+            out["angular_analysis"] = output.angular_analysis
     # Delta-specific impact fields
     if task == "delta":
         if output.error_code:
@@ -2420,6 +2441,190 @@ def repo_ir_cmd(
             _sys.stdout.write("\n")
 
 
+# ── endpoints ─────────────────────────────────────────────────────────────────
+
+def _extract_java_endpoints(root: "Path") -> "dict[str, Any]":
+    """Extract REST endpoint surface from Java source files.
+
+    Scans all .java files for @RequestMapping/@GetMapping/@PostMapping/@PutMapping/
+    @DeleteMapping/@PatchMapping and @M3FiltroSeguridad annotations.
+    Returns JSON-serializable dict with endpoints list, total, and undocumented count.
+    """
+    import re as _re
+    from pathlib import Path as _Path
+
+    _HTTP_MAPPING_RE = _re.compile(
+        r'@(Get|Post|Put|Delete|Patch|Request)Mapping\s*'
+        r'(?:\(\s*(?:value\s*=\s*)?(?:"([^"]*)"|\{[^}]*\}|[^)]*)\s*\))?',
+    )
+    _CLASS_RE = _re.compile(r'(?:class|interface)\s+(\w+)')
+    _METHOD_RE = _re.compile(
+        r'(?:public|protected|private)\s+\S+\s+(\w+)\s*\(',
+    )
+    _FILTRO_RE = _re.compile(
+        r'@M3FiltroSeguridad\s*\(\s*(?:nombreRecurso\s*=\s*)?["\']([^"\']+)["\']',
+    )
+    _CLASS_PATH_RE = _re.compile(
+        r'@RequestMapping\s*\(\s*(?:value\s*=\s*)?["\']([^"\']+)["\']',
+    )
+
+    _HTTP_METHOD_MAP = {
+        "Get": "GET", "Post": "POST", "Put": "PUT",
+        "Delete": "DELETE", "Patch": "PATCH", "Request": "GET",
+    }
+
+    endpoints: list[dict] = []
+    seen: set[tuple] = set()
+
+    java_files = [
+        p for p in root.rglob("*.java")
+        if "/test/" not in str(p).replace("\\", "/")
+        and "/tests/" not in str(p).replace("\\", "/")
+        and "target/" not in str(p).replace("\\", "/")
+    ]
+
+    for java_file in java_files:
+        try:
+            content = java_file.read_text(encoding="utf-8", errors="replace")
+        except OSError:
+            continue
+
+        # Only process files with REST controller or mapping annotations
+        if not any(x in content for x in ("@RestController", "@Controller", "@RequestMapping")):
+            continue
+
+        try:
+            rel_path = str(java_file.relative_to(root)).replace("\\", "/")
+        except ValueError:
+            rel_path = str(java_file).replace("\\", "/")
+
+        # Extract class name
+        cls_m = _CLASS_RE.search(content)
+        class_name = cls_m.group(1) if cls_m else java_file.stem
+
+        # Extract class-level base path from @RequestMapping on the class
+        class_base = ""
+        lines = content.splitlines()
+        for i, line in enumerate(lines):
+            if "@RequestMapping" in line and i < len(lines) - 1:
+                # Check if next non-blank line is class declaration or it's on same block
+                block = "\n".join(lines[max(0, i - 1): i + 5])
+                if "class " in block or "interface " in block:
+                    path_m = _CLASS_PATH_RE.search(block)
+                    if path_m:
+                        class_base = path_m.group(1).rstrip("/")
+                    break
+
+        # Extract method-level endpoints
+        # Parse line-by-line to associate annotations with methods
+        pending_annotations: list[tuple[str, str]] = []  # (http_verb, path_suffix)
+        pending_filtro: Optional[str] = None
+
+        for i, line in enumerate(lines):
+            stripped = line.strip()
+
+            # Check for @M3FiltroSeguridad
+            fm = _FILTRO_RE.search(stripped)
+            if fm:
+                pending_filtro = fm.group(1)
+                continue
+
+            # Check for HTTP mapping annotations
+            hm = _HTTP_MAPPING_RE.search(stripped)
+            if hm:
+                verb_key = hm.group(1)
+                http_verb = _HTTP_METHOD_MAP.get(verb_key, "GET")
+                path_suffix = (hm.group(2) or "").strip()
+                pending_annotations.append((http_verb, path_suffix))
+                continue
+
+            # Check for method declaration — flush pending annotations
+            if pending_annotations and ("public " in stripped or "protected " in stripped):
+                mm = _METHOD_RE.search(stripped)
+                handler = mm.group(1) if mm else ""
+                if handler and not handler.startswith("class"):
+                    for http_verb, path_suffix in pending_annotations:
+                        full_path = (class_base + "/" + path_suffix).replace("//", "/").rstrip("/") or "/"
+                        if not full_path.startswith("/"):
+                            full_path = "/" + full_path
+                        key = (class_name, handler, http_verb)
+                        if key not in seen:
+                            seen.add(key)
+                            entry: dict[str, Any] = {
+                                "method": http_verb,
+                                "path": full_path,
+                                "controller": class_name,
+                                "handler": handler,
+                            }
+                            if pending_filtro:
+                                entry["required_permission"] = pending_filtro
+                            endpoints.append(entry)
+                    pending_annotations = []
+                    pending_filtro = None
+                    continue
+
+            # Non-annotation, non-method line — reset if it's a closing brace or blank
+            if stripped in ("}", "{", "") or stripped.startswith("//") or stripped.startswith("*"):
+                if stripped == "}":
+                    pending_annotations = []
+                    pending_filtro = None
+
+    endpoints.sort(key=lambda e: (e.get("controller", ""), e.get("path", "")))
+    undocumented = sum(1 for e in endpoints if "required_permission" not in e)
+
+    return {
+        "endpoints": endpoints,
+        "total": len(endpoints),
+        "undocumented": undocumented,
+    }
+
+
+@app.command("endpoints")
+def endpoints_cmd(
+    path: Path = typer.Argument(
+        Path("."),
+        help="Repository path to scan for REST endpoints (default: current directory)",
+    ),
+    output_path: Optional[Path] = typer.Option(
+        None, "--output", "-o",
+        help="Write output to a file instead of stdout.",
+    ),
+) -> None:
+    """Extract REST API endpoint surface from Java source files.
+
+    \b
+    Scans all @GetMapping/@PostMapping/@PutMapping/@DeleteMapping/@PatchMapping
+    and @RequestMapping annotations. Extracts HTTP method, path, controller class,
+    handler method, and @M3FiltroSeguridad permission resource name.
+
+    \b
+    Examples:
+      sourcecode endpoints .
+      sourcecode endpoints /path/to/repo
+      sourcecode endpoints . --output endpoints.json
+    """
+    import sys as _sys
+
+    target = path.resolve()
+    if not target.exists() or not target.is_dir():
+        typer.echo(f"Error: '{target}' is not a valid directory.", err=True)
+        raise typer.Exit(code=1)
+
+    data = _extract_java_endpoints(target)
+    output = json.dumps(data, indent=2, ensure_ascii=False)
+
+    if output_path is not None:
+        output_path.write_text(output, encoding="utf-8")
+        typer.echo(
+            f"Endpoints written to {output_path} ({data['total']} endpoints)",
+            err=True,
+        )
+    else:
+        _sys.stdout.buffer.write(output.encode("utf-8"))
+        _sys.stdout.buffer.write(b"\n")
+        _sys.stdout.buffer.flush()
+
+
 # ── version ───────────────────────────────────────────────────────────────────
 
 @app.command("version")
@@ -2466,10 +2671,6 @@ def analyze_cmd(
 def mcp_serve() -> None:
     """Start the MCP server on stdio for AI agent integration.
 
-    \b
-    Requires the 'mcp' extra:
-      pip install sourcecode[mcp]
-
     \b
     Configure in your MCP client (e.g. Claude Desktop):
       {
@@ -2487,15 +2688,7 @@ def mcp_serve() -> None:
         level=logging.INFO,
         format="[sourcecode-mcp] %(levelname)s %(message)s",
     )
-    try:
-        from sourcecode.mcp.server import mcp as _mcp
-    except ImportError:
-        typer.echo(
-            "MCP support not available. Install with:\n"
-            "  pip install sourcecode[mcp]",
-            err=True,
-        )
-        raise typer.Exit(code=1)
+    from sourcecode.mcp.server import mcp as _mcp
 
     log = logging.getLogger(__name__)
     log.info("sourcecode-mcp starting (stdio transport)")
@@ -2513,21 +2706,44 @@ def mcp_serve() -> None:
 @mcp_app.command("init")
 def mcp_init(
     yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt."),
+    target: Optional[str] = typer.Option(
+        None,
+        "--target",
+        "-t",
+        help="Target client: claude-desktop | cursor. Default: auto-detect all.",
+    ),
 ) -> None:
     """Setup MCP integration for Claude Desktop, Cursor, and other clients.
 
     \b
     Detects installed MCP clients, backs up their config files, and safely
     inserts the sourcecode server entry. Fully idempotent — safe to re-run.
+
+    \b
+    Examples:
+      sourcecode mcp init
+      sourcecode mcp init --target claude-desktop
+      sourcecode mcp init --target cursor --yes
     """
-    from sourcecode.mcp.onboarding.detector import detect_clients
+    from sourcecode.mcp.onboarding.detector import detect_clients, is_client_running
     from sourcecode.mcp.onboarding.planner import build_install_plan
     from sourcecode.mcp.onboarding import backup, applier
 
     typer.echo("Detecting MCP clients...")
     typer.echo("")
 
-    clients = detect_clients()
+    all_clients = detect_clients()
+
+    if target:
+        target_slug = target.lower()
+        clients = [c for c in all_clients if c.slug == target_slug]
+        if not clients:
+            valid = ", ".join(c.slug for c in all_clients)
+            typer.echo(f"Unknown target '{target}'. Valid: {valid}", err=True)
+            raise typer.Exit(code=1)
+    else:
+        clients = all_clients
+
     if not clients:
         typer.echo("No MCP clients found on this system.")
         typer.echo("")
@@ -2603,36 +2819,81 @@ def mcp_init(
     typer.echo("MCP integration active.")
     typer.echo("")
 
-    restart_needed = [a.client.name for a in actionable if not a.will_create_file]
-    if restart_needed:
-        typer.echo(f"  Restart {', '.join(restart_needed)} to apply changes.")
+    # Post-write: validate config and warn if client not running
+    for a in actionable:
+        if not is_client_running(a.client):
+            typer.echo(
+                f"  ⚠ Config written but {a.client.name} is not running. "
+                f"Start {a.client.name} and run sourcecode mcp status to verify.",
+                err=False,
+            )
+        else:
+            restart_msg = "" if a.will_create_file else f" Restart {a.client.name} to apply."
+            typer.echo(f"  ✓ {a.client.name} is running.{restart_msg}")
+
+    typer.echo("")
     typer.echo("  Remove:  sourcecode mcp remove")
 
 
 @mcp_app.command("status")
 def mcp_status() -> None:
-    """Show MCP integration status for all detected clients."""
-    from sourcecode.mcp.onboarding.detector import detect_clients
+    """Show MCP integration status: dependencies, config files, and connectivity."""
+    from sourcecode.mcp.onboarding.detector import detect_clients, is_client_running
     from sourcecode.mcp.onboarding import applier
 
-    clients = detect_clients()
-    typer.echo("MCP Integration Status")
+    sep = "─" * 46
+
+    typer.echo("MCP Status")
+    typer.echo(sep)
+
+    # Stage 1: Dependencies
+    try:
+        import mcp as _mcp_pkg  # noqa: F401
+        typer.echo("Dependencies  ✓ installed")
+    except ImportError:
+        typer.echo("Dependencies  ✗ missing")
+        typer.echo("  Fix: pip install sourcecode[mcp]")
     typer.echo("")
 
+    clients = detect_clients()
     if not clients:
         typer.echo("  No MCP clients detected on this system.")
+        typer.echo(sep)
+        typer.echo("  Setup:   sourcecode mcp init")
         raise typer.Exit(code=0)
 
+    # Stage 2: Config files
+    typer.echo("Config files")
     for client in clients:
         if not client.app_installed:
-            typer.echo(f"  ○  {client.name:<18} not found")
+            typer.echo(f"  {client.name:<20} ✗ not found")
+            typer.echo(f"    Expected: {client.config_path}")
+            typer.echo(f"    Fix:      sourcecode mcp init --target {client.slug}")
             continue
         config = applier.read_config(client.config_path)
         if applier.is_installed(config):
-            typer.echo(f"  ✓  {client.name:<18} configured   {client.config_path}")
+            typer.echo(f"  {client.name:<20} ✓ configured   {client.config_path}")
         else:
-            typer.echo(f"  ✗  {client.name:<18} not configured")
+            typer.echo(f"  {client.name:<20} ✗ not configured")
+            typer.echo(f"    Fix: sourcecode mcp init --target {client.slug}")
     typer.echo("")
+
+    # Stage 3: Connectivity
+    typer.echo("Connectivity")
+    any_installed = any(c.app_installed for c in clients)
+    if not any_installed:
+        typer.echo("  (no clients to check)")
+    else:
+        for client in clients:
+            if not client.app_installed:
+                continue
+            if is_client_running(client):
+                typer.echo(f"  {client.name:<20} ✓ running")
+            else:
+                typer.echo(f"  {client.name:<20} ✗ not running")
+                typer.echo(f"    Fix: open {client.name}, then run sourcecode mcp status")
+
+    typer.echo(sep)
     typer.echo("  Setup:   sourcecode mcp init")
     typer.echo("  Remove:  sourcecode mcp remove")
 

sourcecode/confidence_analyzer.py

@@ -175,7 +175,7 @@ class ConfidenceAnalyzer:
         if dep_summary is None or not dep_summary.requested:
             gaps.append(AnalysisGap(
                 area="dependencies",
-                reason="Dependencies not analyzed — run with --dependencies for full context",
+                reason="Dependencies not analyzed — use the full analyze command with dependency flags for complete context",
                 impact="medium",
             ))
         elif dep_summary.requested and dep_summary.total_count == 0:

sourcecode/mcp/onboarding/detector.py

@@ -2,25 +2,43 @@
 from __future__ import annotations
 
 import os
+import subprocess
 import sys
 from dataclasses import dataclass
 from pathlib import Path
+from typing import Any, Dict, List
 
 
-# Registry of known MCP clients and their config paths per platform.
-# Keys: "darwin", "linux", "win32" — matching sys.platform values.
-_CLIENT_REGISTRY: dict[str, dict[str, str]] = {
-    "Claude Desktop": {
-        "darwin": "~/Library/Application Support/Claude/claude_desktop_config.json",
-        "linux": "~/.config/Claude/claude_desktop_config.json",
-        "win32": "{APPDATA}/Claude/claude_desktop_config.json",
+_CLIENT_REGISTRY: List[Dict[str, Any]] = [
+    {
+        "name": "Claude Desktop",
+        "slug": "claude-desktop",
+        "paths": {
+            "darwin": "~/Library/Application Support/Claude/claude_desktop_config.json",
+            "linux": "~/.config/Claude/claude_desktop_config.json",
+            "win32": "{APPDATA}/Claude/claude_desktop_config.json",
+        },
+        "process": {
+            "darwin": "Claude",
+            "linux": "claude-desktop",
+            "win32": "Claude",
+        },
     },
-    "Cursor": {
-        "darwin": "~/.cursor/mcp.json",
-        "linux": "~/.cursor/mcp.json",
-        "win32": "{USERPROFILE}/.cursor/mcp.json",
+    {
+        "name": "Cursor",
+        "slug": "cursor",
+        "paths": {
+            "darwin": "~/.cursor/mcp.json",
+            "linux": "~/.cursor/mcp.json",
+            "win32": "{USERPROFILE}/.cursor/mcp.json",
+        },
+        "process": {
+            "darwin": "Cursor",
+            "linux": "cursor",
+            "win32": "Cursor",
+        },
     },
-}
+]
 
 
 @dataclass(frozen=True)
@@ -28,6 +46,8 @@ class MCPClient:
     name: str
     config_path: Path
     app_installed: bool  # True if the config file (or its parent dir) exists
+    process_name: str    # OS process name for connectivity check
+    slug: str            # --target identifier (e.g. "claude-desktop")
 
 
 def _resolve(template: str) -> Path:
@@ -44,16 +64,41 @@ def detect_clients() -> list[MCPClient]:
     """Return all known MCP clients with their resolved config paths."""
     plat = sys.platform
     clients: list[MCPClient] = []
-    for name, paths in _CLIENT_REGISTRY.items():
-        template = paths.get(plat) or paths.get("linux")
+    for entry in _CLIENT_REGISTRY:
+        paths: Dict[str, str] = entry["paths"]
+        processes: Dict[str, str] = entry["process"]
+        template = paths.get(plat) or paths.get("linux", "")
         if not template:
             continue
         config_path = _resolve(template)
-        # Consider client "installed" if its config file OR parent app dir exists.
         app_installed = config_path.exists() or config_path.parent.exists()
+        process_name = processes.get(plat) or processes.get("linux", "")
         clients.append(MCPClient(
-            name=name,
+            name=entry["name"],
             config_path=config_path,
             app_installed=app_installed,
+            process_name=process_name,
+            slug=entry["slug"],
         ))
     return clients
+
+
+def is_client_running(client: MCPClient) -> bool:
+    """True if the client process is currently running."""
+    if not client.process_name:
+        return False
+    try:
+        if sys.platform == "win32":
+            result = subprocess.run(
+                ["tasklist", "/fi", f"imagename eq {client.process_name}.exe"],
+                capture_output=True, text=True, timeout=5,
+            )
+            return client.process_name.lower() in result.stdout.lower()
+        else:
+            result = subprocess.run(
+                ["pgrep", "-x", client.process_name],
+                capture_output=True, timeout=5,
+            )
+            return result.returncode == 0
+    except Exception:
+        return False

sourcecode/mcp/runner.py

@@ -6,14 +6,18 @@ lookup, no process fork, no stdout encoding issues.
 """
 from __future__ import annotations
 
+import json
+from typing import Any
+
 from typer.testing import CliRunner
 
 _runner = CliRunner()
 
 
-def run_command(args: list[str]) -> str:
-    """Invoke a sourcecode CLI command in-process and return stdout.
+def run_command(args: list[str]) -> Any:
+    """Invoke a sourcecode CLI command in-process and return parsed output.
 
+    Returns parsed JSON dict when output is valid JSON, else the raw string.
     Raises RuntimeError on non-zero exit or empty output.
     """
     from sourcecode.cli import _detected_path, _preprocess_args, app
@@ -37,4 +41,7 @@ def run_command(args: list[str]) -> str:
             f"Args: {args}"
         )
 
-    return output
+    try:
+        return json.loads(output)
+    except json.JSONDecodeError:
+        return output

sourcecode/mcp/server.py

@@ -4,27 +4,24 @@ Exposes sourcecode capabilities as MCP tools. Each tool maps to a CLI command
 and delegates execution to the in-process runner — no subprocess, no binary
 lookup, same process as the CLI.
 
-All tools return the canonical contract:
-  {"success": bool, "data": str | None, "error": {"code": str, "message": str} | None}
+All tools return:
+  {"success": bool, "data": dict | str | None, "error": {"code": str, "message": str} | None}
+data is the parsed JSON object from the CLI output, not a shell string.
 """
 from __future__ import annotations
 
-from typing import Literal
+import os
+from typing import Any
 
 from mcp.server.fastmcp import FastMCP
 
+from sourcecode import __version__
 from sourcecode.mcp.runner import run_command
 
-mcp = FastMCP("sourcecode")
+mcp = FastMCP("sourcecode", version=__version__)
 
-_PREPARE_CONTEXT_TASKS = frozenset({
-    "delta", "review-pr", "fix-bug", "onboard",
-    "explain", "refactor", "generate-tests",
-})
-_TELEMETRY_ACTIONS = frozenset({"status", "enable", "disable"})
 
-
-def _ok(data: str) -> dict:
+def _ok(data: Any) -> dict:
     return {"success": True, "data": data, "error": None}
 
 
@@ -40,108 +37,120 @@ def _execute(args: list[str]) -> dict:
 
 
 @mcp.tool()
-def compact(path: str, git_context: bool = False) -> dict:
-    """Compact analysis of a repository (~1000-3000 tokens).
+def get_compact_context(repo_path: str = ".") -> dict:
+    """High-signal summary of a repository (~1000-3000 tokens).
 
-    Maps to: sourcecode <path> --compact [--git-context]
+    Maps to: sourcecode <repo_path> --compact
+    Returns: stacks, entry points, dependency summary, confidence, gaps.
+    repo_path: absolute path to the repository (default: current working directory).
     """
-    if not isinstance(path, str):
-        return _err("path must be a string", "INVALID_ARGUMENT")
-    if not isinstance(git_context, bool):
-        return _err("git_context must be boolean", "INVALID_ARGUMENT")
-    args = [path, "--compact"]
-    if git_context:
-        args.append("--git-context")
-    return _execute(args)
+    if not isinstance(repo_path, str):
+        return _err("repo_path must be a string", "INVALID_ARGUMENT")
+    return _execute([repo_path, "--compact"])
 
 
 @mcp.tool()
-def agent(path: str, git_context: bool = False) -> dict:
+def get_agent_context(repo_path: str = ".") -> dict:
     """Agent-optimised analysis: identity, entry points, dependencies, gaps.
 
-    Maps to: sourcecode <path> --agent [--git-context]
+    Maps to: sourcecode <repo_path> --agent
+    Returns: structured noise-free JSON for AI agents.
+    repo_path: absolute path to the repository (default: current working directory).
     """
-    if not isinstance(path, str):
-        return _err("path must be a string", "INVALID_ARGUMENT")
-    if not isinstance(git_context, bool):
-        return _err("git_context must be boolean", "INVALID_ARGUMENT")
-    args = [path, "--agent"]
-    if git_context:
-        args.append("--git-context")
-    return _execute(args)
+    if not isinstance(repo_path, str):
+        return _err("repo_path must be a string", "INVALID_ARGUMENT")
+    return _execute([repo_path, "--agent"])
 
 
 @mcp.tool()
-def prepare_context(
-    task: Literal[
-        "delta", "review-pr", "fix-bug", "onboard",
-        "explain", "refactor", "generate-tests",
-    ],
-    path: str,
-) -> dict:
-    """Task-specific context for AI coding agents.
-
-    Maps to: sourcecode prepare-context <task> <path>
-
-    task must be one of:
-      explain        Architecture, entry points, key dependencies
-      fix-bug        Risk-ranked files, suspected areas, annotations
-      refactor       Structural issues, improvement opportunities
-      generate-tests Untested source files, test gap analysis
-      onboard        Full project context for new agents/developers
-      review-pr      PR diff with runtime signals and security impact
-      delta          Incremental context: git-changed files only
+def get_endpoints(repo_path: str = ".") -> dict:
+    """REST API endpoint surface extraction from Java source files.
+
+    Maps to: sourcecode endpoints <repo_path>
+    Returns: endpoints list with method, path, controller, handler, required_permission;
+             total count and undocumented count.
+    repo_path: absolute path to the repository (default: current working directory).
     """
-    if task not in _PREPARE_CONTEXT_TASKS:
-        return _err(
-            f"task must be one of {sorted(_PREPARE_CONTEXT_TASKS)}",
-            "INVALID_ARGUMENT",
-        )
-    if not isinstance(path, str):
-        return _err("path must be a string", "INVALID_ARGUMENT")
-    return _execute(["prepare-context", task, path])
+    if not isinstance(repo_path, str):
+        return _err("repo_path must be a string", "INVALID_ARGUMENT")
+    return _execute(["endpoints", repo_path])
 
 
 @mcp.tool()
-def repo_ir(path: str) -> dict:
-    """Deterministic symbol-level IR for Java repositories.
+def get_module_context(repo_path: str = ".", module: str = "") -> dict:
+    """Compact analysis of a specific module or subdirectory within a repository.
 
-    Maps to: sourcecode repo-ir <path>
-    Output is JSON: graph{nodes,edges}, analysis, impact, subsystems, change_set.
+    Maps to: sourcecode <repo_path>/<module> --compact
+    repo_path: absolute path to the repository root.
+    module: subdirectory name relative to repo_path (e.g. 'src/auth', 'api', 'core').
     """
-    if not isinstance(path, str):
-        return _err("path must be a string", "INVALID_ARGUMENT")
-    return _execute(["repo-ir", path])
+    if not isinstance(repo_path, str):
+        return _err("repo_path must be a string", "INVALID_ARGUMENT")
+    if not isinstance(module, str) or not module.strip():
+        return _err("module must be a non-empty string", "INVALID_ARGUMENT")
+    module_path = os.path.join(repo_path, module)
+    return _execute([module_path, "--compact"])
 
 
 @mcp.tool()
-def version() -> dict:
-    """Return the installed sourcecode version.
+def get_delta(repo_path: str = ".", since: str = "HEAD~1") -> dict:
+    """Incremental context: git-changed files since a reference commit.
 
-    Maps to: sourcecode version
+    Maps to: sourcecode prepare-context delta <repo_path> --since <since>
+    repo_path: absolute path to the repository (default: current working directory).
+    since: git ref to diff against (e.g. HEAD~3, main, origin/main).
     """
-    return _execute(["version"])
+    if not isinstance(repo_path, str):
+        return _err("repo_path must be a string", "INVALID_ARGUMENT")
+    if not isinstance(since, str) or not since.strip():
+        return _err("since must be a non-empty git ref", "INVALID_ARGUMENT")
+    return _execute(["prepare-context", "delta", repo_path, "--since", since])
 
 
 @mcp.tool()
-def config() -> dict:
-    """Show sourcecode configuration (version, telemetry state, config path).
+def get_ir_summary(repo_path: str = ".") -> dict:
+    """Deterministic symbol-level IR summary for Java repositories.
 
-    Maps to: sourcecode config
+    Maps to: sourcecode repo-ir <repo_path> --summary-only
+    Returns: analysis summary, impact, and change_set — omits full graph nodes/edges.
+    repo_path: absolute path to the repository (default: current working directory).
     """
-    return _execute(["config"])
+    if not isinstance(repo_path, str):
+        return _err("repo_path must be a string", "INVALID_ARGUMENT")
+    return _execute(["repo-ir", repo_path, "--summary-only"])
 
 
 @mcp.tool()
-def telemetry(action: Literal["status", "enable", "disable"]) -> dict:
-    """Manage telemetry settings.
+def fix_bug_context(repo_path: str = ".", symptom: str = "") -> dict:
+    """Risk-ranked files for bug investigation, optionally focused by symptom.
+
+    Maps to: sourcecode prepare-context fix-bug <repo_path> [--symptom <symptom>]
+    Includes compact_base: security_surface, transactional_boundaries, spring_profiles.
+    repo_path: absolute path to the repository (default: current working directory).
+    symptom: optional error message or class name to focus the file ranking
+             (e.g. "NullPointerException in EstructuraRrHhRestController").
+    """
+    if not isinstance(repo_path, str):
+        return _err("repo_path must be a string", "INVALID_ARGUMENT")
+    args = ["prepare-context", "fix-bug", repo_path]
+    if symptom and isinstance(symptom, str) and symptom.strip():
+        args.extend(["--symptom", symptom.strip()])
+    return _execute(args)
+
 
-    Maps to: sourcecode telemetry <status|enable|disable>
-    action must be one of: status, enable, disable
+@mcp.tool()
+def review_pr_context(repo_path: str = ".", since: str = "") -> dict:
+    """Execution paths and risk analysis for changed files in a pull request.
+
+    Maps to: sourcecode prepare-context review-pr <repo_path> [--since <since>]
+    Returns: compact_base + execution_paths (diff-scoped) + hotspots for changed files.
+    repo_path: absolute path to the repository (default: current working directory).
+    since: git ref to diff against (e.g. HEAD~3, main, origin/main).
+           If omitted, diffs against uncommitted changes or HEAD~1 fallback.
     """
-    if action not in _TELEMETRY_ACTIONS:
-        return _err(
-            f"action must be one of {sorted(_TELEMETRY_ACTIONS)}",
-            "INVALID_ARGUMENT",
-        )
-    return _execute(["telemetry", action])
+    if not isinstance(repo_path, str):
+        return _err("repo_path must be a string", "INVALID_ARGUMENT")
+    args = ["prepare-context", "review-pr", repo_path]
+    if since and isinstance(since, str) and since.strip():
+        args.extend(["--since", since.strip()])
+    return _execute(args)

sourcecode/prepare_context.py

@@ -322,7 +322,7 @@ class TaskOutput:
     relevant_files: list[RelevantFile]
     suspected_areas: list[str]
     improvement_opportunities: list[str]
-    test_gaps: list[str]
+    test_gaps: list  # list[str] for non-Java; list[dict] for Java (has path/public_method_count/has_spring_annotations)
     key_dependencies: list[dict[str, Any]]
     code_notes_summary: Optional[dict[str, Any]]
     limitations: list[str]
@@ -378,6 +378,15 @@ class TaskOutput:
     uncommitted_changes: list[dict] = field(default_factory=list)
     # transparency: explicit diff scope for every command
     analysis_scope: dict = field(default_factory=dict)
+    # compact_base fields — enriched in all prepare-context tasks (Fix #1)
+    security_surface: Optional[dict] = None
+    mybatis: Optional[dict] = None
+    transactional_boundaries: Optional[dict] = None
+    spring_profiles_info: Optional[dict] = None
+    angular_analysis: Optional[dict] = None
+    deployment_risks: list[str] = field(default_factory=list)
+    deployment: Optional[dict] = None
+    entry_points_structured: Optional[dict] = None
 
 
 @dataclass
@@ -902,6 +911,53 @@ class TaskContextBuilder:
         from sourcecode.context_summarizer import ContextSummarizer
         sm.context_summary = ContextSummarizer(self.root).generate(sm)
 
+        # ── 3b. Compact-base enrichment (Fix #1) ───────────────────────────
+        # Enrich sm with Java-specific fields — same as main CLI pipeline
+        _java_stack_cb = next((s for s in stacks if s.stack == "java"), None)
+        if _java_stack_cb is not None:
+            sm.language_version = getattr(_java_stack_cb, "language_version", None) or None
+            sm.spring_profiles = getattr(_java_stack_cb, "spring_profiles", []) or []
+            sm.app_server_hint = getattr(_java_stack_cb, "app_server_hint", None) or None
+            sm.packaging = getattr(_java_stack_cb, "packaging", None) or None
+
+        # Import serializer helpers — same functions used by --compact
+        from sourcecode.serializer import (
+            _security_surface_from_eps as _cb_sec_fn,
+            _mybatis_pairing as _cb_mybatis_fn,
+            _transactional_summary as _cb_trans_fn,
+            _spring_profiles_context as _cb_spring_fn,
+            _angular_analysis as _cb_angular_fn,
+            _project_deployment_risks as _cb_deploy_risks_fn,
+            _bootstrap_structured as _cb_bootstrap_fn,
+            _spring_boot_version as _cb_sbver_fn,
+            _jndi_datasources as _cb_jndi_fn,
+        )
+
+        _cb_security_surface = _cb_sec_fn(entry_points, root=self.root, file_paths=all_paths)
+        _cb_mybatis = _cb_mybatis_fn(sm)
+        _cb_transactional = _cb_trans_fn(sm)
+        _cb_spring_profiles = _cb_spring_fn(sm)
+        _cb_angular = _cb_angular_fn(sm)
+        _cb_deploy_risks = _cb_deploy_risks_fn(sm)
+        _cb_bootstrap = _cb_bootstrap_fn(entry_points)
+
+        _cb_sb_ver = _cb_sbver_fn(sm)
+        _cb_deployment: Optional[dict] = None
+        _cb_packaging = getattr(sm, "packaging", None)
+        _cb_app_server = getattr(sm, "app_server_hint", None)
+        if _cb_sb_ver or _cb_packaging or _cb_app_server:
+            _cb_deployment = {}
+            if _cb_sb_ver:
+                _cb_deployment["spring_boot_version"] = _cb_sb_ver
+            if _cb_packaging:
+                _cb_deployment["packaging"] = _cb_packaging
+            if _cb_app_server:
+                _cb_deployment["app_server_hint"] = _cb_app_server
+        _cb_jndi = _cb_jndi_fn(sm)
+        if _cb_jndi:
+            _cb_deployment = _cb_deployment or {}
+            _cb_deployment["jndi_datasources"] = _cb_jndi
+
         # ── 4. Dependencies ────────────────────────────────────────────────
         key_dependencies: list[dict[str, Any]] = []
         limitations: list[str] = []
@@ -1647,42 +1703,107 @@ class TaskContextBuilder:
                     symptom_hint = _fe_redirect
 
         # ── 7. Test gaps (generate-tests only) ────────────────────────────
-        test_gaps: list[str] = []
+        test_gaps: list = []
         if task_name == "generate-tests" and not fast:
-            def _normalize_test_stem(stem: str) -> str:
-                # Java: FooTest / FooTests → Foo; TestFoo → Foo
-                if stem.endswith("Tests"):
-                    return stem[:-5]
-                if stem.endswith("Test"):
-                    return stem[:-4]
-                if stem.startswith("Test") and len(stem) > 4 and stem[4].isupper():
-                    return stem[4:]
-                # Python/JS: test_foo / foo_test
-                return stem.removeprefix("test_").removesuffix("_test")
-
-            # Patterns excluded from test_gaps by default (IMP-1): tooling config
-            # files have no business logic to test. --include-config overrides.
-            _CONFIG_EXCLUDE_PATTERNS = (
-                ".eslintrc", ".prettierrc", "eslint.config",
-                "karma.conf", "jest.config", "babel.config",
-                "webpack.config", "vite.config", "rollup.config",
-                "tsconfig", "angular.json", ".claude/",
-            )
+            if _is_java:
+                # Java-aware algorithm (Fix #2): find Service/RestController/Repository/Mapper
+                # files with no matching test pair in src/test/**
+                _JAVA_TARGET_SUFFIXES = (
+                    "Service.java", "RestController.java",
+                    "Repository.java", "Mapper.java",
+                )
+                # Build set of test stems (FooTest → Foo, FooIT → Foo, etc.)
+                _java_test_stems: set[str] = set()
+                for _tp in all_paths:
+                    if not _tp.endswith(".java"):
+                        continue
+                    if not self._is_test(_tp):
+                        continue
+                    _ts = Path(_tp).stem
+                    for _suf in ("Test", "IT", "Tests", "Spec"):
+                        if _ts.endswith(_suf):
+                            _ts = _ts[: -len(_suf)]
+                            break
+                    if _ts.startswith("Test") and len(_ts) > 4 and _ts[4].isupper():
+                        _ts = _ts[4:]
+                    _java_test_stems.add(_ts)
+
+                _java_candidates: list[dict] = []
+                for _p in all_paths:
+                    if not any(_p.endswith(_s) for _s in _JAVA_TARGET_SUFFIXES):
+                        continue
+                    if self._is_test(_p):
+                        continue
+                    _pnorm = _p.replace("\\", "/")
+                    if "src/main/resources" in _pnorm or "target/" in _pnorm:
+                        continue
+                    if Path(_p).stem in _java_test_stems:
+                        continue
+                    _pub_count = 0
+                    _ann_count = 0
+                    try:
+                        _content = (self.root / _p).read_text(
+                            encoding="utf-8", errors="replace"
+                        )[:16000]
+                        _pub_count = _content.count("public ")
+                        _ann_count = (
+                            _content.count("@Transactional")
+                            + _content.count("@RequestMapping")
+                            + _content.count("@GetMapping")
+                            + _content.count("@PostMapping")
+                            + _content.count("@PutMapping")
+                            + _content.count("@DeleteMapping")
+                        )
+                    except OSError:
+                        pass
+                    _java_candidates.append({
+                        "path": _p,
+                        "public_method_count": _pub_count,
+                        "has_spring_annotations": _ann_count > 0,
+                        "_rank": _pub_count + _ann_count * 2,
+                    })
+
+                _java_candidates.sort(key=lambda x: -x["_rank"])
+                test_gaps = [
+                    {
+                        "path": c["path"],
+                        "public_method_count": c["public_method_count"],
+                        "has_spring_annotations": c["has_spring_annotations"],
+                    }
+                    for c in _java_candidates
+                ]
+            else:
+                # Non-Java algorithm (unchanged)
+                def _normalize_test_stem(stem: str) -> str:
+                    if stem.endswith("Tests"):
+                        return stem[:-5]
+                    if stem.endswith("Test"):
+                        return stem[:-4]
+                    if stem.startswith("Test") and len(stem) > 4 and stem[4].isupper():
+                        return stem[4:]
+                    return stem.removeprefix("test_").removesuffix("_test")
+
+                _CONFIG_EXCLUDE_PATTERNS = (
+                    ".eslintrc", ".prettierrc", "eslint.config",
+                    "karma.conf", "jest.config", "babel.config",
+                    "webpack.config", "vite.config", "rollup.config",
+                    "tsconfig", "angular.json", ".claude/",
+                )
 
-            def _is_config_file(p: str) -> bool:
-                name = Path(p).name.lower()
-                norm = p.replace("\\", "/")
-                return any(pat in name or pat in norm for pat in _CONFIG_EXCLUDE_PATTERNS)
-
-            test_stems = {_normalize_test_stem(Path(p).stem) for p in test_set}
-            untested = [
-                p for p in source_set
-                if Path(p).stem not in test_stems
-                and not any(pen in p for pen in spec.ranking_penalties)
-                and (include_config or not _is_config_file(p))
-            ]
-            untested.sort(key=lambda p: (len(p.split("/")), p))
-            test_gaps = untested[:15]
+                def _is_config_file(p: str) -> bool:
+                    name = Path(p).name.lower()
+                    norm = p.replace("\\", "/")
+                    return any(pat in name or pat in norm for pat in _CONFIG_EXCLUDE_PATTERNS)
+
+                test_stems = {_normalize_test_stem(Path(p).stem) for p in test_set}
+                untested = [
+                    p for p in source_set
+                    if Path(p).stem not in test_stems
+                    and not any(pen in p for pen in spec.ranking_penalties)
+                    and (include_config or not _is_config_file(p))
+                ]
+                untested.sort(key=lambda p: (len(p.split("/")), p))
+                test_gaps = untested[:15]
 
         # ── 8. Confidence + gaps ──────────────────────────────────────────────
         from sourcecode.confidence_analyzer import ConfidenceAnalyzer
@@ -1809,6 +1930,15 @@ class TaskContextBuilder:
             diff_validation_status=_delta_baseline.get("diff_validation_status") if task_name == "delta" else None,
             warnings=_delta_baseline.get("warnings", []) if task_name == "delta" else [],
             symptom_hint=symptom_hint if task_name == "fix-bug" else None,
+            # compact_base fields (Fix #1) — superset of --compact for all tasks
+            security_surface=_cb_security_surface,
+            mybatis=_cb_mybatis,
+            transactional_boundaries=_cb_transactional,
+            spring_profiles_info=_cb_spring_profiles,
+            angular_analysis=_cb_angular,
+            deployment_risks=_cb_deploy_risks,
+            deployment=_cb_deployment,
+            entry_points_structured=_cb_bootstrap,
         )
 
     def render_prompt(self, output: TaskOutput) -> str:

sourcecode/serializer.py

@@ -2012,7 +2012,7 @@ def agent_view(sm: SourceMap, *, full: bool = False) -> dict[str, Any]:
         if not sm.dependency_summary or not sm.dependency_summary.requested:
             analysis_gaps.append({
                 "area": "dependencies",
-                "reason": "Dependencies not analyzed — add --dependencies for full context",
+                "reason": "Dependencies not analyzed — use the full analyze command with dependency flags for complete context",
                 "impact": "medium",
             })
 

{sourcecode-1.31.0.dist-info → sourcecode-1.31.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.31.0
+Version: 1.31.2
 Summary: Deterministic codebase context for AI coding agents
 License:                                  Apache License
                                    Version 2.0, January 2004
@@ -203,6 +203,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
 Requires-Python: >=3.9
+Requires-Dist: mcp>=1.0.0
 Requires-Dist: pathspec>=1.0
 Requires-Dist: ruamel-yaml>=0.18
 Requires-Dist: tomli>=2.0; python_version < '3.11'
@@ -224,7 +225,7 @@ Description-Content-Type: text/markdown
 
 **Deterministic, behavior-aware codebase context for AI agents and PR review.**
 
-![Version](https://img.shields.io/badge/version-1.31.0-blue)
+![Version](https://img.shields.io/badge/version-1.31.2-blue)
 ![Python](https://img.shields.io/badge/python-3.10%2B-green)
 
 ---
@@ -260,7 +261,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.31.0
+# sourcecode 1.31.2
 ```
 
 ---

{sourcecode-1.31.0.dist-info → sourcecode-1.31.2.dist-info}/RECORD

@@ -1,12 +1,12 @@
-sourcecode/__init__.py,sha256=MiA5_ZlVOCsJoykaFJRoZJpA8VwhlU7ns_GdhCt64L4,103
+sourcecode/__init__.py,sha256=BlIGNpIZ2KvAHJhMqzRGPET0plDw5AYOTlGs0F8h4hU,103
 sourcecode/adaptive_scanner.py,sha256=XffluXKzJUXrMtjEiAOnSNPZnztdIcts17T9ouHeID0,10521
 sourcecode/architecture_analyzer.py,sha256=MyBa0Hf5HmkudZQDLKrjcWDKETXETXl0mQX1swtTwAA,39091
 sourcecode/architecture_summary.py,sha256=z34_6v7cSwy98cof2UVciGho7SCrZ93tiqMmq5WNzRQ,20405
 sourcecode/ast_extractor.py,sha256=XgrZg2DcWcUm9r87cRG3KGO7IK2TIL_N-CvhSbUmmh4,49901
 sourcecode/classifier.py,sha256=-0t0HLc9L9UleMLfclfLM3AXhBjUb_AYyBPDbvgWtac,7755
-sourcecode/cli.py,sha256=wncSKjhpDuN5t-tU7vj-kY2x6FREFyXoRetZnUensMs,110219
+sourcecode/cli.py,sha256=qYMuo7DY6erJD5HwjU1Rot07xR54kXil4YzVytyU1Po,120897
 sourcecode/code_notes_analyzer.py,sha256=y1MJBnPZHYp4i6cQCXUb9ATIyifS_qMQWjw_8lPkpsU,9215
-sourcecode/confidence_analyzer.py,sha256=H9VHYRzZhqMFlSCZffjtsMUGYLnDvrq1g5FjzyQ1hxE,16381
+sourcecode/confidence_analyzer.py,sha256=ZUn-Nywi5TEQcuozqK_vfOyPT-a1dYYO42elAtVFV-k,16412
 sourcecode/context_scorer.py,sha256=QpChSpsmaAYz91rXA4Ue5xzQmNz_ZboZN09YOHScq1U,14679
 sourcecode/context_summarizer.py,sha256=CiQrfBEzun949bWvmLabWoj2HhPn6Lw62ofqnsy0FlQ,6503
 sourcecode/contract_model.py,sha256=nRxJKPMs1VHwFTa8AVXhGmaLjti3Lr2sjHDpWgv1bfE,3917
@@ -22,7 +22,7 @@ sourcecode/git_analyzer.py,sha256=0Gyj-vMpIIN4nfriKXVRouNYBeJ59s6pQDX2Xu9Pq-U,13
 sourcecode/graph_analyzer.py,sha256=iUK-7pSV-cvGqqD2hENdYmhnm0wcXFEyK-xnu5ul8OU,62515
 sourcecode/metrics_analyzer.py,sha256=m0ENgtqKeBL17kUIK3fmGkgo7UfXBNHxCMj0H_Y5K7c,22750
 sourcecode/pr_comment_renderer.py,sha256=smHslxiG14lrytCkq5nFrFu-qTHgA-t-LFYfdrfjz2o,14423
-sourcecode/prepare_context.py,sha256=QNCl8uKk9PQpgXxPHBNSDXXkc1s2wTZwU6H0REC5Qms,173487
+sourcecode/prepare_context.py,sha256=vmZnoFneipRCE-hP6drvhqNXb3FwLrVub449e0MzT0Y,179908
 sourcecode/progress.py,sha256=qn30sWaHOkjTgXsSBmiPkz7Rsbwc5oSlIe6JNEMYp_k,3149
 sourcecode/ranking_engine.py,sha256=ZAucq_YX2KkWUuAZf4P0lhtQ_38vEFnUhuGtSZd1S0E,12970
 sourcecode/redactor.py,sha256=xuGcadGEHaPw4qZXlMDvzMCsr4VOkdp3oBQptHyJk8c,2884
@@ -33,7 +33,7 @@ sourcecode/runtime_classifier.py,sha256=zWX3r3HCKHc-qtIobErOa8aKMmaoPYREtJKvPcBG
 sourcecode/scanner.py,sha256=WdOQ78mMzjR1NjmKTlbxdgwinnCTfAhxCVLBEFQiFHU,8899
 sourcecode/schema.py,sha256=fj3BZ3IcnNV4j21BFIEvz8Qnw_vZoqIbzzRg-qQ-nd0,24530
 sourcecode/semantic_analyzer.py,sha256=12TwXYkYbDcBdu0heX_EmfPM2EkO8a_r5osf0SaeQbs,88956
-sourcecode/serializer.py,sha256=FM4xklb9Ywg9KNdNpo8QXR50izuml5FkbeQgL2uS1HY,111611
+sourcecode/serializer.py,sha256=KHVqwUK53axF10detPzqgmIY2P31rjLLJ_9T9Eyqp-E,111647
 sourcecode/summarizer.py,sha256=lPlKhMh28nueXkPo2xKeD3DUFYVGRlJMIdY-8TSM-ls,17486
 sourcecode/tree_utils.py,sha256=8GAkIfQAsvtEudIeW1l4ooH_oRtrWR8cpJQJsEa_Pfw,2093
 sourcecode/workspace.py,sha256=X_6NmNnitvT3_38V-JDChydo_sR68s249hLFlrQskU0,8271
@@ -59,12 +59,12 @@ sourcecode/detectors/systems.py,sha256=nYaKbGDFu0EOXFcd_1doWFT3tTUdkbxc2DjHUF5Tc
 sourcecode/detectors/terraform.py,sha256=cxORPR_zVLOJpHlh4e9JnFpkQsn_UnqMMom5yG65hZ4,1693
 sourcecode/detectors/tooling.py,sha256=8CKbtxwQoABP-WyBRNmdAmHDOvAH57AR1cF4UKuWEdQ,2074
 sourcecode/mcp/__init__.py,sha256=XU4HfRGbdid8wdUA0x_4f7uKZD1z3mv_XUY_WU_T9Mw,179
-sourcecode/mcp/runner.py,sha256=B167PyUBUwAJC6stKRCd3KHpmrpZOMsAA3gOtIuUauU,1186
-sourcecode/mcp/server.py,sha256=grK87-zeJ98W-DIXqaNg_PXGecFB_WzooKkyQcjJDa0,4480
+sourcecode/mcp/runner.py,sha256=7PnFjKYbgxFeDnqVeSntXHxZX7ZtK3-krDkEuVjI24M,1386
+sourcecode/mcp/server.py,sha256=01_b0MZnv4Yq2ES3FJSrqp1AJwCVdLVwOzQUVo3BtxY,6322
 sourcecode/mcp/onboarding/__init__.py,sha256=sj2PWqEBmMc4zBNkomg89WtL0M6S7A9yb7_wAuSWNP4,66
 sourcecode/mcp/onboarding/applier.py,sha256=yfSMT0NKdZsjavtLkC8yQ7OtkfepOl5IXGByqg6bdEY,1894
 sourcecode/mcp/onboarding/backup.py,sha256=ihqGOR8QTX8HASRSEDyfFyXr5bkXrygPHamv4p9KTmk,1452
-sourcecode/mcp/onboarding/detector.py,sha256=lcBkERH1WlxTXGTKVtxKv1fvql4NgSnVxGftra-gMvE,1961
+sourcecode/mcp/onboarding/detector.py,sha256=kDc0U6kXMuq_GivqwKrgJzIVLVeoLr3RQl63ksW10I8,3327
 sourcecode/mcp/onboarding/planner.py,sha256=Fopg5f72FDiPfldF7NOxYjcBA_w8hi_jBJpSz39lPb8,1332
 sourcecode/telemetry/__init__.py,sha256=M0eQZFNkmJiLbI_oNP4QEXwVju1dQ2d4P-E1-Bw8PxE,3116
 sourcecode/telemetry/config.py,sha256=Pir0WHp4z-9Qclnn2NDZ3vwitqsMkOAJckmwjUSxrk4,1795
@@ -72,8 +72,8 @@ sourcecode/telemetry/consent.py,sha256=wLMvGNJeSSyZoNkQXpoUioY6mMv4Qdvuw7S9jAEWn
 sourcecode/telemetry/events.py,sha256=oEvvulfsv5GIDWG2174gSS6tNB95w38AIYiYeifGKlE,2294
 sourcecode/telemetry/filters.py,sha256=Asa71oRl7q3Wt_FMwuufIZJFzSYdgRNKS8LHCIyFeYE,4805
 sourcecode/telemetry/transport.py,sha256=KJeIPCPWMdmbCP3ySGs2iUlia34U6vWne2dZsUezesw,1560
-sourcecode-1.31.0.dist-info/METADATA,sha256=tp3EeSNMJlNOi0f6JNoXdDsfrQDbEm703TurOFj83kw,29057
-sourcecode-1.31.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-1.31.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-1.31.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-1.31.0.dist-info/RECORD,,
+sourcecode-1.31.2.dist-info/METADATA,sha256=CaHPC5ti8mv3vU8hOaq1vV5lvAHw8kPIH4IEvbk3x2k,29083
+sourcecode-1.31.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-1.31.2.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-1.31.2.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-1.31.2.dist-info/RECORD,,