sourcecode 1.31.0__tar.gz → 1.31.2__tar.gz

{sourcecode-1.31.0 → sourcecode-1.31.2}/PKG-INFO

@@ -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 → sourcecode-1.31.2}/README.md

@@ -2,7 +2,7 @@
 
 **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)
 
 ---
@@ -38,7 +38,7 @@ pipx install sourcecode
 
 ```bash
 sourcecode version
-# sourcecode 1.31.0
+# sourcecode 1.31.2
 ```
 
 ---

{sourcecode-1.31.0 → sourcecode-1.31.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "1.31.0"
+version = "1.31.2"
 description = "Deterministic codebase context for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -29,6 +29,7 @@ dependencies = [
     "pathspec>=1.0",
     "ruamel.yaml>=0.18",
     "tomli>=2.0; python_version < '3.11'",
+    "mcp>=1.0.0",
 ]
 
 [project.scripts]

{sourcecode-1.31.0 → sourcecode-1.31.2}/src/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-1.31.0 → sourcecode-1.31.2}/src/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-1.31.0 → sourcecode-1.31.2}/src/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-1.31.2/src/sourcecode/mcp/onboarding/detector.py

@@ -0,0 +1,104 @@
+"""Detect MCP-capable clients installed on the current machine."""
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Dict, List
+
+
+_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",
+        },
+    },
+    {
+        "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)
+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:
+    """Expand env vars in Windows-style {VAR} templates, then expanduser."""
+    result = template
+    for var in ("APPDATA", "LOCALAPPDATA", "USERPROFILE"):
+        val = os.environ.get(var, "")
+        if val:
+            result = result.replace(f"{{{var}}}", val)
+    return Path(result).expanduser()
+
+
+def detect_clients() -> list[MCPClient]:
+    """Return all known MCP clients with their resolved config paths."""
+    plat = sys.platform
+    clients: list[MCPClient] = []
+    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)
+        app_installed = config_path.exists() or config_path.parent.exists()
+        process_name = processes.get(plat) or processes.get("linux", "")
+        clients.append(MCPClient(
+            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-1.31.0 → sourcecode-1.31.2}/src/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