sourcecode 0.24.0__tar.gz → 0.26.0__tar.gz

{sourcecode-0.24.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.24.0 → sourcecode-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 0.24.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.24.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.24.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.24.0",
+    "sourcecode_version": "0.26.0",
     "analyzed_path": "/abs/path/to/project"
   },
   "file_tree": {

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "0.24.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.24.0 → sourcecode-0.26.0}/src/sourcecode/__init__.py

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

{sourcecode-0.24.0 → sourcecode-0.26.0}/src/sourcecode/architecture_analyzer.py

@@ -92,6 +92,21 @@ DOMAIN_ROLES: dict[str, str] = {
 }
 
 LAYER_PATTERNS: dict[str, dict[str, list[str]]] = {
+    "cqrs": {
+        "commands": ["commands", "command"],
+        "queries":  ["queries", "query"],
+    },
+    "clean": {
+        "domain":         ["domain", "domains"],
+        "application":    ["application", "usecases", "usecase"],
+        "infrastructure": ["infrastructure", "infra", "adapters", "persistence"],
+    },
+    "onion": {
+        "domain":      ["domain", "core"],
+        "application": ["application", "usecases"],
+        "ports":       ["ports", "interfaces"],
+        "adapters":    ["adapters", "secondary"],
+    },
     "mvc": {
         "controller": ["controller", "controllers", "routes", "views", "handlers"],
         "model":      ["model", "models", "entity", "entities", "domain"],
@@ -108,12 +123,28 @@ LAYER_PATTERNS: dict[str, dict[str, list[str]]] = {
         "adapter": ["adapter", "adapters"],
         "domain":  ["domain", "core", "model", "models"],
     },
+    "monorepo": {
+        "apps":     ["apps", "applications"],
+        "packages": ["packages", "libs", "modules"],
+    },
     "fullstack": {
         "frontend": ["frontend", "client", "web", "ui", "pages", "components", "app"],
         "backend":  ["backend", "server", "api", "services"],
     },
 }
 
+# Higher value = wins when score ties
+_PATTERN_PRIORITY: dict[str, int] = {
+    "cqrs":       8,
+    "clean":      7,
+    "onion":      6,
+    "hexagonal":  5,
+    "monorepo":   4,
+    "mvc":        3,
+    "layered":    2,
+    "fullstack":  1,
+}
+
 
 class ArchitectureAnalyzer:
     """Analiza la arquitectura de un proyecto a partir de su estructura de ficheros y grafo de modulos."""
@@ -245,9 +276,10 @@ class ArchitectureAnalyzer:
             for part in parts[:-1]:
                 dir_names.add(part.lower())
 
-        # 1. Classical keyword-based pattern matching (MVC, layered, hexagonal, fullstack)
+        # 1. Classical keyword-based pattern matching
         best_pattern = ""
         best_score = 0
+        best_priority = -1
         best_matched: dict[str, list[str]] = {}
 
         for pattern_name, layer_keys in LAYER_PATTERNS.items():
@@ -257,8 +289,10 @@ class ArchitectureAnalyzer:
                 if matched_dirs:
                     matched[layer_key] = matched_dirs
             score = len(matched)
-            if score > best_score:
+            priority = _PATTERN_PRIORITY.get(pattern_name, 0)
+            if (score, priority) > (best_score, best_priority):
                 best_score = score
+                best_priority = priority
                 best_pattern = pattern_name
                 best_matched = matched
 
@@ -281,23 +315,61 @@ class ArchitectureAnalyzer:
                 ))
             return best_pattern, layers
 
-        # 2. Functional file-naming heuristic: *_analyzer.py, cli.py, schema.py, …
+        # 2. Microservices structural detection (before file-naming heuristics)
+        microservices_result = self._detect_microservices(source_paths)
+        if microservices_result is not None:
+            return microservices_result
+
+        # 3. Functional file-naming heuristic: *_analyzer.py, cli.py, schema.py, …
         func_result = self._detect_layered_functional(source_paths)
         if func_result is not None:
             return func_result
 
-        # 3. Modular sub-package heuristic: ≥2 distinct named sub-packages
+        # 4. Modular sub-package heuristic: ≥2 distinct named sub-packages
         modular_result = self._detect_modular(source_paths)
         if modular_result is not None:
             return modular_result
 
-        # 4. Fallback: flat (shallow) vs truly unknown (deep but unrecognised)
+        # 5. Fallback: flat (shallow) vs truly unknown (deep but unrecognised)
         max_depth = max(
             (len(p.replace("\\", "/").split("/")) - 1 for p in source_paths),
             default=0,
         )
         return ("flat" if max_depth <= 2 else "unknown"), []
 
+    def _detect_microservices(
+        self, paths: list[str]
+    ) -> Optional[tuple[str, list[ArchitectureLayer]]]:
+        """Detect microservices from multiple sibling service directories or services/* pattern."""
+        # Pattern 1: explicit services/* subdirectories
+        service_subdirs: dict[str, list[str]] = {}
+        for p in paths:
+            parts = p.replace("\\", "/").split("/")
+            if len(parts) >= 3 and parts[0].lower() == "services":
+                service_subdirs.setdefault(parts[1], []).append(p)
+        if len(service_subdirs) >= 3:
+            return "microservices", [
+                ArchitectureLayer(name=k, pattern="microservices", files=v, confidence="medium")
+                for k, v in list(service_subdirs.items())[:8]
+            ]
+
+        # Pattern 2: multiple top-level dirs each containing a canonical entry file
+        _ENTRY_FILES = {"main.go", "main.py", "server.js", "server.ts", "main.ts", "app.py"}
+        entry_dirs: dict[str, list[str]] = {}
+        for p in paths:
+            parts = p.replace("\\", "/").split("/")
+            if len(parts) >= 2 and parts[-1].lower() in _ENTRY_FILES:
+                top = parts[0]
+                if top.lower() not in _SRC_TRANSPARENT and top.lower() not in _TEST_DIRS:
+                    entry_dirs.setdefault(top, []).append(p)
+        if len(entry_dirs) >= 4:
+            return "microservices", [
+                ArchitectureLayer(name=k, pattern="microservices", files=v, confidence="low")
+                for k, v in list(entry_dirs.items())[:8]
+            ]
+
+        return None
+
     def _detect_layered_functional(
         self, paths: list[str]
     ) -> Optional[tuple[str, list[ArchitectureLayer]]]:

{sourcecode-0.24.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"}
@@ -49,43 +55,46 @@ class ArchitectureSummarizer:
         if not file_paths:
             return None
 
+        # Rich path: use all available signals (stacks, arch analysis, graph)
+        rich_lines = self._build_rich_lines(sm)
+
+        # 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)
             entry_points = fallback[:1]
 
-        if not entry_points:
-            return "Arquitectura no inferida con suficiente evidencia estatica."
-
-        entry_point = entry_points[0]
-        content = self._read_file(entry_point.path)
-        if content is None:
-            return f"Entry point principal: {entry_point.path}. Arquitectura no inferida con suficiente evidencia estatica."
-
-        suffix = Path(entry_point.path).suffix
-        if suffix in _PYTHON_EXTENSIONS:
-            lang_lines = self._summarize_python_entry(entry_point.path, content)
-        elif suffix in _NODE_EXTENSIONS:
-            lang_lines = self._summarize_node_entry(entry_point.path, content)
-        elif suffix in _GO_EXTENSIONS:
-            lang_lines = self._summarize_go_entry(entry_point.path, content)
-        elif suffix in _JAVA_EXTENSIONS:
-            lang_lines = self._summarize_java_entry(entry_point.path, content, sm.stacks)
-        elif suffix in {".cs", ".fs", ".vb"}:
-            lang_lines = self._summarize_dotnet_entry(sm.stacks)
-        else:
-            lang_lines = []
-
-        if lang_lines:
-            # Product-level description available — no need for internal "Entry point: ..." header
-            lines = lang_lines
-        else:
+        lang_lines: list[str] = []
+        if entry_points:
+            entry_point = entry_points[0]
+            content = self._read_file(entry_point.path)
+            if content:
+                suffix = Path(entry_point.path).suffix
+                if suffix in _PYTHON_EXTENSIONS:
+                    lang_lines = self._summarize_python_entry(entry_point.path, content)
+                elif suffix in _NODE_EXTENSIONS:
+                    lang_lines = self._summarize_node_entry(entry_point.path, content)
+                elif suffix in _GO_EXTENSIONS:
+                    lang_lines = self._summarize_go_entry(entry_point.path, content)
+                elif suffix in _JAVA_EXTENSIONS:
+                    lang_lines = self._summarize_java_entry(entry_point.path, content, sm.stacks)
+                elif suffix in {".cs", ".fs", ".vb"}:
+                    lang_lines = self._summarize_dotnet_entry(sm.stacks)
+
+        # Merge: rich lines first, stack-specific details appended (deduped)
+        lines = rich_lines + [l for l in lang_lines if l not in rich_lines]
+
+        if not lines and entry_points:
+            entry_point = entry_points[0]
             lines = [self._describe_entry_point(entry_point, sm.project_type)]
-            if not lang_lines:
-                lines.append("Orquesta modulos internos no detallados por el analisis estatico disponible.")
+
+        if not lines:
+            return "Arquitectura no inferida con suficiente evidencia estatica."
 
         unique_lines: list[str] = []
         seen: set[str] = set()
@@ -95,7 +104,106 @@ class ArchitectureSummarizer:
                 continue
             seen.add(line)
             unique_lines.append(line)
-        return "\n".join(unique_lines[:5]) if unique_lines else None
+        return "\n".join(unique_lines[:6]) if unique_lines else None
+
+    def _build_rich_lines(self, sm: SourceMap) -> list[str]:
+        """Generate architect-quality summary lines from stacks, arch analysis, and graph."""
+        if not sm.stacks:
+            return []
+
+        # Compute arch analysis inline if needed
+        arch = sm.architecture
+        if arch is None and sm.file_paths:
+            try:
+                from sourcecode.architecture_analyzer import ArchitectureAnalyzer
+                arch = ArchitectureAnalyzer().analyze(self.root, sm)
+            except Exception:
+                arch = None
+
+        lines: list[str] = []
+
+        # Line 1: project description (type + stack + frameworks)
+        project_line = self._describe_project_type(sm)
+        if project_line:
+            lines.append(project_line)
+
+        # Line 2: architecture pattern + layers
+        if arch and arch.pattern not in (None, "unknown", "flat"):
+            arch_line = self._describe_arch_pattern(arch)
+            if arch_line:
+                lines.append(arch_line)
+
+        # Line 3: coupling notes (if graph analytics present)
+        if sm.module_graph_summary:
+            mgr = sm.module_graph_summary
+            coupling_parts: list[str] = []
+            if mgr.cycle_count > 0:
+                s = "s" if mgr.cycle_count > 1 else ""
+                coupling_parts.append(f"{mgr.cycle_count} import cycle{s}")
+            if mgr.hubs:
+                hub_names = [h.removeprefix("module:").split("/")[-1] for h in mgr.hubs[:2]]
+                coupling_parts.append(f"hub modules: {', '.join(hub_names)}")
+            if coupling_parts:
+                lines.append(f"Coupling: {'; '.join(coupling_parts)}.")
+
+        return lines
+
+    def _describe_project_type(self, sm: SourceMap) -> str:
+        from sourcecode.context_summarizer import _STACK_LABELS, _TYPE_LABELS
+        runtime = _TYPE_LABELS.get(sm.project_type or "", "")
+        primary = next((s for s in sm.stacks if s.primary), sm.stacks[0] if sm.stacks else None)
+        if primary is None:
+            return ""
+        stack_label = _STACK_LABELS.get(primary.stack, primary.stack)
+
+        # 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}."
+        return f"{stack_label} project{fw_str}."
+
+    def _describe_arch_pattern(self, arch: Any) -> str:
+        pattern_labels = {
+            "clean": "Clean Architecture",
+            "onion": "Onion Architecture",
+            "hexagonal": "Hexagonal Architecture",
+            "layered": "Layered Architecture",
+            "mvc": "MVC pattern",
+            "cqrs": "CQRS pattern",
+            "microservices": "Microservices",
+            "monorepo": "Monorepo workspace",
+            "modular": "Modular architecture",
+        }
+        label = pattern_labels.get(arch.pattern, arch.pattern.replace("_", " ").title() if arch.pattern else "")
+        if not label:
+            return ""
+        if arch.layers:
+            layer_names = [l.name for l in arch.layers[:4]]
+            return f"{label} with {', '.join(layer_names)} layers."
+        return f"{label} pattern detected."
 
     def _summarize_python_entry(self, path: str, content: str) -> list[str]:
         try:
@@ -367,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.24.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/context_summarizer.py

@@ -0,0 +1,191 @@
+from __future__ import annotations
+
+"""Generates a compact, high-signal ContextSummary for AI agent consumption.
+
+Uses all available analysis: stacks, architecture, graph analytics, entry points.
+Fast path: O(1) from pre-computed data. Falls back to inline ArchitectureAnalyzer if needed.
+"""
+
+from pathlib import Path
+from typing import Any, Optional
+
+from sourcecode.schema import ContextSummary, SourceMap
+
+_STACK_LABELS: dict[str, str] = {
+    "python": "Python",
+    "nodejs": "Node.js/TypeScript",
+    "go": "Go",
+    "rust": "Rust",
+    "dotnet": "C#/.NET",
+    "java": "Java",
+    "kotlin": "Kotlin",
+    "scala": "Scala",
+    "ruby": "Ruby",
+    "php": "PHP",
+    "dart": "Dart/Flutter",
+    "elixir": "Elixir",
+}
+
+_TYPE_LABELS: dict[str, str] = {
+    "api": "REST API",
+    "webapp": "Web app",
+    "fullstack": "Full-stack app",
+    "cli": "CLI tool",
+    "worker": "Background worker / service",
+    "library": "Library / package",
+    "unknown": "Application",
+}
+
+_LAYER_HINTS: dict[str, str] = {
+    "domain": "Core domain logic and entities",
+    "application": "Application / use-case orchestration",
+    "infrastructure": "External integrations (DB, messaging, APIs)",
+    "controller": "HTTP handlers and route definitions",
+    "service": "Business logic services",
+    "repository": "Data access / persistence",
+    "commands": "CQRS write side (commands)",
+    "queries": "CQRS read side (queries)",
+    "ports": "Hexagonal ports (interfaces)",
+    "adapters": "Hexagonal adapters (implementations)",
+    "processing": "Data processing / analysis",
+    "orchestration": "Orchestration / coordination",
+    "data": "Data models / schemas",
+    "apps": "Application packages (monorepo apps)",
+    "packages": "Shared packages (monorepo libs)",
+}
+
+
+class ContextSummarizer:
+    """Generates ContextSummary from a fully-populated SourceMap."""
+
+    def __init__(self, root: Path) -> None:
+        self.root = root
+
+    def generate(self, sm: SourceMap) -> Optional[ContextSummary]:
+        try:
+            return self._build(sm)
+        except Exception:
+            return None
+
+    def _build(self, sm: SourceMap) -> ContextSummary:
+        arch = sm.architecture
+        if arch is None and sm.file_paths:
+            from sourcecode.architecture_analyzer import ArchitectureAnalyzer
+            arch = ArchitectureAnalyzer().analyze(self.root, sm)
+
+        return ContextSummary(
+            runtime_shape=self._infer_runtime_shape(sm),
+            dominant_pattern=self._dominant_pattern(arch),
+            critical_modules=self._collect_critical_modules(sm),
+            layer_map=self._build_layer_map(arch),
+            edit_hints=self._generate_edit_hints(arch, sm),
+            coupling_notes=self._coupling_notes(sm),
+        )
+
+    def _infer_runtime_shape(self, sm: SourceMap) -> str:
+        runtime = _TYPE_LABELS.get(sm.project_type or "", "Application")
+
+        # Gather framework names from all stacks (deduplicated, max 3)
+        fw_names: list[str] = []
+        seen: set[str] = set()
+        for stack in sm.stacks:
+            for fw in stack.frameworks:
+                if fw.name not in seen:
+                    seen.add(fw.name)
+                    fw_names.append(fw.name)
+        fw_names = fw_names[:3]
+
+        if fw_names:
+            return f"{runtime} — {', '.join(fw_names)}"
+
+        # Fallback: stack label
+        primary = next((s for s in sm.stacks if s.primary), sm.stacks[0] if sm.stacks else None)
+        if primary:
+            label = _STACK_LABELS.get(primary.stack, primary.stack)
+            return f"{runtime} — {label}"
+
+        return runtime
+
+    def _dominant_pattern(self, arch: Any) -> Optional[str]:
+        if arch is None:
+            return None
+        pattern = arch.pattern
+        if pattern in (None, "unknown", "flat"):
+            return None
+        return pattern
+
+    def _collect_critical_modules(self, sm: SourceMap) -> list[str]:
+        critical: list[str] = []
+        seen: set[str] = set()
+
+        for ep in sm.entry_points[:3]:
+            if ep.path and ep.path not in seen:
+                seen.add(ep.path)
+                critical.append(ep.path)
+
+        mgr = sm.module_graph_summary
+        if mgr:
+            for hub in mgr.hubs[:4]:
+                path = hub.removeprefix("module:")
+                if path and path not in seen:
+                    seen.add(path)
+                    critical.append(path)
+
+        return critical[:6]
+
+    def _build_layer_map(self, arch: Any) -> dict[str, list[str]]:
+        if arch is None or not arch.layers:
+            return {}
+        result: dict[str, list[str]] = {}
+        for layer in arch.layers[:6]:
+            dirs: set[str] = set()
+            for f in layer.files[:8]:
+                parts = f.replace("\\", "/").split("/")
+                if len(parts) >= 2:
+                    dirs.add("/".join(parts[:-1]) + "/")
+                else:
+                    dirs.add(f)
+            if dirs:
+                result[layer.name] = sorted(dirs)[:3]
+        return result
+
+    def _generate_edit_hints(self, arch: Any, sm: SourceMap) -> list[str]:
+        hints: list[str] = []
+        if arch is None or not arch.layers:
+            return hints
+
+        for layer in arch.layers[:5]:
+            hint_label = _LAYER_HINTS.get(layer.name, layer.name)
+            dirs: list[str] = []
+            seen_dirs: set[str] = set()
+            for f in layer.files[:6]:
+                parts = f.replace("\\", "/").split("/")
+                d = "/".join(parts[:-1]) + "/" if len(parts) >= 2 else f
+                if d not in seen_dirs:
+                    seen_dirs.add(d)
+                    dirs.append(d)
+            if dirs:
+                dir_str = ", ".join(dirs[:2])
+                hints.append(f"{hint_label} → {dir_str}")
+
+        return hints[:4]
+
+    def _coupling_notes(self, sm: SourceMap) -> list[str]:
+        notes: list[str] = []
+        mgr = sm.module_graph_summary
+        if mgr is None:
+            return notes
+
+        if mgr.cycle_count > 0:
+            s = "s" if mgr.cycle_count > 1 else ""
+            notes.append(f"{mgr.cycle_count} circular import cycle{s} detected")
+
+        if mgr.hubs:
+            names = [h.removeprefix("module:").split("/")[-1] for h in mgr.hubs[:3]]
+            notes.append(f"High-coupling hubs: {', '.join(names)}")
+
+        orphan_count = len(mgr.orphans)
+        if orphan_count >= 3:
+            notes.append(f"{orphan_count} orphan modules (unreferenced)")
+
+        return notes

{sourcecode-0.24.0 → sourcecode-0.26.0}/src/sourcecode/detectors/dotnet.py

@@ -55,9 +55,14 @@ class DotnetDetector(AbstractDetector):
             if project is not None:
                 projects.append(project)
 
-        frameworks = self._collect_frameworks(projects)
+        from sourcecode.detectors.hybrid import merge_framework_detections, scan_for_frameworks
+
+        manifest_frameworks = self._collect_frameworks(projects)
         signals = self._build_signals(projects)
-        entry_points = self._detect_entry_points(context, projects, frameworks)
+        entry_points = self._detect_entry_points(context, projects, manifest_frameworks)
+        priority = [ep.path for ep in entry_points]
+        import_frameworks = scan_for_frameworks(context.root, context.file_tree, "dotnet", priority_paths=priority)
+        frameworks = merge_framework_detections(manifest_frameworks, import_frameworks)
 
         manifests = project_paths + [p for p in all_paths if p.endswith(".sln")]
         stack = StackDetection(