sourcecode 0.44.0__tar.gz → 0.46.0__tar.gz

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

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

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

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

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

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

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

@@ -660,6 +660,21 @@ def main(
         )
         raise typer.Exit(code=1)
 
+    if symbol and mode not in ("contract", "standard"):
+        typer.echo(
+            f"Error: --symbol requires --mode contract or standard (got '{mode}'). "
+            "Symbol search uses the contract pipeline which does not run in raw mode.",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
+    if entrypoints_only and mode not in ("contract", "standard"):
+        typer.echo(
+            f"Error: --entrypoints-only requires --mode contract or standard (got '{mode}').",
+            err=True,
+        )
+        raise typer.Exit(code=1)
+
     if dependency_depth > 0:
         typer.echo(
             f"[warning] --dependency-depth {dependency_depth} has no effect: "
@@ -716,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:
@@ -1257,7 +1275,13 @@ def main(
             eco_order = 0 if d.ecosystem == primary_ecosystem else 1
             return (role_order, eco_order, d.name.lower())
 
-        sm.key_dependencies = sorted(direct_deps, key=_dep_sort_key)[:15]
+        _seen_dep_names: set[str] = set()
+        _deduped_deps: list[Any] = []
+        for d in sorted(direct_deps, key=_dep_sort_key):
+            if d.name not in _seen_dep_names:
+                _seen_dep_names.add(d.name)
+                _deduped_deps.append(d)
+        sm.key_dependencies = _deduped_deps[:15]
 
     # LQN-02: deterministic NL summary
     sm.project_summary = ProjectSummarizer(target).generate(sm)
@@ -1356,37 +1380,61 @@ def main(
     _is_contract_mode = mode in ("contract", "standard")
     if _is_contract_mode:
         from sourcecode.contract_pipeline import ContractPipeline
+        from sourcecode.contract_model import ContractSummary as _ContractSummary
         _cp = ContractPipeline()
-        _contracts, _contract_summary = _cp.run(
-            target,
-            sm.file_paths,
-            entry_points=sm.entry_points,
-            monorepo_packages=sm.monorepo_packages,
-            mode=mode,
-            rank_by=rank_by,  # type: ignore[arg-type]
-            max_symbols=max_symbols,
-            dependency_depth=dependency_depth,
-            entrypoints_only=entrypoints_only,
-            changed_only=changed_only,
-            symbol=symbol,
-            compress_types=compress_types,
-            max_importers=max_importers,
-            semantic_calls=sm.semantic_calls or None,
-            code_notes=sm.code_notes or None,
-        )
+        try:
+            _contracts, _contract_summary = _cp.run(
+                target,
+                sm.file_paths,
+                entry_points=sm.entry_points,
+                monorepo_packages=sm.monorepo_packages,
+                mode=mode,
+                rank_by=rank_by,  # type: ignore[arg-type]
+                max_symbols=max_symbols,
+                dependency_depth=dependency_depth,
+                entrypoints_only=entrypoints_only,
+                changed_only=changed_only,
+                symbol=symbol,
+                compress_types=compress_types,
+                max_importers=max_importers,
+                semantic_calls=sm.semantic_calls or None,
+                code_notes=sm.code_notes or None,
+            )
+        except Exception as _exc:
+            typer.echo(f"[error] contract pipeline failed: {_exc}", err=True)
+            _contracts = []
+            _contract_summary = _ContractSummary(
+                mode=mode,
+                total_files=0,
+                extracted_files=0,
+                filtered_files=0,
+                method_breakdown={},
+                ranked_by=rank_by,
+                limitations=[f"pipeline_error: {type(_exc).__name__}"],
+            )
         sm = _replace(sm, file_contracts=_contracts, contract_summary=_contract_summary)
         if symbol is not None and len(_contracts) == 0:
-            typer.echo(
-                f"[warning] --symbol '{symbol}' matched 0 files. "
-                "The symbol may not exist at the current --depth, or the name may differ in case. "
-                "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)
+            _jvm_stacks = {"java", "kotlin", "scala", "groovy"}
+            _is_jvm_repo = any(s.stack in _jvm_stacks for s in sm.stacks)
+            if _is_jvm_repo:
+                typer.echo(
+                    f"[warning] --symbol '{symbol}' matched 0 files. "
+                    "Per-file AST extraction is not available for Java/JVM repos — "
+                    "symbol search works only with Python, TypeScript, and JavaScript. "
+                    "Use --git-context or --code-notes for JVM navigation.",
+                    err=True,
+                )
+            else:
+                typer.echo(
+                    f"[warning] --symbol '{symbol}' matched 0 files. "
+                    "The symbol may not exist, the name may differ in case, "
+                    "or the file may be outside the scanned depth. "
+                    "Try --depth 8 or verify the symbol name.",
+                    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)
@@ -1395,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.44.0 → sourcecode-0.46.0}/src/sourcecode/contract_pipeline.py

@@ -241,7 +241,9 @@ class ContractPipeline:
             contracts.append(contract)
             method_counts[contract.extraction_method] += 1
 
-        if not self._extractor.has_tree_sitter():
+        _js_ts_languages = {"typescript", "javascript", "tsx", "jsx"}
+        _has_js_ts = any(c.language in _js_ts_languages for c in contracts)
+        if _has_js_ts and not self._extractor.has_tree_sitter():
             limitations.append(
                 "tree_sitter_unavailable: JS/TS extraction uses heuristics. "
                 "Install with: pip install 'sourcecode[ast]'"

{sourcecode-0.44.0 → sourcecode-0.46.0}/src/sourcecode/detectors/heuristic.py

@@ -66,6 +66,13 @@ class HeuristicDetector(AbstractDetector):
                     counts[stack] += 1
                     break
 
+        # Suppress minority stacks: if a language appears in fewer than 3 files
+        # AND represents less than 10% of detected source files, it is likely
+        # noise (stray config files, vendored snippets) rather than a real stack.
+        # Always emit the dominant language regardless of absolute count.
+        total_detected = sum(counts.values())
+        _ABS_MIN = 3
+        _REL_MIN = 0.10
         stacks = [
             StackDetection(
                 stack=stack,
@@ -73,7 +80,8 @@ class HeuristicDetector(AbstractDetector):
                 confidence="low",
                 manifests=[],
             )
-            for stack, _count in counts.most_common()
+            for stack, count in counts.most_common()
+            if count >= _ABS_MIN or (total_detected > 0 and count / total_detected >= _REL_MIN)
         ]
 
         entry_points: list[EntryPoint] = []

{sourcecode-0.44.0 → sourcecode-0.46.0}/src/sourcecode/env_analyzer.py

@@ -11,8 +11,8 @@ _MAX_FILE_SIZE = 512 * 1024  # 512 KB
 
 _SKIP_DIRS = {
     "node_modules", ".git", "__pycache__", ".venv", "venv",
-    ".mypy_cache", "dist", "build", ".tox", ".eggs", "coverage",
-    ".next", ".nuxt", ".output", "vendor",
+    ".mypy_cache", "dist", "build", "target", ".gradle",
+    ".tox", ".eggs", "coverage", ".next", ".nuxt", ".output", "vendor",
 }
 
 _CODE_EXTENSIONS = {

{sourcecode-0.44.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.44.0 → sourcecode-0.46.0}/src/sourcecode/serializer.py

@@ -121,10 +121,16 @@ def _dependency_groups(sm: SourceMap) -> dict[str, list[dict[str, Any]]]:
 
         if role in _PRODUCTION_DEP_ROLES and scope not in {"dev"}:
             groups["production_dependencies"].append(item)
+            _jvm_ecosystems = {"maven", "gradle", "java", "kotlin", "scala", "groovy"}
             if dep.source == "manifest" and name_key not in import_index:
-                suspect = dict(item)
-                suspect["reason"] = "declared as production dependency but no static import observed"
-                groups["suspicious_dependencies"].append(suspect)
+                if dep.ecosystem in _jvm_ecosystems:
+                    # Static import check unsupported for JVM: import index only covers
+                    # Python/JS/TS. Flagging JVM deps as suspicious produces only false positives.
+                    pass
+                else:
+                    suspect = dict(item)
+                    suspect["reason"] = "declared as production dependency but no static import observed"
+                    groups["suspicious_dependencies"].append(suspect)
         elif role in _TEST_DEP_ROLES:
             groups["test_utilities"].append(item)
         elif role in _BUILD_DEP_ROLES:
@@ -1168,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.44.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):