sourcecode 0.25.0__tar.gz → 0.26.0__tar.gz

{sourcecode-0.25.0 → sourcecode-0.26.0}/.gitignore

@@ -24,7 +24,10 @@ src/*.egg-info/
 
 # Environment / secrets
 *.env
+.env.*
 *.secret.json
+*.local.json
+*.local.toml
 
 # OS cruft
 .DS_Store

{sourcecode-0.25.0 → sourcecode-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 0.25.0
+Version: 0.26.0
 Summary: Genera un mapa de contexto estructurado de proyectos de software para agentes IA
 License: MIT
 Requires-Python: >=3.9

{sourcecode-0.25.0 → sourcecode-0.26.0}/docs/schema.md

@@ -81,7 +81,7 @@ Campos:
 {
   "schema_version": "1.0",
   "generated_at": "2026-04-07T19:41:05.686277+00:00",
-  "sourcecode_version": "0.25.0",
+  "sourcecode_version": "0.26.0",
   "analyzed_path": "/abs/path/to/project"
 }
 ```
@@ -645,7 +645,7 @@ Ejemplo de salida para un monorepo con web Node.js y API Python con `--dependenc
   "metadata": {
     "schema_version": "1.0",
     "generated_at": "2026-04-07T19:41:05.686277+00:00",
-    "sourcecode_version": "0.25.0",
+    "sourcecode_version": "0.26.0",
     "analyzed_path": "/abs/path/to/project"
   },
   "file_tree": {

{sourcecode-0.25.0 → sourcecode-0.26.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "0.25.0"
+version = "0.26.0"
 description = "Genera un mapa de contexto estructurado de proyectos de software para agentes IA"
 readme = "README.md"
 requires-python = ">=3.9"

{sourcecode-0.25.0 → sourcecode-0.26.0}/src/sourcecode/__init__.py

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

{sourcecode-0.25.0 → sourcecode-0.26.0}/src/sourcecode/architecture_summary.py

@@ -9,6 +9,12 @@ from sourcecode.schema import EntryPoint, SourceMap, StackDetection
 from sourcecode.tree_utils import flatten_file_tree
 
 _TOOLING_PREFIXES = (".claude/", ".vscode/", "bin/")
+_AUXILIARY_PATH_PARTS: frozenset[str] = frozenset({
+    "benchmark", "benchmarks", "bench", "benches",
+    "demo", "demos", "example", "examples",
+    "docs", "doc", "fixture", "fixtures",
+    "playground", "playgrounds", "sandbox",
+})
 _PYTHON_EXTENSIONS = {".py"}
 _NODE_EXTENSIONS = {".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"}
 _GO_EXTENSIONS = {".go"}
@@ -52,10 +58,12 @@ class ArchitectureSummarizer:
         # Rich path: use all available signals (stacks, arch analysis, graph)
         rich_lines = self._build_rich_lines(sm)
 
-        # Stack-specific entry point analysis (existing logic)
+        # Stack-specific entry point analysis: exclude tooling + auxiliary paths
         entry_points = [
             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")
         ]
         if not entry_points:
             fallback = self._infer_fallback_entry_points(file_paths, sm.stacks)
@@ -147,7 +155,31 @@ class ArchitectureSummarizer:
         if primary is None:
             return ""
         stack_label = _STACK_LABELS.get(primary.stack, primary.stack)
-        fw_names = [f.name for s in sm.stacks for f in s.frameworks[:2]][:3]
+
+        # For monorepos: only show frameworks from runtime-critical packages,
+        # not every framework found in every workspace (avoids "React project" misclassification)
+        if sm.project_type == "monorepo" and sm.monorepo_packages:
+            runtime_roles = {"runtime_core", "plugin_host", "backend_runtime"}
+            runtime_paths = {p.path for p in sm.monorepo_packages if p.architectural_role in runtime_roles}
+            fw_names = [
+                f.name
+                for s in sm.stacks
+                if not s.workspace or s.workspace in runtime_paths
+                for f in s.frameworks[:2]
+            ]
+            fw_names = list(dict.fromkeys(fw_names))[:3]  # dedup, preserve order
+        else:
+            # Filter out frameworks from auxiliary or tooling stacks (docs/, benchmarks/, etc.)
+            fw_names = [
+                f.name
+                for s in sm.stacks
+                if not self._is_tooling_path(s.root or "")
+                and not self._is_tooling_path(s.workspace or "")
+                and not self._is_auxiliary_path(s.root or "")
+                and not self._is_auxiliary_path(s.workspace or "")
+                for f in s.frameworks[:2]
+            ][:3]
+
         fw_str = f" using {', '.join(fw_names)}" if fw_names else ""
         if runtime:
             return f"{stack_label} {runtime.lower()}{fw_str}."
@@ -443,6 +475,12 @@ class ArchitectureSummarizer:
         except OSError:
             return None
 
+    def _is_auxiliary_path(self, path: str | None) -> bool:
+        if not path:
+            return False
+        parts = path.replace("\\", "/").strip("/").lower().split("/")
+        return any(p in _AUXILIARY_PATH_PARTS for p in parts)
+
     def _is_tooling_path(self, path: str | None) -> bool:
         if not path:
             return False

{sourcecode-0.25.0 → sourcecode-0.26.0}/src/sourcecode/cli.py

@@ -555,6 +555,14 @@ def main(
                 semantic_summary=sem_sum,
             )
 
+    # Runtime architecture — classify workspace packages for structural summaries
+    if workspace_analysis.workspaces:
+        from sourcecode.runtime_classifier import RuntimeClassifier
+        sm.monorepo_packages = RuntimeClassifier().classify(
+            target,
+            [ws.path for ws in workspace_analysis.workspaces],
+        )
+
     # Phase 9: LLM Output Quality — poblar campos derivados
     from sourcecode.architecture_summary import ArchitectureSummarizer
     from sourcecode.summarizer import ProjectSummarizer

sourcecode-0.26.0/src/sourcecode/detectors/nodejs.py

@@ -0,0 +1,265 @@
+from __future__ import annotations
+
+from typing import Any
+
+from sourcecode.detectors.base import (
+    AbstractDetector,
+    DetectionContext,
+    EntryPoint,
+    StackDetection,
+)
+from sourcecode.detectors.parsers import load_json_file, unique_strings
+from sourcecode.schema import FrameworkDetection
+from sourcecode.tree_utils import path_exists_in_tree
+
+_FRAMEWORK_MAP = {
+    "next": "Next.js",
+    "express": "Express",
+    "react": "React",
+    "vite": "Vite",
+    "vue": "Vue",
+    "svelte": "Svelte",
+    "@nestjs/core": "NestJS",
+    "fastify": "Fastify",
+    "hono": "Hono",
+    "@remix-run/node": "Remix",
+    "@remix-run/react": "Remix",
+    "astro": "Astro",
+    "nuxt": "Nuxt",
+    "@nuxt/kit": "Nuxt",
+    "gatsby": "Gatsby",
+    "@angular/core": "Angular",
+    "solid-js": "SolidJS",
+    "@trpc/server": "tRPC",
+    "graphql": "GraphQL",
+    "@apollo/server": "Apollo",
+    "apollo-server": "Apollo",
+    "koa": "Koa",
+    "elysia": "Elysia",
+}
+
+
+class NodejsDetector(AbstractDetector):
+    name = "nodejs"
+    priority = 20
+
+    def can_detect(self, context: DetectionContext) -> bool:
+        if "package.json" not in context.manifests:
+            return False
+        if not path_exists_in_tree(context.file_tree, "package.json"):
+            return False
+        manifest_type = context.manifest_types.get("package.json", "application")
+        return manifest_type not in {"auxiliary", "config"}
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        package_json = load_json_file(context.root / "package.json")
+        if package_json is None:
+            return [], []
+
+        from sourcecode.detectors.hybrid import merge_framework_detections, scan_for_frameworks
+
+        dependency_names = self._collect_dependency_names(package_json)
+        seen_fw: set[str] = set()
+        manifest_frameworks = []
+        for pkg_name, label in _FRAMEWORK_MAP.items():
+            if pkg_name in dependency_names and label not in seen_fw:
+                seen_fw.add(label)
+                manifest_frameworks.append(FrameworkDetection(name=label, source="package.json"))
+
+        package_manager = self._detect_package_manager(context)
+        entry_points = self._collect_entry_points(context, package_json)
+        priority = [ep.path for ep in entry_points]
+        import_frameworks = scan_for_frameworks(context.root, context.file_tree, "nodejs", priority_paths=priority)
+        frameworks = merge_framework_detections(manifest_frameworks, import_frameworks)
+        signals = self._detect_monorepo_signals(context, package_json)
+
+        stack = StackDetection(
+            stack="nodejs",
+            detection_method="manifest",
+            confidence="high",
+            frameworks=frameworks,
+            package_manager=package_manager,
+            manifests=["package.json"],
+            signals=signals,
+        )
+        return [stack], entry_points
+
+    def _detect_monorepo_signals(
+        self, context: DetectionContext, package_json: dict[str, Any]
+    ) -> list[str]:
+        signals: list[str] = []
+        if path_exists_in_tree(context.file_tree, "turbo.json"):
+            signals.append("monorepo:turbo")
+        elif path_exists_in_tree(context.file_tree, "nx.json"):
+            signals.append("monorepo:nx")
+        elif path_exists_in_tree(context.file_tree, "pnpm-workspace.yaml"):
+            signals.append("monorepo:pnpm")
+        elif isinstance(package_json.get("workspaces"), (list, dict)):
+            signals.append("monorepo:npm-workspaces")
+        return signals
+
+    def _collect_dependency_names(self, package_json: dict[str, Any]) -> set[str]:
+        names: set[str] = set()
+        for field in ("dependencies", "devDependencies", "peerDependencies", "optionalDependencies"):
+            raw = package_json.get(field, {})
+            if isinstance(raw, dict):
+                names.update(str(name) for name in raw)
+        return names
+
+    def _detect_package_manager(self, context: DetectionContext) -> str | None:
+        for filename, package_manager in (
+            ("bun.lockb", "bun"),
+            ("pnpm-lock.yaml", "pnpm"),
+            ("package-lock.json", "npm"),
+            ("yarn.lock", "yarn"),
+        ):
+            if path_exists_in_tree(context.file_tree, filename):
+                return package_manager
+        return None
+
+    # Directories that indicate a non-production entry point
+    _AUXILIARY_DIRS: frozenset[str] = frozenset({
+        "benchmark", "benchmarks", "bench",
+        "example", "examples",
+        "demo", "demos",
+        "playground", "playgrounds",
+        "fixture", "fixtures",
+        "sandbox", "e2e", "docs",
+    })
+
+    def _collect_entry_points(
+        self, context: DetectionContext, package_json: dict[str, Any]
+    ) -> list[EntryPoint]:
+        entry_points: list[EntryPoint] = []
+        seen: set[str] = set()
+
+        # Priority 1: package.json scripts — most reliable signal
+        scripts = package_json.get("scripts", {})
+        if isinstance(scripts, dict):
+            for script_name, script_cmd in scripts.items():
+                if not isinstance(script_cmd, str):
+                    continue
+                ep_type, kind = self._classify_script(script_name)
+                if ep_type is None:
+                    continue
+                # Extract file path from script command
+                path = self._extract_script_path(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,
+                        ))
+
+        # Priority 2: package.json bin — CLI production entry points
+        bin_field = package_json.get("bin")
+        bin_paths: list[str] = []
+        if isinstance(bin_field, str) and bin_field.strip():
+            bin_paths.append(bin_field.strip())
+        elif isinstance(bin_field, dict):
+            bin_paths.extend(
+                str(v).strip() for v in bin_field.values()
+                if isinstance(v, str) and v.strip()
+            )
+        for path in bin_paths:
+            if path not in seen and path_exists_in_tree(context.file_tree, path):
+                seen.add(path)
+                entry_points.append(EntryPoint(
+                    path=path,
+                    stack="nodejs",
+                    kind="cli",
+                    source="package.json#bin",
+                    confidence="high",
+                    reason="bin",
+                    evidence="declared in package.json bin field",
+                    entrypoint_type="production",
+                ))
+
+        # Priority 3: package.json main (library/module entry)
+        main = package_json.get("main")
+        if isinstance(main, str) and main.strip():
+            path = main.strip()
+            if path not in seen and path_exists_in_tree(context.file_tree, path):
+                seen.add(path)
+                entry_points.append(EntryPoint(
+                    path=path,
+                    stack="nodejs",
+                    kind="server",
+                    source="package.json",
+                    confidence="high",
+                    entrypoint_type="production",
+                ))
+
+        # Priority 4: filename conventions (last resort — penalize auxiliary dirs)
+        for path in [
+            "server.js", "server.ts",
+            "src/index.js", "src/index.ts",
+            "src/main.js", "src/main.ts", "src/main.tsx",
+            "app/page.tsx", "pages/index.js",
+        ]:
+            if path in seen or not path_exists_in_tree(context.file_tree, path):
+                continue
+            ep_type = self._path_entrypoint_type(path)
+            kind = "web" if path.startswith(("app/", "pages/")) else "server"
+            entry_points.append(EntryPoint(
+                path=path,
+                stack="nodejs",
+                kind=kind,
+                source="convention",
+                confidence="medium",
+                reason="convention",
+                entrypoint_type=ep_type,
+            ))
+
+        return entry_points
+
+    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"):
+            return "production", "server"
+        if lower in ("dev", "develop", "watch"):
+            return "development", "server"
+        if lower in ("cli", "bin"):
+            return "production", "cli"
+        if "benchmark" in lower or lower == "bench":
+            return "benchmark", "script"
+        if lower.startswith("example") or lower.startswith("demo"):
+            return "example", "script"
+        return None, ""
+
+    def _extract_script_path(self, cmd: str, context: DetectionContext) -> str | None:
+        """Extract a likely source file path from a script command string."""
+        import shlex
+        try:
+            parts = shlex.split(cmd)
+        except ValueError:
+            parts = cmd.split()
+        # Skip executor prefixes: node, ts-node, tsx, nodemon, npx, etc.
+        _SKIP = {"node", "ts-node", "tsx", "nodemon", "npx", "pnpm", "yarn", "npm", "bun",
+                 "--inspect", "--inspect-brk", "--require", "-r", "run", "exec"}
+        for part in parts:
+            if part.startswith("-") or part in _SKIP or "=" in part:
+                continue
+            # It looks like a file path (has slash or known extension)
+            p = part.strip("'\"")
+            if ("/" in p or p.endswith((".js", ".ts", ".mjs", ".cjs"))) and not p.startswith("@"):
+                return p
+        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):
+            return "example"
+        return "production"

{sourcecode-0.25.0 → sourcecode-0.26.0}/src/sourcecode/graph_analyzer.py

@@ -15,6 +15,44 @@ GraphDetail = Literal["high", "medium", "full"]
 GraphImportance = Literal["high", "medium", "low"]
 
 
+# Node.js stdlib modules — omit from graph unless --graph-detail full
+_NODE_STDLIB: frozenset[str] = frozenset({
+    "fs", "fs/promises", "path", "os", "child_process", "process",
+    "net", "http", "https", "http2", "stream", "events", "util",
+    "crypto", "buffer", "url", "querystring", "string_decoder",
+    "readline", "repl", "assert", "dns", "dgram", "vm",
+    "worker_threads", "cluster", "module", "v8", "perf_hooks",
+    "async_hooks", "inspector", "tty", "zlib", "domain",
+    "timers", "timers/promises", "console", "constants",
+    "node:fs", "node:path", "node:os", "node:crypto", "node:buffer",
+    "node:stream", "node:events", "node:util", "node:http", "node:https",
+    "node:child_process", "node:process", "node:worker_threads",
+})
+
+# Python stdlib modules — omit from graph unless --graph-detail full
+_PYTHON_STDLIB: frozenset[str] = frozenset({
+    "os", "sys", "re", "io", "abc", "ast", "copy", "csv",
+    "enum", "functools", "itertools", "json", "logging", "math",
+    "pathlib", "random", "shutil", "string", "subprocess",
+    "threading", "time", "typing", "uuid", "warnings",
+    "collections", "contextlib", "dataclasses", "datetime",
+    "decimal", "difflib", "email", "glob", "hashlib", "hmac",
+    "http", "importlib", "inspect", "operator", "pickle",
+    "platform", "pprint", "queue", "signal", "socket",
+    "sqlite3", "stat", "struct", "tempfile", "textwrap",
+    "traceback", "unicodedata", "unittest", "urllib", "weakref",
+    "xml", "zipfile", "zlib",
+})
+
+# External packages that add noise without structural signal
+_NODE_NOISE_PACKAGES: frozenset[str] = frozenset({
+    "lodash", "moment", "date-fns", "uuid", "chalk", "debug",
+    "yargs", "commander", "dotenv", "cross-env",
+    "eslint", "prettier", "typescript", "ts-node",
+    "@types/node", "@types/react",
+})
+
+
 class GraphAnalyzer:
     """Construye un grafo estructural parcial y seguro del proyecto."""
 
@@ -908,7 +946,14 @@ class GraphAnalyzer:
                         )
                     )
                 else:
-                    limitations.append(f"node_external:{relative_path}:{spec}")
+                    # Silently skip stdlib and noise packages — they add no structural signal
+                    bare = spec.removeprefix("node:")
+                    root_pkg = bare.split("/")[0]
+                    if (spec not in _NODE_STDLIB
+                            and bare not in _NODE_STDLIB
+                            and root_pkg not in _NODE_STDLIB
+                            and root_pkg not in _NODE_NOISE_PACKAGES):
+                        limitations.append(f"node_external:{relative_path}:{spec}")
 
         return nodes, edges, limitations
 
@@ -1121,6 +1166,10 @@ class GraphAnalyzer:
     def _resolve_python_import(
         self, module_name: str, module_map: dict[str, str]
     ) -> Optional[str]:
+        # Skip stdlib modules — they add no structural signal to the project graph
+        root_module = module_name.split(".")[0]
+        if root_module in _PYTHON_STDLIB:
+            return None
         for path, candidate in module_map.items():
             if candidate == module_name:
                 return path

{sourcecode-0.25.0 → sourcecode-0.26.0}/src/sourcecode/prepare_context.py

@@ -359,10 +359,15 @@ class TaskContextBuilder:
 
         # ── 2. Detect stacks + entry points ───────────────────────────────
         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)
-        stacks, project_type = detector.classify_results(file_tree, stacks, entry_points)
+        stacks, project_type = detector.classify_results(
+            file_tree, stacks, entry_points,
+            project_type_override="monorepo" if workspace_analysis.is_monorepo else None,
+        )
 
         # ── 3. Summarize ───────────────────────────────────────────────────
         from sourcecode.schema import AnalysisMetadata, SourceMap
@@ -378,6 +383,14 @@ class TaskContextBuilder:
         )
         sm.file_paths = all_paths
 
+        # Classify workspace packages for structural context
+        if workspace_analysis.workspaces:
+            from sourcecode.runtime_classifier import RuntimeClassifier
+            sm.monorepo_packages = RuntimeClassifier().classify(
+                self.root,
+                [ws.path for ws in workspace_analysis.workspaces],
+            )
+
         project_summary = ProjectSummarizer(self.root).generate(sm)
         architecture_summary = ArchitectureSummarizer(self.root).generate(sm)
 
@@ -436,13 +449,31 @@ class TaskContextBuilder:
                     for p, n in sorted(counts2.items(), key=lambda x: -x[1])[:8]
                 ]
 
+        # ── 5b. Git signals for ranking ────────────────────────────────────
+        git_hotspots: dict[str, int] = {}
+        uncommitted_files: set[str] = set()
+        try:
+            from sourcecode.git_analyzer import GitAnalyzer
+            _gc = GitAnalyzer().analyze(self.root, depth=30, days=90)
+            _bad = {"no_git_repo", "git_not_found", "git_timeout"}
+            if _gc and not (_bad & set(_gc.limitations)):
+                git_hotspots = {h.file: h.commit_count for h in _gc.change_hotspots}
+                if _gc.uncommitted_changes:
+                    _uc = _gc.uncommitted_changes
+                    uncommitted_files = set(_uc.staged) | set(_uc.unstaged)
+        except Exception:
+            pass
+
         # ── 6. Rank files ──────────────────────────────────────────────────
         entry_set = {ep.path for ep in entry_points}
         test_set = {p for p in all_paths if self._is_test(p)}
         source_set = {p for p in all_paths if not self._is_test(p) and self._is_source(p)}
 
         relevant_files = self._rank_files(
-            task_name, spec, all_paths, entry_set, test_set
+            task_name, spec, all_paths, entry_set, test_set,
+            monorepo_packages=sm.monorepo_packages if sm.monorepo_packages else None,
+            git_hotspots=git_hotspots,
+            uncommitted_files=uncommitted_files,
         )
 
         # ── 7. Test gaps (generate-tests only) ────────────────────────────
@@ -590,7 +621,21 @@ class TaskContextBuilder:
         all_paths: list[str],
         entry_set: set[str],
         test_set: set[str],
+        monorepo_packages: Optional[list] = None,
+        git_hotspots: Optional[dict[str, int]] = None,
+        uncommitted_files: Optional[set[str]] = None,
     ) -> list[RelevantFile]:
+        from sourcecode.relevance_scorer import RelevanceScorer
+        scorer = RelevanceScorer(monorepo_packages or [])
+
+        # Auxiliary entry points (benchmark, docs, examples) must not get
+        # the production entry boost — they are not runtime signals.
+        runtime_entry_set = {ep for ep in entry_set if not scorer.is_auxiliary(ep)}
+
+        _hotspots = git_hotspots or {}
+        _uncommitted = uncommitted_files or set()
+        _max_churn = max(_hotspots.values(), default=1)
+
         scored: list[tuple[float, RelevantFile]] = []
 
         for path in all_paths:
@@ -599,6 +644,10 @@ class TaskContextBuilder:
             if any(pen in path for pen in spec.ranking_penalties):
                 continue
 
+            # Hard filter: tooling/config noise
+            if scorer.is_noise(path):
+                continue
+
             is_test = path in test_set
             if is_test and task_name != "generate-tests":
                 continue
@@ -606,7 +655,8 @@ class TaskContextBuilder:
             score = 0.0
             reasons: list[str] = []
 
-            if path in entry_set:
+            # Only runtime entry points get the production boost
+            if path in runtime_entry_set:
                 score += 3.0
                 reasons.append("entry point")
 
@@ -625,11 +675,30 @@ class TaskContextBuilder:
                 if not reasons:
                     reasons.append("source file")
 
+            # Operational relevance boost/penalty from package role
+            rel = scorer.score(path)
+            score += (rel - 0.3) * 2.0  # center around 0.3 baseline
+
+            # Suppress auxiliary dirs (benchmarks, docs, examples, demos)
+            if scorer.is_auxiliary(path):
+                score -= 2.0
+
+            # Git churn: frequently changed files are high-signal for active work
+            churn = _hotspots.get(path, 0)
+            if churn > 0:
+                score += (churn / _max_churn) * 1.5
+                reasons.append(f"git churn ({churn})")
+
+            # Uncommitted changes: files actively being edited rank highest
+            if path in _uncommitted:
+                score += 1.0
+                reasons.append("uncommitted changes")
+
             if score <= 0:
                 continue
 
             role = (
-                "entrypoint" if path in entry_set
+                "entrypoint" if path in runtime_entry_set
                 else ("test" if is_test else "source")
             )
             scored.append((score, RelevantFile(