sourcecode 0.23.0__py3-none-any.whl → 0.25.0__py3-none-any.whl

sourcecode/__init__.py

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

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/architecture_summary.py

@@ -49,6 +49,10 @@ 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 (existing logic)
         entry_points = [
             entry for entry in sm.entry_points
             if not self._is_tooling_path(entry.path)
@@ -57,33 +61,32 @@ class ArchitectureSummarizer:
             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)
-        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()
@@ -93,7 +96,82 @@ 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)
+        fw_names = [f.name for s in sm.stacks 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:
@@ -189,6 +267,44 @@ class ArchitectureSummarizer:
             lines.append("Orquesta el arranque de la aplicacion JVM.")
         return lines
 
+    def _summarize_dotnet_entry(self, stacks: list[StackDetection]) -> list[str]:
+        dotnet_stacks = [s for s in stacks if s.stack == "dotnet"]
+        if not dotnet_stacks:
+            return []
+        lines: list[str] = []
+        signals = [sig for s in dotnet_stacks for sig in s.signals]
+
+        for sig in signals:
+            if "project" in sig and "detected" in sig:
+                lines.append(sig[0].upper() + sig[1:] + ".")
+                break
+
+        for sig in signals:
+            if sig.startswith("project types:"):
+                types = sig.removeprefix("project types:").strip()
+                lines.append(f"Stack: {types}.")
+                break
+
+        for sig in signals:
+            if sig.startswith("target frameworks:"):
+                fws = sig.removeprefix("target frameworks:").strip()
+                lines.append(f"Target: {fws}.")
+                break
+
+        for sig in signals:
+            if sig.startswith("architecture:"):
+                pattern = sig.removeprefix("architecture:").strip()
+                lines.append(f"Patrón detectado: {pattern}.")
+                break
+
+        framework_names = [f.name for s in dotnet_stacks for f in s.frameworks]
+        if framework_names:
+            lines.append(f"Frameworks: {', '.join(framework_names)}.")
+
+        if not lines:
+            lines.append("Solución .NET detectada.")
+        return lines
+
     def _summarize_go_entry(self, path: str, content: str) -> list[str]:
         imports = re.findall(r'"([^"]+)"', content)
         internal = [module for module in imports if not module.startswith(("fmt", "net/", "os", "context"))]
@@ -273,6 +389,16 @@ class ArchitectureSummarizer:
                         confidence="medium",
                     )
                 )
+            elif path.endswith("Program.cs") or path.endswith("Program.fs"):
+                candidates.append(
+                    EntryPoint(
+                        path=path,
+                        stack="dotnet",
+                        kind="cli",
+                        source="convention",
+                        confidence="medium",
+                    )
+                )
         return candidates
 
     def _fallback_priority(self, path: str) -> tuple[int, int, str]:

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