sourcecode 0.29.0__py3-none-any.whl → 0.30.0__py3-none-any.whl

sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Genera mapas de contexto estructurado para agentes IA."""
 
-__version__ = "0.29.0"
+__version__ = "0.30.0"

sourcecode/architecture_summary.py

@@ -5,6 +5,7 @@ import re
 from pathlib import Path
 from typing import Any
 
+from sourcecode.entrypoint_classifier import is_production_entry_point
 from sourcecode.schema import EntryPoint, SourceMap, StackDetection
 from sourcecode.tree_utils import flatten_file_tree
 
@@ -63,11 +64,8 @@ class ArchitectureSummarizer:
             entry for entry in sm.entry_points
             if not self._is_tooling_path(entry.path)
             and not self._is_auxiliary_path(entry.path)
-            and entry.entrypoint_type not in ("benchmark", "example")
+            and is_production_entry_point(entry)
         ]
-        if not entry_points:
-            fallback = self._infer_fallback_entry_points(file_paths, sm.stacks)
-            entry_points = fallback[:1]
 
         lang_lines: list[str] = []
         if entry_points:
@@ -280,8 +278,7 @@ class ArchitectureSummarizer:
         if modules:
             formatted = self._format_module_list([self._module_label(module) for module in modules])
             if formatted:
-                lines.append(f"Orquesta modulos internos: {formatted}.")
-        lines.append("Produce la salida principal del entry point JavaScript/TypeScript detectado.")
+                lines.append(f"Imports internos del entry point: {formatted}.")
         return lines
 
     def _summarize_java_entry(self, path: str, content: str, stacks: list[StackDetection]) -> list[str]:
@@ -344,8 +341,7 @@ class ArchitectureSummarizer:
         if internal:
             formatted = self._format_module_list([self._module_label(module) for module in internal])
             if formatted:
-                lines.append(f"Orquesta paquetes internos: {formatted}.")
-        lines.append("Produce la salida principal del binario Go detectado.")
+                lines.append(f"Imports internos del binario Go: {formatted}.")
         return lines
 
     def _describe_entry_point(self, entry_point: EntryPoint, project_type: str | None) -> str:

sourcecode/classifier.py

@@ -45,8 +45,12 @@ class TypeClassifier:
         primary_stack = self._select_primary_stack(enriched, project_type)
 
         final_stacks: list[StackDetection] = []
+        primary_assigned = False
         for stack in enriched:
-            final_stacks.append(replace(stack, primary=(stack.stack == primary_stack)))
+            is_primary = stack.stack == primary_stack and not primary_assigned
+            if is_primary:
+                primary_assigned = True
+            final_stacks.append(replace(stack, primary=is_primary))
         return final_stacks, project_type
 
     def _enrich_stack(

sourcecode/cli.py

@@ -6,9 +6,10 @@ import time
 from pathlib import Path
 from typing import Any, Optional, cast
 
-import typer
-
-from sourcecode import __version__
+import typer
+
+from sourcecode import __version__
+from sourcecode.entrypoint_classifier import is_production_entry_point, normalize_entry_point
 
 
 # ---------------------------------------------------------------------------
@@ -117,11 +118,11 @@ def _check_pipeline_coherence(sm: "SourceMap") -> list[str]:  # type: ignore[nam
                 )
 
         # overall:high requires at least one production entry point
-        if cs.overall == "high":
-            prod_eps = [
-                ep for ep in sm.entry_points
-                if ep.entrypoint_type in ("production", None)
-            ]
+        if cs.overall == "high":
+            prod_eps = [
+                ep for ep in sm.entry_points
+                if is_production_entry_point(ep)
+            ]
             if not prod_eps and sm.entry_points:
                 issues.append(
                     "[coherence] overall=high but no production entry points exist — "
@@ -134,21 +135,7 @@ def _check_pipeline_coherence(sm: "SourceMap") -> list[str]:  # type: ignore[nam
                 "[coherence] entry_point_confidence=high but entry_points is empty"
             )
 
-    # Contradictory EP classification: EPs with entrypoint_type=benchmark must not
-    # appear in agent_view output (checked post-facto via produced_by + type)
-    benchmark_eps = [
-        ep for ep in sm.entry_points
-        if ep.entrypoint_type in ("benchmark", "example")
-    ]
-    if benchmark_eps and sm.entry_points and all(
-        ep.entrypoint_type in ("benchmark", "example") for ep in sm.entry_points
-    ):
-        issues.append(
-            f"[coherence] all {len(sm.entry_points)} entry point(s) are benchmark/example — "
-            "no production entry detected; analysis_gaps should reflect impact=high"
-        )
-
-    return issues
+    return issues
 
 _HELP = """\
 Deterministic codebase context for AI coding agents.
@@ -993,12 +980,13 @@ def main(
             "example", "examples", "docs", "doc", "fixtures", "fixture",
         })
         for _ep in sm.entry_points:
-            _ep_type = _ep.entrypoint_type
-            _path_parts = _ep.path.replace("\\", "/").lower().split("/")
-            _filtered = (
-                _ep_type in ("benchmark", "example")
-                or any(p in _aux_parts for p in _path_parts)
-            )
+            _normalized_ep = normalize_entry_point(_ep)
+            _ep_type = _normalized_ep.entrypoint_type
+            _path_parts = _ep.path.replace("\\", "/").lower().split("/")
+            _filtered = (
+                _normalized_ep.classification != "production"
+                or any(p in _aux_parts for p in _path_parts)
+            )
             if _filtered:
                 _trace.emit("output", "agent_view", "filter_ep",
                             target=_ep.path,

sourcecode/confidence_analyzer.py

@@ -12,6 +12,7 @@ from __future__ import annotations
 from pathlib import Path
 from typing import TYPE_CHECKING
 
+from sourcecode.entrypoint_classifier import is_production_entry_point, normalize_entry_point
 from sourcecode.schema import AnalysisGap, ConfidenceSummary, SourceMap
 
 if TYPE_CHECKING:
@@ -59,8 +60,15 @@ class ConfidenceAnalyzer:
                     hard_signals.append(sig)
 
         # ── Entry point signals ───────────────────────────────────────────────
-        for ep in sm.entry_points:
-            if ep.source in _HARD_SOURCES or ep.reason == "console_script":
+        normalized_entry_points = [normalize_entry_point(ep) for ep in sm.entry_points]
+
+        for ep in normalized_entry_points:
+            if ep.classification != "production":
+                sig = f"entry:{ep.path} ({ep.classification}, {ep.reason or ep.source})"
+                if sig not in ignored_signals:
+                    ignored_signals.append(sig)
+                continue
+            if ep.source in _HARD_SOURCES or ep.reason == "console_script" or ep.runtime_relevance == "high":
                 sig = f"entry:{ep.path} ({ep.reason or ep.source})"
                 if sig not in hard_signals:
                     hard_signals.append(sig)
@@ -95,13 +103,13 @@ class ConfidenceAnalyzer:
             anomalies.append("All stacks detected via heuristic only — no manifest found")
 
         # ── Anomaly: entry points all low-confidence ──────────────────────────
-        if sm.entry_points and all(ep.confidence == "low" for ep in sm.entry_points):
+        if normalized_entry_points and all(ep.confidence == "low" for ep in normalized_entry_points):
             anomalies.append("All entry points are low-confidence (heuristic/code_signal only)")
 
         # ── Anomaly: all production EPs are convention-only (no manifest evidence) ──
         production_eps_check = [
-            ep for ep in sm.entry_points
-            if ep.entrypoint_type in ("production", None)
+            ep for ep in normalized_entry_points
+            if is_production_entry_point(ep)
         ]
         if production_eps_check and all(
             ep.source in ("convention", "heuristic") or ep.reason in ("convention", "entry_file_pattern")
@@ -113,37 +121,37 @@ class ConfidenceAnalyzer:
             )
 
         # ── Anomaly: no production entry points ───────────────────────────────
-        if sm.entry_points:
+        if normalized_entry_points:
             production_eps = [
-                ep for ep in sm.entry_points
-                if ep.entrypoint_type in ("production", None)
+                ep for ep in normalized_entry_points
+                if is_production_entry_point(ep)
             ]
             if not production_eps:
                 anomalies.append(
-                    "No production entry points — all detected entries are dev/benchmark/example"
+                    "No production entry points — all detected entries are development/auxiliary"
                 )
 
         # ── Gaps ──────────────────────────────────────────────────────────────
-        if not sm.entry_points:
+        if not normalized_entry_points:
             gaps.append(AnalysisGap(
                 area="entry_points",
                 reason="No entry point detected — project may use non-standard structure or be a library",
                 impact="high",
             ))
         elif all(
-            ep.entrypoint_type in ("benchmark", "example", "development")
-            for ep in sm.entry_points
+            ep.classification in ("development", "auxiliary")
+            for ep in normalized_entry_points
         ):
             gaps.append(AnalysisGap(
                 area="entry_points",
                 reason=(
-                    "All detected entry points are auxiliary (benchmark/example/dev) — "
+                    "All detected entry points are development or auxiliary — "
                     "no production entry point found. Verify project has a 'start'/'serve' "
                     "script or production binary."
                 ),
                 impact="high",
             ))
-        elif all(ep.confidence == "low" for ep in sm.entry_points):
+        elif all(ep.confidence == "low" for ep in normalized_entry_points):
             gaps.append(AnalysisGap(
                 area="entry_points",
                 reason="Entry points inferred from code patterns only, no manifest declaration found",
@@ -196,12 +204,17 @@ class ConfidenceAnalyzer:
         # Entry points: only consider production EPs for confidence scoring.
         # Benchmark/example/dev-only entries are not evidence of production readiness.
         production_eps = [
-            ep for ep in sm.entry_points
-            if ep.entrypoint_type in ("production", None)
+            ep for ep in normalized_entry_points
+            if is_production_entry_point(ep)
         ]
         ep_conf = _max_confidence([ep.confidence for ep in production_eps] or ["low"])
         overall = _min_confidence([stack_conf, ep_conf])
 
+        if normalized_entry_points and not production_eps:
+            overall = "low"
+        elif production_eps and all(ep.runtime_relevance == "low" for ep in production_eps):
+            overall = _min_confidence([overall, "low"])
+
         # Factor in architecture confidence when available
         arch = sm.architecture
         if arch is not None and arch.requested:

sourcecode/detectors/nodejs.py

@@ -125,6 +125,9 @@ class NodejsDetector(AbstractDetector):
         "playground", "playgrounds",
         "fixture", "fixtures",
         "sandbox", "e2e", "docs",
+        "test", "tests", "__tests__", "spec", "specs",
+        "scripts", "script", "tools", "tooling", "ci",
+        ".storybook", "storybook",
     })
 
     def _collect_entry_points(
@@ -144,19 +147,20 @@ class NodejsDetector(AbstractDetector):
                     continue
                 # Extract file path from script command
                 path = self._extract_script_path(script_cmd, context)
+                if path is None:
+                    path = self._infer_tool_script_path(script_name, script_cmd, context)
                 if path and path not in seen and path_exists_in_tree(context.file_tree, path):
                     seen.add(path)
-                    if not self._is_auxiliary_path(path):
-                        entry_points.append(EntryPoint(
-                            path=path,
-                            stack="nodejs",
-                            kind=kind,
-                            source="package.json#scripts",
-                            confidence="high",
-                            reason=f"script:{script_name}",
-                            evidence=f"scripts.{script_name} = {script_cmd!r:.80}",
-                            entrypoint_type=ep_type,
-                        ))
+                    entry_points.append(EntryPoint(
+                        path=path,
+                        stack="nodejs",
+                        kind=kind,
+                        source="package.json#scripts",
+                        confidence="high",
+                        reason=f"script:{script_name}",
+                        evidence=f"scripts.{script_name} = {script_cmd!r:.80}",
+                        entrypoint_type=self._path_entrypoint_type(path, fallback=ep_type),
+                    ))
 
         # Priority 2: package.json bin — CLI production entry points
         bin_field = package_json.get("bin")
@@ -233,7 +237,7 @@ class NodejsDetector(AbstractDetector):
     def _classify_script(self, script_name: str) -> tuple[str | None, str]:
         """Map script name → (entrypoint_type, kind). Returns (None, '') to skip."""
         lower = script_name.lower()
-        if lower in ("start", "serve"):
+        if lower in ("start", "serve", "server"):
             return "production", "server"
         if lower in ("dev", "develop", "watch"):
             return "development", "server"
@@ -243,6 +247,12 @@ class NodejsDetector(AbstractDetector):
             return "benchmark", "script"
         if lower.startswith("example") or lower.startswith("demo"):
             return "example", "script"
+        if lower in {"docs", "doc", "storybook", "playground"} or any(
+            marker in lower for marker in ("rspress", "vite", "storybook", "playground")
+        ):
+            return "development", "server"
+        if lower in {"test", "e2e", "spec", "lint", "format", "typecheck", "build"}:
+            return "development", "script"
         return None, ""
 
     def _extract_script_path(self, cmd: str, context: DetectionContext) -> str | None:
@@ -264,12 +274,36 @@ class NodejsDetector(AbstractDetector):
                 return p
         return None
 
+    def _infer_tool_script_path(
+        self,
+        script_name: str,
+        script_cmd: str,
+        context: DetectionContext,
+    ) -> str | None:
+        text = f"{script_name} {script_cmd}".lower()
+        candidates: list[str] = []
+        if "rspress" in text or "docs" in text or "doc" in text:
+            candidates.extend(["docs/rspress.mjs", "docs/rspress.config.mjs"])
+        if "storybook" in text:
+            candidates.extend([".storybook/main.js", ".storybook/main.ts"])
+        if "vite" in text or "playground" in text:
+            candidates.extend(["playground/vite.config.ts", "vite.config.ts"])
+        for candidate in candidates:
+            if path_exists_in_tree(context.file_tree, candidate):
+                return candidate
+        return None
+
     def _is_auxiliary_path(self, path: str) -> bool:
         norm = path.replace("\\", "/")
         parts = norm.split("/")
         return any(p.lower() in self._AUXILIARY_DIRS for p in parts)
 
-    def _path_entrypoint_type(self, path: str) -> str:
-        if self._is_auxiliary_path(path):
+    def _path_entrypoint_type(self, path: str, *, fallback: str = "production") -> str:
+        parts = {p.lower() for p in path.replace("\\", "/").split("/")}
+        if parts & {"benchmark", "benchmarks", "bench", "benches"}:
+            return "benchmark"
+        if parts & {"example", "examples", "demo", "demos", "fixture", "fixtures"}:
             return "example"
-        return "production"
+        if self._is_auxiliary_path(path):
+            return "development"
+        return fallback

sourcecode/entrypoint_classifier.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from dataclasses import replace
+from typing import Literal
+
+from sourcecode.schema import EntryPoint
+
+Classification = Literal["production", "development", "auxiliary"]
+RuntimeRelevance = Literal["high", "medium", "low"]
+
+_AUXILIARY_DIRS = frozenset({
+    "benchmark", "benchmarks", "bench", "benches",
+    "example", "examples", "demo", "demos",
+    "fixture", "fixtures", "__fixtures__", "testdata", "test_data",
+    "test", "tests", "__tests__", "spec", "specs", "e2e",
+    "script", "scripts", "tool", "tools", "tooling", "ci",
+    "mock", "mocks", "sandbox",
+})
+
+_DEVELOPMENT_DIRS = frozenset({
+    "docs", "doc", "documentation", "wiki",
+    "playground", "playgrounds", ".storybook", "storybook",
+})
+
+_DEV_MARKERS = ("rspress", "vite", "storybook", "playground", "dev-server")
+_PRODUCTION_SCRIPT_REASONS = {"script:start", "script:serve", "script:server"}
+
+
+def classify_entry_point(ep: EntryPoint) -> Classification:
+    """Return the operational class for an entry point.
+
+    The rules intentionally prefer exclusion over weak inclusion. Development
+    and auxiliary path evidence wins over detector-provided production labels.
+    """
+    path = ep.path.replace("\\", "/").lower()
+    parts = set(path.split("/"))
+    reason = (ep.reason or "").lower()
+    evidence = (ep.evidence or "").lower()
+    marker_text = f"{path} {reason} {evidence}"
+
+    if parts & _DEVELOPMENT_DIRS or any(marker in marker_text for marker in _DEV_MARKERS):
+        return "development"
+    if parts & _AUXILIARY_DIRS:
+        return "auxiliary"
+    if ep.entrypoint_type in {"benchmark", "example"}:
+        return "auxiliary"
+    if ep.entrypoint_type == "development":
+        return "development"
+    if (
+        ep.source == "convention"
+        and ep.kind in {"binary", "application"}
+        and ep.stack in {"go", "rust", "java", "dotnet", "kotlin", "scala"}
+    ):
+        return "production"
+    if ep.source in {"heuristic", "convention"}:
+        return "auxiliary"
+    if ep.entrypoint_type == "production":
+        return "production"
+    if ep.source == "package.json#bin" or reason == "bin":
+        return "production"
+    if reason in _PRODUCTION_SCRIPT_REASONS:
+        return "production"
+    return "production"
+
+
+def runtime_relevance(ep: EntryPoint, classification: Classification | None = None) -> RuntimeRelevance:
+    classification = classification or classify_entry_point(ep)
+    if classification != "production":
+        return "low"
+    reason = (ep.reason or "").lower()
+    if ep.source == "package.json#bin" or reason == "bin" or reason in _PRODUCTION_SCRIPT_REASONS:
+        return "high"
+    if ep.source == "package.json" and reason in {"main", "module"}:
+        return "medium"
+    if ep.source == "convention" and ep.kind in {"binary", "application"}:
+        return "medium"
+    if ep.source in {"heuristic", "convention"} or ep.confidence == "low":
+        return "low"
+    return "medium"
+
+
+def normalize_entry_point(ep: EntryPoint) -> EntryPoint:
+    classification = classify_entry_point(ep)
+    relevance = runtime_relevance(ep, classification)
+    legacy_type = ep.entrypoint_type
+    if classification == "auxiliary" and legacy_type == "production" and ep.source in {"heuristic", "convention"}:
+        legacy_type = None
+    if legacy_type is None:
+        if classification == "production":
+            legacy_type = "production"
+        elif classification == "development":
+            legacy_type = "development"
+    return replace(
+        ep,
+        classification=classification,
+        runtime_relevance=relevance,
+        entrypoint_type=legacy_type,
+    )
+
+
+def is_production_entry_point(ep: EntryPoint) -> bool:
+    normalized = normalize_entry_point(ep)
+    return (
+        normalized.classification == "production"
+        and normalized.runtime_relevance in {"high", "medium"}
+    )

sourcecode/schema.py

@@ -72,10 +72,12 @@ class EntryPoint:
     kind: str = "entry"
     source: str = "manifest"
     confidence: Literal["high", "medium", "low"] = "high"
-    reason: Optional[str] = None   # console_script | entry_file_pattern | main_guard | typer_app | heuristic | convention
-    evidence: Optional[str] = None  # brief evidence string
-    entrypoint_type: Optional[Literal["production", "development", "benchmark", "example"]] = None
-    produced_by: Optional[str] = None  # which detector emitted this
+    reason: Optional[str] = None   # console_script | entry_file_pattern | main_guard | typer_app | heuristic | convention
+    evidence: Optional[str] = None  # brief evidence string
+    entrypoint_type: Optional[Literal["production", "development", "benchmark", "example"]] = None
+    classification: Optional[Literal["production", "development", "auxiliary"]] = None
+    runtime_relevance: Optional[Literal["high", "medium", "low"]] = None
+    produced_by: Optional[str] = None  # which detector emitted this
 
 
 @dataclass

sourcecode/serializer.py

@@ -13,9 +13,10 @@ import sys
 from dataclasses import asdict, dataclass, is_dataclass, replace
 from io import StringIO
 from pathlib import Path
-from typing import Any, Optional
-
-from sourcecode.schema import (
+from typing import Any, Optional
+
+from sourcecode.entrypoint_classifier import normalize_entry_point, is_production_entry_point
+from sourcecode.schema import (
     ArchitectureAnalysis,
     ModuleGraph,
     ModuleGraphSummary,
@@ -34,7 +35,7 @@ def to_json(sm: SourceMap | dict[str, Any], indent: int = 2) -> str:
     return json.dumps(data, indent=indent, ensure_ascii=False)
 
 
-def to_yaml(sm: SourceMap) -> str:
+def to_yaml(sm: SourceMap) -> str:
     """Serializa SourceMap a YAML usando ruamel.yaml.
 
     ruamel.yaml preserva el orden de claves y serializa None como null
@@ -50,11 +51,42 @@ def to_yaml(sm: SourceMap) -> str:
         lambda dumper, data: dumper.represent_scalar("tag:yaml.org,2002:null", "null"),
     )
     stream = StringIO()
-    yaml.dump(asdict(sm), stream)
-    return stream.getvalue()
-
-
-def compact_view(sm: SourceMap, *, no_tree: bool = False) -> dict[str, Any]:
+    yaml.dump(asdict(sm), stream)
+    return stream.getvalue()
+
+
+def _clean_entry_point(ep: Any) -> dict[str, Any]:
+    normalized = normalize_entry_point(ep)
+    return {
+        k: v
+        for k, v in asdict(normalized).items()
+        if v is not None and v != "" and k != "workspace"
+    }
+
+
+def _entry_point_groups(entry_points: list[Any]) -> dict[str, list[dict[str, Any]]]:
+    groups: dict[str, list[dict[str, Any]]] = {
+        "production": [],
+        "development": [],
+        "auxiliary": [],
+    }
+    for ep in entry_points:
+        normalized = normalize_entry_point(ep)
+        item = _clean_entry_point(normalized)
+        if is_production_entry_point(normalized):
+            groups["production"].append(item)
+        elif normalized.classification == "development":
+            groups["development"].append(item)
+        else:
+            groups["auxiliary"].append(item)
+
+    groups["production"].sort(key=lambda ep: (ep.get("runtime_relevance") != "high", ep.get("path", "")))
+    groups["development"].sort(key=lambda ep: ep.get("path", ""))
+    groups["auxiliary"].sort(key=lambda ep: ep.get("path", ""))
+    return groups
+
+
+def compact_view(sm: SourceMap, *, no_tree: bool = False) -> dict[str, Any]:
     """Context package ready for prompt or handoff (~600-800 tokens).
 
     Answers: what it is, where it enters, what depends on what,
@@ -85,13 +117,12 @@ def compact_view(sm: SourceMap, *, no_tree: bool = False) -> dict[str, Any]:
     if sm.code_notes_summary is not None and sm.code_notes_summary.requested:
         code_notes_summary_dict = asdict(sm.code_notes_summary)
 
-    # Entry points: strip None fields for compactness
-    entry_points_compact = [
-        {k: v for k, v in asdict(ep).items() if v is not None and v != ""}
-        for ep in sm.entry_points
-    ]
-    if not entry_points_compact:
-        entry_points_compact = None  # type: ignore[assignment]  # signal: not detected
+    # Entry points: production runtime only. Auxiliary and development entries
+    # are exposed separately so agents do not mix tooling with execution paths.
+    ep_groups = _entry_point_groups(sm.entry_points)
+    entry_points_compact = ep_groups["production"]
+    if not entry_points_compact:
+        entry_points_compact = []  # truth signal: no production runtime detected
 
     # Confidence summary
     conf_dict: Any = None
@@ -116,9 +147,11 @@ def compact_view(sm: SourceMap, *, no_tree: bool = False) -> dict[str, Any]:
         "project_summary": sm.project_summary,
         "architecture_summary": sm.architecture_summary,
         "context_summary": context_summary_dict,
-        "stacks": [asdict(stack) for stack in sm.stacks],
-        "entry_points": entry_points_compact,
-        "dependency_summary": dep_summary_dict,
+        "stacks": [asdict(stack) for stack in sm.stacks],
+        "entry_points": entry_points_compact,
+        "development_entry_points": ep_groups["development"] or None,
+        "auxiliary_entry_points": ep_groups["auxiliary"] or None,
+        "dependency_summary": dep_summary_dict,
         "key_dependencies": key_deps,
         "env_summary": env_summary_dict,
         "code_notes_summary": code_notes_summary_dict,
@@ -163,10 +196,14 @@ def normalize_source_map(sm: SourceMap) -> SourceMap:
 
     # dependencies is already list[DependencyRecord] by default_factory, but
     # guard against any future refactor that could accidentally set it to None
-    if sm.dependencies is None:  # type: ignore[comparison-overlap]
-        changes["dependencies"] = []
-
-    return replace(sm, **changes) if changes else sm
+    if sm.dependencies is None:  # type: ignore[comparison-overlap]
+        changes["dependencies"] = []
+
+    normalized_eps = [normalize_entry_point(ep) for ep in sm.entry_points]
+    if normalized_eps != sm.entry_points:
+        changes["entry_points"] = normalized_eps
+
+    return replace(sm, **changes) if changes else sm
 
 
 def validate_source_map(sm: SourceMap) -> None:
@@ -410,37 +447,13 @@ def agent_view(sm: SourceMap) -> dict[str, Any]:
 
     result: dict[str, Any] = {"project": project}
 
-    # ── 2. Entry points: production/runtime first; benchmark/example always excluded ──
-    # Never fall back to auxiliary-only EPs — when no operational EP exists the
-    # confidence_summary anomaly and analysis_gaps explain the gap instead.
-    if sm.entry_points:
-        _ep_skip = {"workspace"}
-        _aux_parts = frozenset({
-            "benchmark", "benchmarks", "bench", "demo", "demos",
-            "example", "examples", "docs", "doc", "fixtures", "fixture",
-        })
-
-        def _ep_priority(ep_dict: dict[str, Any]) -> int:
-            ep_type = ep_dict.get("entrypoint_type")
-            if ep_type in ("benchmark", "example"):
-                return 10
-            path_parts = ep_dict.get("path", "").replace("\\", "/").lower().split("/")
-            if any(p in _aux_parts for p in path_parts):
-                return 5
-            if ep_type == "development":
-                return 3
-            return 0
-
-        all_ep = [
-            {k: v for k, v in asdict(ep).items() if v is not None and v != "" and k not in _ep_skip}
-            for ep in sm.entry_points
-        ]
-        all_ep.sort(key=_ep_priority)
-        operational_ep = [ep for ep in all_ep if _ep_priority(ep) < 5]
-        if operational_ep:
-            result["entry_points"] = operational_ep
-        # When operational_ep is empty: omit key entirely.
-        # confidence_summary.anomalies + analysis_gaps carry the explanation.
+    # ── 2. Entry points: production/runtime only in the primary field ─────────
+    # Development and auxiliary entries are explicit side channels. A missing
+    # production runtime is represented as entry_points=[], never by fallback.
+    ep_groups = _entry_point_groups(sm.entry_points)
+    result["entry_points"] = ep_groups["production"]
+    result["development_entry_points"] = ep_groups["development"]
+    result["auxiliary_entry_points"] = ep_groups["auxiliary"]
 
     # ── 3. Architecture ───────────────────────────────────────────────────────
     if sm.architecture_summary:
@@ -550,7 +563,7 @@ def agent_view(sm: SourceMap) -> dict[str, Any]:
     return result
 
 
-def standard_view(sm: SourceMap, *, include_tree: bool = False) -> dict[str, Any]:
+def standard_view(sm: SourceMap, *, include_tree: bool = False) -> dict[str, Any]:
     """Default output — three signal layers.
 
     Layer A (always):
@@ -568,14 +581,18 @@ def standard_view(sm: SourceMap, *, include_tree: bool = False) -> dict[str, Any
     Full dependencies list is never included — use key_dependencies instead.
     Empty unrequested analyzer fields are omitted entirely.
     """
-    result: dict[str, Any] = {
-        "metadata": asdict(sm.metadata),
-        "project_type": sm.project_type,
-        "project_summary": sm.project_summary,
-        "architecture_summary": sm.architecture_summary,
-        "stacks": [asdict(s) for s in sm.stacks],
-        "entry_points": [asdict(ep) for ep in sm.entry_points],
-    }
+    ep_groups = _entry_point_groups(sm.entry_points)
+
+    result: dict[str, Any] = {
+        "metadata": asdict(sm.metadata),
+        "project_type": sm.project_type,
+        "project_summary": sm.project_summary,
+        "architecture_summary": sm.architecture_summary,
+        "stacks": [asdict(s) for s in sm.stacks],
+        "entry_points": ep_groups["production"],
+        "development_entry_points": ep_groups["development"],
+        "auxiliary_entry_points": ep_groups["auxiliary"],
+    }
 
     # Layer B — signals (only when the corresponding analyzer ran)
     if sm.dependency_summary is not None and sm.dependency_summary.requested:

{sourcecode-0.29.0.dist-info → sourcecode-0.30.0.dist-info}/METADATA

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

{sourcecode-0.29.0.dist-info → sourcecode-0.30.0.dist-info}/RECORD

@@ -1,14 +1,15 @@
-sourcecode/__init__.py,sha256=n13VPZwhm9Du2TeJhJzTRI5m_7dP6mgpjdq-5NmlVIw,100
+sourcecode/__init__.py,sha256=MU2HxHzhdlDeES-MGTUNA1df0X4nB3GWAvjTRWUEoys,100
 sourcecode/architecture_analyzer.py,sha256=SBRMWJN70M2qeNLkm9oCG_1rw2UOVuNgikyeAHJsXKw,22859
-sourcecode/architecture_summary.py,sha256=qolHmn6MWUIQHzY9WeHcfN41EJkQdnPQ5F_Z8pqQasA,20251
-sourcecode/classifier.py,sha256=Ft_RfYS-KOe0t7vjgUx04OoCJd1-DXK7k9-I0CFDSnU,6934
-sourcecode/cli.py,sha256=4yXSF9UkQsMWU26ySO4-7Zs0B224AxbrdYGr2Urag1k,51120
+sourcecode/architecture_summary.py,sha256=rSY5MRiaz4N1YdG0pqDTDuFjSN7PO_Zplx-dtNzv2Yo,19985
+sourcecode/classifier.py,sha256=GKTMN8qKZX7ponSwDJfN08RrasI4CVpq1_gFBgEopps,7093
+sourcecode/cli.py,sha256=LKtus6aETNZv70fkp5LrjTfvu5w9jsB4go-7MCoDnzg,50611
 sourcecode/code_notes_analyzer.py,sha256=rRd8bFYV0krjlxxQV0wenwE9K7pVpUQSR7KvSvUQKw4,9226
-sourcecode/confidence_analyzer.py,sha256=pzWeHTMz9ZYCuogYcTagpIJuLY-1SOSPTjsiE77rPek,11336
+sourcecode/confidence_analyzer.py,sha256=B48lCuz_t_qsyjPQdLbKUj2kJ0Wu4Sq5ZnO18F_v3eU,12069
 sourcecode/context_summarizer.py,sha256=CiQrfBEzun949bWvmLabWoj2HhPn6Lw62ofqnsy0FlQ,6503
 sourcecode/coverage_parser.py,sha256=q0LeZJaX1bnntLu-ImksdBsMlpsVmk_iUfSaB4eaJGo,19702
 sourcecode/dependency_analyzer.py,sha256=Exq0BfInvfS5iAg9xAr6WI2uPNuotkIudTKcYJcRhB8,52757
 sourcecode/doc_analyzer.py,sha256=Ec3orx6vBKsh5cNM3-F4y2Got2KuKx8w3dErwtdtM-A,19891
+sourcecode/entrypoint_classifier.py,sha256=a69dMGyxCTd_LOm3oqj-EXWpRmbmeujN7T1mr2eJ1as,3877
 sourcecode/env_analyzer.py,sha256=slvq-eT24RVMNczLNDlZbe0hU8JXIIPxybqubvrrnSQ,14409
 sourcecode/git_analyzer.py,sha256=saI5wtHBEOXBhdk7SrVR7ArSM6MFkyGgukvGRuD9WRc,9638
 sourcecode/graph_analyzer.py,sha256=hMOsLLz9B0UnQ4xwbHdgr3bFvqpw0bQ8kN-xmEn3Krk,64156
@@ -18,9 +19,9 @@ sourcecode/redactor.py,sha256=xuGcadGEHaPw4qZXlMDvzMCsr4VOkdp3oBQptHyJk8c,2884
 sourcecode/relevance_scorer.py,sha256=2yvxDFnz9YGrHEJubgx9soiVIDZHKv_pntOtTARtKow,5928
 sourcecode/runtime_classifier.py,sha256=zWX3r3HCKHc-qtIobErOa8aKMmaoPYREtJKvPcBGPjQ,14792
 sourcecode/scanner.py,sha256=aM3h9-DCQ3xKpeHpHYdo2vX6T5P95HA_YwZbkAVNwmo,8288
-sourcecode/schema.py,sha256=yCBhYKbF6axqMgl6F1XGk7xLl6uDJNZafwSSNMtxSa8,20222
+sourcecode/schema.py,sha256=wylO5aKFBHBUAvMh4AH6hKKcN8p5yt6XRkyRvZRjV-4,20378
 sourcecode/semantic_analyzer.py,sha256=asQfJf-EhzYaOTA-iMuZsrVXtbW7SV2WEKCxgsxa88Y,79413
-sourcecode/serializer.py,sha256=ZTnMbVnLSdplLK-NOdqH6GSi4v6zLgxm5i69VR9vS2Q,27199
+sourcecode/serializer.py,sha256=VksZokFUG3GLWz_eUtVqNdkddkeV-tBY2lzfa8ociAc,27898
 sourcecode/summarizer.py,sha256=YfBixsN1zWHHXdOEqaf793BylbJrsj75ST7FN6jcqRU,15424
 sourcecode/tree_utils.py,sha256=Fj9OIuUksBvgibNd3feog0sMDjVypJzPexp5lvMoYWI,1424
 sourcecode/workspace.py,sha256=fQlVoNx8S-fSHpKoJ0JBvEHCFkxszH0KZVJed1i3TRk,6845
@@ -35,7 +36,7 @@ sourcecode/detectors/heuristic.py,sha256=Hab_Uiuxtq-WBs_wCnzETBS5hhaxeEtf-GOGMH6
 sourcecode/detectors/hybrid.py,sha256=IGFRUVsAZ1ooRlFdznCeJAV6vy1yVDx-VyghvLtddXc,9101
 sourcecode/detectors/java.py,sha256=cZvB13cqJ76zHDncEG-TOCuK8gJjJN2mZGS2DGEcZy8,7715
 sourcecode/detectors/jvm_ext.py,sha256=EgHJ5W8EE-ZTN9V607mVzohyKgZE8Mc2jCi-DF8RAZU,2616
-sourcecode/detectors/nodejs.py,sha256=cqLw3SJ1UcImZD5_DVobByacWRD4ftIlep_mYo9z-n8,11260
+sourcecode/detectors/nodejs.py,sha256=LN-m3bERpijlBMl1TNVOH_cJDhfDYRhn8K8lsNzztVc,12923
 sourcecode/detectors/parsers.py,sha256=ugPg8yNUf0Ai1gA7Fnn6wAkYGFjTxRodSP3IeViYJJ4,2290
 sourcecode/detectors/php.py,sha256=W_AQD0WMVDdWHa9h_ilX6W8XSpz0X4ctpMK2WXfXf1I,1887
 sourcecode/detectors/project.py,sha256=egFUnHC93xFfb-ikGCIOSkRdyP52qytDx9W7pGkX0MY,6525
@@ -51,8 +52,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-0.29.0.dist-info/METADATA,sha256=FeC2-4TQTNZRw7iXfUDelfEv7Art515YgQkW4ZB68AA,25020
-sourcecode-0.29.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-0.29.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-0.29.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-0.29.0.dist-info/RECORD,,
+sourcecode-0.30.0.dist-info/METADATA,sha256=wjMQ_CyxnBDjQ6G_7PLE5crhTdh2sl6wd6Bkdy3t48o,25020
+sourcecode-0.30.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-0.30.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-0.30.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-0.30.0.dist-info/RECORD,,