sourcecode 0.45.0__tar.gz → 0.46.0__tar.gz

{sourcecode-0.45.0 → sourcecode-0.46.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 0.45.0
+Version: 0.46.0
 Summary: Deterministic codebase context for AI coding agents
 License:                                  Apache License
                                    Version 2.0, January 2004

{sourcecode-0.45.0 → sourcecode-0.46.0}/pyproject.toml

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

{sourcecode-0.45.0 → sourcecode-0.46.0}/src/sourcecode/__init__.py

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

{sourcecode-0.45.0 → sourcecode-0.46.0}/src/sourcecode/cli.py

@@ -731,8 +731,11 @@ def main(
     # These flags produce standard_view-only output sections not in contract_view.
     # Preserves backward compat: callers using any legacy flag get their previous format.
     # New callers opt into contract mode via --mode contract (or bare invocation).
+    # Legacy flags that produce output sections incompatible with contract_view
+    # force mode to raw. --agent is excluded: it now runs the contract pipeline
+    # and enriches contract_view with auto-enabled analyzers (deps, env, notes).
     _legacy_flags_active = (
-        compact or agent or tree or format == "yaml" or trace_pipeline
+        compact or tree or format == "yaml" or trace_pipeline
         or docs or semantics or graph_modules or full_metrics or architecture
     )
     if mode in ("contract", "standard") and _legacy_flags_active:
@@ -1429,11 +1432,9 @@ def main(
                     "Try --depth 8 or verify the symbol name.",
                     err=True,
                 )
-        if agent:
-            typer.echo(f"[contract] {len(_contracts)} files extracted ({_contract_summary.method_breakdown})", err=True)
 
     # 4. Serialize
-    if _is_contract_mode:
+    if _is_contract_mode and not agent:
         from sourcecode.serializer import contract_view as _contract_view
         _depth = _CONTRACT_DEPTH.get(mode, "minimal")
         data = _contract_view(sm, emit_graph=emit_graph, depth=_depth)
@@ -1442,6 +1443,19 @@ def main(
         content = json.dumps(data, indent=2, ensure_ascii=False)
     elif agent:
         data = agent_view(sm)
+        # When contract pipeline ran (mode=contract, no legacy flags), include
+        # per-file contracts in agent output so agents get structural context.
+        if _is_contract_mode and sm.file_contracts:
+            from sourcecode.serializer import _serialize_contract_minimal
+            data["contracts"] = [_serialize_contract_minimal(c) for c in sm.file_contracts]
+            if sm.contract_summary is not None:
+                cs = sm.contract_summary
+                data["contract_summary"] = {
+                    "files": cs.extracted_files,
+                    "total": cs.total_files,
+                }
+                if cs.method_breakdown:
+                    data["contract_summary"]["methods"] = cs.method_breakdown
         if not no_redact:
             data = redact_dict(data)
         content = json.dumps(data, indent=2, ensure_ascii=False)

{sourcecode-0.45.0 → sourcecode-0.46.0}/src/sourcecode/prepare_context.py

@@ -349,21 +349,56 @@ class TaskContextBuilder:
         spec = TASKS[task_name]
 
         # ── 1. Scan ────────────────────────────────────────────────────────
-        from sourcecode.scanner import FileScanner
+        from sourcecode.adaptive_scanner import AdaptiveScanner
+        from sourcecode.repo_classifier import RepoClassifier
         from sourcecode.tree_utils import flatten_file_tree
 
-        scanner = FileScanner(self.root, max_depth=6)
+        _topology = RepoClassifier().classify(self.root)
+        scanner = AdaptiveScanner(self.root, topology=_topology, base_depth=6)
         file_tree = scanner.scan_tree()
         manifests = scanner.find_manifests()
         all_paths = [p.replace("\\", "/") for p in flatten_file_tree(file_tree)]
 
         # ── 2. Detect stacks + entry points ───────────────────────────────
+        from dataclasses import replace as _replace
         from sourcecode.detectors import ProjectDetector, build_default_detectors
         from sourcecode.workspace import WorkspaceAnalyzer
 
         detector = ProjectDetector(build_default_detectors())
         workspace_analysis = WorkspaceAnalyzer().analyze(self.root, manifests)
-        stacks, entry_points, _ = detector.detect(self.root, file_tree, manifests)
+
+        _root_manifests = [
+            m for m in manifests
+            if Path(m).resolve().parent == self.root
+        ]
+        _detection_manifests = _root_manifests if workspace_analysis.workspaces else manifests
+        if workspace_analysis.is_monorepo and not _root_manifests:
+            from sourcecode.schema import EntryPoint, StackDetection
+            stacks: list[StackDetection] = []
+            entry_points: list[EntryPoint] = []
+        else:
+            stacks, entry_points, _ = detector.detect(self.root, file_tree, _detection_manifests)
+
+        # Iterate workspaces to collect per-workspace stacks and entry points —
+        # same approach as the main CLI (cli.py lines 971-1041).
+        for workspace in workspace_analysis.workspaces:
+            ws_root = self.root / workspace.path
+            if not ws_root.exists() or not ws_root.is_dir():
+                continue
+            _ws_topology = RepoClassifier().classify(ws_root)
+            _ws_scanner = AdaptiveScanner(ws_root, topology=_ws_topology, base_depth=6)
+            _ws_tree = _ws_scanner.scan_tree()
+            _ws_manifests = _ws_scanner.find_manifests()
+            _ws_stacks, _ws_eps, _ = detector.detect(ws_root, _ws_tree, _ws_manifests)
+            stacks.extend(
+                _replace(s, root=workspace.path, workspace=workspace.path, primary=False)
+                for s in _ws_stacks
+            )
+            entry_points.extend(
+                _replace(ep, path=f"{workspace.path}/{ep.path}")
+                for ep in _ws_eps
+            )
+
         stacks, project_type = detector.classify_results(
             file_tree, stacks, entry_points,
             project_type_override="monorepo" if workspace_analysis.is_monorepo else None,

{sourcecode-0.45.0 → sourcecode-0.46.0}/src/sourcecode/serializer.py

@@ -1174,6 +1174,33 @@ def _contract_view_minimal(
         if cs.symbol_truncation:
             result["symbol_query"] = cs.symbol_truncation
 
+    # Monorepo package roles — helps agents understand workspace structure
+    if sm.monorepo_packages:
+        _noise_roles = {"benchmark_layer", "tooling_layer", "docs_layer", "test_layer"}
+        operational_pkgs = [
+            {"path": p.path, "role": p.architectural_role, "criticality": p.criticality}
+            for p in sm.monorepo_packages
+            if p.architectural_role not in _noise_roles
+        ]
+        if operational_pkgs:
+            result["workspace_packages"] = operational_pkgs
+
+    # Confidence summary — detection quality signal
+    if sm.confidence_summary is not None:
+        cs_conf = sm.confidence_summary
+        conf: dict[str, Any] = {
+            "overall": cs_conf.overall,
+            "stack": cs_conf.stack_confidence,
+            "entry_points": cs_conf.entry_point_confidence,
+        }
+        if cs_conf.anomalies:
+            conf["anomalies"] = cs_conf.anomalies
+        result["confidence"] = conf
+
+    # Analysis gaps — explicit about what could not be analyzed
+    if sm.analysis_gaps:
+        result["analysis_gaps"] = [asdict(g) for g in sm.analysis_gaps]
+
     return result
 
 

{sourcecode-0.45.0 → sourcecode-0.46.0}/src/sourcecode/workspace.py

@@ -45,7 +45,7 @@ class WorkspaceAnalyzer:
 
     def _detect_markers(self, root: Path) -> list[str]:
         markers: list[str] = []
-        for filename in ("pnpm-workspace.yaml", "go.work", "turbo.json", "lerna.json"):
+        for filename in ("pnpm-workspace.yaml", "go.work", "turbo.json", "lerna.json", "nx.json", "rush.json"):
             if (root / filename).exists():
                 markers.append(filename)
 
@@ -54,6 +54,17 @@ class WorkspaceAnalyzer:
             content = cargo.read_text(encoding="utf-8", errors="replace")
             if "[workspace]" in content:
                 markers.append("Cargo.toml[workspace]")
+
+        pkg = root / "package.json"
+        if pkg.exists():
+            try:
+                import json as _json
+                data = _json.loads(pkg.read_text(encoding="utf-8", errors="replace"))
+                if isinstance(data, dict) and data.get("workspaces"):
+                    markers.append("package.json[workspaces]")
+            except Exception:
+                pass
+
         return markers
 
     def _workspace_candidates_from_manifests(
@@ -84,6 +95,8 @@ class WorkspaceAnalyzer:
             candidates.extend(self._from_go_work(root))
         if "Cargo.toml[workspace]" in markers:
             candidates.extend(self._from_cargo_workspace(root))
+        if "package.json[workspaces]" in markers:
+            candidates.extend(self._from_npm_workspaces(root))
         return [candidate for candidate in candidates if self._is_allowed_workspace(candidate.path)]
 
     def _from_pnpm_workspace(self, root: Path) -> list[WorkspaceCandidate]:
@@ -143,6 +156,27 @@ class WorkspaceAnalyzer:
                     in_members = False
         return candidates
 
+    def _from_npm_workspaces(self, root: Path) -> list[WorkspaceCandidate]:
+        try:
+            import json as _json
+            data = _json.loads((root / "package.json").read_text(encoding="utf-8", errors="replace"))
+        except Exception:
+            return []
+        workspaces = data.get("workspaces", [])
+        if isinstance(workspaces, dict):
+            workspaces = workspaces.get("packages", [])
+        if not isinstance(workspaces, list):
+            return []
+        candidates: list[WorkspaceCandidate] = []
+        for pattern in workspaces:
+            if not isinstance(pattern, str):
+                continue
+            for path in self._resolve_pattern(root, pattern):
+                candidates.append(
+                    WorkspaceCandidate(path=path, reason="marker:package.json[workspaces]", depth=len(Path(path).parts))
+                )
+        return candidates
+
     def _resolve_pattern(self, root: Path, pattern: str) -> list[str]:
         matches: list[str] = []
         for candidate in root.glob(pattern):