sourcecode 1.32.5__tar.gz → 1.32.7__tar.gz

{sourcecode-1.32.5 → sourcecode-1.32.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.32.5
+Version: 1.32.7
 Summary: Deterministic codebase context for AI coding agents
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm

{sourcecode-1.32.5 → sourcecode-1.32.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "1.32.5"
+version = "1.32.7"
 description = "Deterministic codebase context for AI coding agents"
 readme = "README.md"
 requires-python = ">=3.9"

{sourcecode-1.32.5 → sourcecode-1.32.7}/src/sourcecode/__init__.py

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

{sourcecode-1.32.5 → sourcecode-1.32.7}/src/sourcecode/cli.py

@@ -384,6 +384,18 @@ def _get_command_with_preprocessing(typer_instance: Any) -> Any:
     # Refresh help text at invocation time so it reflects current license state.
     cmd.help = _build_help_text()
 
+    # Add [Pro] badge to Pro-gated option help strings for free-tier users.
+    try:
+        from sourcecode.license import is_pro as _lp_is_pro
+    except Exception:
+        _lp_is_pro = False
+    if not _lp_is_pro:
+        _PRO_OPTS = {"full"}
+        for _param in cmd.params:
+            if getattr(_param, "name", None) in _PRO_OPTS and getattr(_param, "help", None):
+                if "[Pro]" not in _param.help:
+                    _param.help = _param.help + "  [dim][Pro][/dim]"
+
     _orig_cmd_main = cmd.main
 
     def _cmd_main(args: Optional[list[str]] = None, **kwargs: Any) -> Any:
@@ -1442,12 +1454,23 @@ def main(
         if dependency_analyzer is not None
         else None
     )
+    # Free-tier node cap: limit graph size to 10 nodes unless Pro.
+    _effective_max_nodes = max_nodes
+    try:
+        from sourcecode.license import is_pro as _lp_is_pro_gm
+    except Exception:
+        _lp_is_pro_gm = False
+    _FREE_NODE_CAP = 10
+    if not _lp_is_pro_gm and graph_analyzer is not None:
+        if _effective_max_nodes is None or _effective_max_nodes > _FREE_NODE_CAP:
+            _effective_max_nodes = _FREE_NODE_CAP
+
     module_graph = (
         graph_analyzer.merge_graphs(
             module_graphs,
             detail=graph_detail_typed,
             edge_kinds=parsed_graph_edges,
-            max_nodes=max_nodes,
+            max_nodes=_effective_max_nodes,
             entry_points=entry_points,
         )
         if graph_analyzer is not None
@@ -1567,6 +1590,15 @@ def main(
                 semantic_summary=sem_sum,
             )
 
+    # Free-tier node cap for --semantics: limit semantic_symbols to 10 unless Pro.
+    if semantic_analyzer is not None and sm.semantic_symbols:
+        try:
+            from sourcecode.license import is_pro as _lp_is_pro_sem
+        except Exception:
+            _lp_is_pro_sem = False
+        if not _lp_is_pro_sem and len(sm.semantic_symbols) > _FREE_NODE_CAP:
+            sm = replace(sm, semantic_symbols=sm.semantic_symbols[:_FREE_NODE_CAP])
+
     # Runtime architecture — classify workspace packages for structural summaries
     if workspace_analysis.workspaces:
         from sourcecode.runtime_classifier import RuntimeClassifier
@@ -3721,6 +3753,24 @@ def config_cmd() -> None:
     typer.echo("  sourcecode telemetry status")
 
 
+# ── cold-start (RIS bootstrap for external MCP and agents) ───────────────────
+
+@app.command("cold-start")
+def cold_start_cmd(
+    path: Path = typer.Argument(Path("."), help="Repository path (default: current directory)"),
+) -> None:
+    """Output Repository Intelligence Snapshot bootstrap context as JSON.
+
+    Returns instantly from persisted RIS — zero re-analysis cost.
+    status: cold_start_ready | cold_start_stale | no_ris
+    """
+    import json as _json
+    from sourcecode.ris import get_cold_start_context as _gcs
+    target = Path(path).resolve()
+    result = _gcs(target)
+    typer.echo(_json.dumps(result, indent=2, ensure_ascii=False))
+
+
 # ── analyze (legacy alias) ────────────────────────────────────────────────────
 
 @app.command("analyze", hidden=True)
@@ -4175,11 +4225,13 @@ def cache_warm_cmd(
     agent: bool = typer.Option(False, "--agent", help="Also warm agent view."),
 ) -> None:
     """Pre-populate the cache by running a fresh analysis."""
+    import shutil as _shutil
     import subprocess as _sub
     import sys as _sys
     target = Path(path).resolve()
     typer.echo(f"Warming cache for {target} …", err=True)
-    cmd = [_sys.executable, "-m", "sourcecode", str(target)]
+    _sc_bin = _shutil.which("sourcecode") or _sys.argv[0]
+    cmd = [_sc_bin, str(target)]
     if compact:
         cmd.append("--compact")
     if agent:

{sourcecode-1.32.5 → sourcecode-1.32.7}/src/sourcecode/license.py

@@ -248,6 +248,7 @@ def require_feature(feature_name: str) -> None:
             f"'{display}' requires a Pro license. "
             "Run: sourcecode activate <license_key>"
         ),
+        "upgrade_hint": "sourcecode activate <license_key>",
     }
     sys.stdout.write(json.dumps(payload, ensure_ascii=False) + "\n")
     sys.stdout.flush()

{sourcecode-1.32.5 → sourcecode-1.32.7}/src/sourcecode/prepare_context.py

@@ -734,6 +734,77 @@ class TaskContextBuilder:
     def __init__(self, root: Path) -> None:
         self.root = root
 
+    # ------------------------------------------------------------------
+    # RIS fast-path: serve onboard/explain from warm snapshot (<50ms)
+    # ------------------------------------------------------------------
+
+    def _try_ris_fast_path(self, task_name: str, spec: "TaskSpec") -> Optional[TaskOutput]:
+        """Return TaskOutput from a warm RIS without running the full scan.
+
+        Only activated for onboard/explain when git HEAD matches stored RIS.
+        Falls through (returns None) on any error or cache miss.
+        """
+        try:
+            import subprocess as _sp
+            from sourcecode.ris import load_ris as _lris
+            _ris = _lris(self.root)
+            if _ris is None or not _ris.compact_summary:
+                return None
+            _r = _sp.run(
+                ["git", "-C", str(self.root), "rev-parse", "--short", "HEAD"],
+                capture_output=True, text=True, timeout=2,
+            )
+            if _r.returncode != 0 or _r.stdout.strip() != _ris.git_head:
+                return None
+
+            compact = _ris.compact_summary
+            struct = _ris.structural_map
+
+            entry_points = struct.get("entrypoints") or compact.get("entry_points") or []
+            controllers = struct.get("controllers") or []
+            services = struct.get("services") or []
+
+            _seen: set = set()
+            relevant: list[RelevantFile] = []
+            for fp in entry_points[:10]:
+                if isinstance(fp, str) and fp not in _seen:
+                    _seen.add(fp)
+                    relevant.append(RelevantFile(path=fp, role="entrypoint", score=1.0, reason="entry_point", why="Primary entry point"))
+            for fp in controllers[:8]:
+                if isinstance(fp, str) and fp not in _seen:
+                    _seen.add(fp)
+                    relevant.append(RelevantFile(path=fp, role="source", score=0.9, reason="controller", why="Controller"))
+            for fp in services[:8]:
+                if isinstance(fp, str) and fp not in _seen:
+                    _seen.add(fp)
+                    relevant.append(RelevantFile(path=fp, role="source", score=0.8, reason="service", why="Service layer"))
+
+            # compact_summary uses "analysis_gaps" (list[dict]) not "gaps" (list[str])
+            _raw_gaps = compact.get("gaps") or compact.get("analysis_gaps") or []
+            _gap_strs: list[str] = [
+                g.get("reason", str(g)) if isinstance(g, dict) else str(g)
+                for g in _raw_gaps
+                if g
+            ]
+
+            return TaskOutput(
+                task=task_name,
+                goal=spec.goal,
+                project_summary=compact.get("project_summary") or compact.get("summary"),
+                architecture_summary=compact.get("architecture_summary"),
+                relevant_files=relevant,
+                suspected_areas=[],
+                improvement_opportunities=[],
+                test_gaps=[],
+                key_dependencies=compact.get("key_dependencies") or [],
+                code_notes_summary=None,
+                limitations=[],
+                confidence=compact.get("confidence") or compact.get("confidence_summary") or "high",
+                gaps=_gap_strs,
+            )
+        except Exception:
+            return None
+
     def build(self, task_name: str, *, since: Optional[str] = None, symptom: Optional[str] = None, fast: bool = False, include_config: bool = False, all_gaps: bool = False) -> TaskOutput:
         if task_name not in TASKS:
             raise ValueError(
@@ -741,6 +812,12 @@ class TaskContextBuilder:
             )
         spec = TASKS[task_name]
 
+        # ── RIS fast-path (onboard / explain only) ────────────────────────────
+        if task_name in ("onboard", "explain") and not fast:
+            _warm = self._try_ris_fast_path(task_name, spec)
+            if _warm is not None:
+                return _warm
+
         # ── 0. review-pr: git-first scope resolution (before any filesystem scan) ─
         _pr_git_root: Optional[Path] = None
         _pr_scope_files: Optional[list[str]] = None

{sourcecode-1.32.5 → sourcecode-1.32.7}/src/sourcecode/ris.py

@@ -362,7 +362,8 @@ def get_cold_start_context(repo_root: Path) -> dict:
         current_head = _current_git_head(repo_root)
         stale = bool(current_head and ris.git_head and current_head != ris.git_head)
 
-        return {
+        endpoints = ris.api_surface.get("endpoints", [])
+        result: dict = {
             "status": "cold_start_stale" if stale else "cold_start_ready",
             "repo_id": ris.repo_id,
             "git_head": ris.git_head,
@@ -370,8 +371,18 @@ def get_cold_start_context(repo_root: Path) -> dict:
             "last_updated_at": ris.last_updated_at,
             "summary": ris.compact_summary,
             "entrypoints": ris.structural_map.get("entrypoints", []),
-            "endpoints": ris.api_surface.get("endpoints", []),
+            "endpoints": endpoints,
             "hotspots": ris.git_context_snapshot.get("hotspots", []),
         }
+        if not endpoints:
+            _is_java = (repo_root / "pom.xml").exists() or \
+                       (repo_root / "build.gradle").exists() or \
+                       (repo_root / "build.gradle.kts").exists()
+            if _is_java:
+                result["endpoints_hint"] = (
+                    "Java repo detected but no endpoint index found. "
+                    "Call get_endpoints (or: sourcecode endpoints <path>) to populate."
+                )
+        return result
     except Exception:
         return {"status": "no_ris"}