sourcecode 0.23.0__tar.gz → 0.24.0__tar.gz

{sourcecode-0.23.0 → sourcecode-0.24.0}/PKG-INFO

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

{sourcecode-0.23.0 → sourcecode-0.24.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.23.0",
+  "sourcecode_version": "0.24.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.23.0",
+    "sourcecode_version": "0.24.0",
     "analyzed_path": "/abs/path/to/project"
   },
   "file_tree": {

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

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

{sourcecode-0.23.0 → sourcecode-0.24.0}/src/sourcecode/__init__.py

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

{sourcecode-0.23.0 → sourcecode-0.24.0}/src/sourcecode/architecture_summary.py

@@ -74,6 +74,8 @@ class ArchitectureSummarizer:
             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 = []
 
@@ -189,6 +191,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 +313,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-0.24.0/src/sourcecode/detectors/csproj_parser.py

@@ -0,0 +1,203 @@
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass, field
+from pathlib import Path, PurePosixPath
+
+
+@dataclass
+class CsprojProject:
+    name: str
+    path: str                                         # repo-relative path to .csproj
+    project_dir: str                                  # repo-relative folder (empty if root)
+    target_frameworks: list[str] = field(default_factory=list)
+    output_type: str = ""
+    sdk: str = ""
+    project_references: list[str] = field(default_factory=list)  # resolved repo-relative csproj paths
+    package_references: list[tuple[str, str]] = field(default_factory=list)
+    project_type: str = "classlib"                    # webapi|classlib|console|test|blazor|worker
+    language: str = "csharp"                          # csharp|fsharp|vbnet
+
+
+_TEST_PACKAGES: frozenset[str] = frozenset({
+    "xunit", "nunit", "mstest.testframework", "microsoft.net.test.sdk",
+    "nunit3testadapter", "xunit.runner.visualstudio", "mstest.testadapter",
+    "coverlet.collector", "moq", "nsubstitute", "fluentassertions",
+})
+
+_LAYER_KEYWORDS: tuple[tuple[str, str], ...] = (
+    ("api", "Api"),
+    ("web", "Api"),
+    ("endpoint", "Api"),
+    ("controller", "Api"),
+    ("application", "Application"),
+    ("usecase", "Application"),
+    ("usecases", "Application"),
+    ("domain", "Domain"),
+    ("core", "Domain"),
+    ("infrastructure", "Infrastructure"),
+    ("infra", "Infrastructure"),
+    ("persistence", "Infrastructure"),
+    ("repository", "Infrastructure"),
+    ("shared", "Shared"),
+    ("common", "Shared"),
+    ("contracts", "Shared"),
+    ("abstractions", "Shared"),
+    ("test", "Tests"),
+    ("tests", "Tests"),
+    ("spec", "Tests"),
+    ("specs", "Tests"),
+)
+
+
+def parse_csproj(absolute_path: Path, relative_path: str) -> CsprojProject | None:
+    """Parse a .csproj/.fsproj/.vbproj and return structured project info. Returns None on error."""
+    try:
+        content = absolute_path.read_text(encoding="utf-8", errors="replace")
+        root_elem = ET.fromstring(content)
+    except (OSError, ET.ParseError):
+        return None
+
+    suffix = Path(relative_path).suffix.lower()
+    language = {"fsproj": "fsharp", "vbproj": "vbnet"}.get(suffix.lstrip("."), "csharp")
+
+    project_dir = str(PurePosixPath(relative_path).parent)
+    if project_dir == ".":
+        project_dir = ""
+
+    name = Path(relative_path).stem
+    sdk = root_elem.get("Sdk", "") or ""
+
+    frameworks: list[str] = []
+    output_type = ""
+    package_refs: list[tuple[str, str]] = []
+    project_refs: list[str] = []
+
+    for elem in root_elem.iter():
+        tag = _strip_ns(elem.tag)
+        text = (elem.text or "").strip()
+
+        if tag == "TargetFramework":
+            if not frameworks and text:
+                frameworks = [text]
+        elif tag == "TargetFrameworks":
+            if text:
+                frameworks = [f.strip() for f in text.split(";") if f.strip()]
+        elif tag == "OutputType":
+            if not output_type:
+                output_type = text
+        elif tag == "AssemblyName":
+            if text:
+                name = text
+        elif tag == "PackageReference":
+            pkg = elem.get("Include", "") or ""
+            ver = elem.get("Version", "") or (elem.findtext("Version") or "").strip()
+            if pkg:
+                package_refs.append((pkg, ver))
+        elif tag == "ProjectReference":
+            include = (elem.get("Include", "") or "").replace("\\", "/")
+            if include:
+                project_refs.append(include)
+
+    if not sdk:
+        sdk = _detect_sdk_from_imports(root_elem)
+
+    resolved_refs = [
+        r for r in (_resolve_ref(relative_path, ref) for ref in project_refs) if r
+    ]
+
+    project_type = _classify_project(
+        sdk=sdk,
+        output_type=output_type,
+        name=name,
+        package_refs=[p[0] for p in package_refs],
+    )
+
+    return CsprojProject(
+        name=name,
+        path=relative_path,
+        project_dir=project_dir,
+        target_frameworks=frameworks,
+        output_type=output_type,
+        sdk=sdk,
+        project_references=resolved_refs,
+        package_references=package_refs,
+        project_type=project_type,
+        language=language,
+    )
+
+
+def infer_architecture_pattern(projects: list[CsprojProject]) -> str | None:
+    """Infer Clean Architecture / Onion / Layered from project names."""
+    layers: set[str] = set()
+    for project in projects:
+        name_lower = project.name.lower()
+        for keyword, layer in _LAYER_KEYWORDS:
+            if keyword in name_lower:
+                layers.add(layer)
+                break
+
+    if {"Application", "Domain", "Infrastructure"} <= layers:
+        return "Clean Architecture"
+    if {"Api", "Domain", "Infrastructure"} <= layers:
+        return "Onion Architecture"
+    if {"Api", "Application", "Infrastructure"} <= layers:
+        return "Layered Architecture"
+    if len(layers) >= 3:
+        return "Layered Architecture"
+    return None
+
+
+def _strip_ns(tag: str) -> str:
+    return tag.split("}", 1)[1] if "}" in tag else tag
+
+
+def _resolve_ref(source_csproj: str, ref: str) -> str | None:
+    """Resolve a ProjectReference path (relative to source .csproj) to a repo-relative path."""
+    source_dir = str(PurePosixPath(source_csproj).parent)
+    base = "" if source_dir == "." else source_dir
+    combined = f"{base}/{ref}" if base else ref
+    parts: list[str] = []
+    for part in combined.split("/"):
+        if part == "..":
+            if parts:
+                parts.pop()
+        elif part and part != ".":
+            parts.append(part)
+    return "/".join(parts) if parts else None
+
+
+def _detect_sdk_from_imports(root_elem: ET.Element) -> str:
+    for elem in root_elem.iter():
+        if _strip_ns(elem.tag) == "Import":
+            project = elem.get("Project", "")
+            if "Microsoft.NET" in project:
+                return project
+    return ""
+
+
+def _classify_project(
+    *,
+    sdk: str,
+    output_type: str,
+    name: str,
+    package_refs: list[str],
+) -> str:
+    sdk_l = sdk.lower()
+    name_l = name.lower()
+    pkgs_l = {p.lower() for p in package_refs}
+    out_l = output_type.lower()
+
+    if pkgs_l & _TEST_PACKAGES or any(kw in name_l for kw in ("test", "tests", "spec", "specs")):
+        return "test"
+    if "microsoft.net.sdk.blazor" in sdk_l or any("blazor" in p for p in pkgs_l):
+        return "blazor"
+    if "microsoft.net.sdk.web" in sdk_l or any(
+        p.startswith("microsoft.aspnetcore") for p in pkgs_l
+    ):
+        return "webapi"
+    if "microsoft.net.sdk.worker" in sdk_l or "microsoft.extensions.hosting" in pkgs_l:
+        return "worker"
+    if out_l in ("exe", "winexe"):
+        return "console"
+    return "classlib"

sourcecode-0.24.0/src/sourcecode/detectors/dotnet.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+from collections import Counter
+
+from sourcecode.detectors.base import (
+    AbstractDetector,
+    DetectionContext,
+    EntryPoint,
+    StackDetection,
+)
+from sourcecode.detectors.csproj_parser import (
+    CsprojProject,
+    infer_architecture_pattern,
+    parse_csproj,
+)
+from sourcecode.schema import FrameworkDetection
+from sourcecode.tree_utils import flatten_file_tree, path_exists_in_tree
+
+_PROJECT_EXTENSIONS = (".csproj", ".fsproj", ".vbproj")
+
+_FRAMEWORK_SIGNALS: tuple[tuple[str, str], ...] = (
+    ("microsoft.net.sdk.web", "ASP.NET Core"),
+    ("microsoft.net.sdk.blazor", "Blazor"),
+    ("microsoft.net.sdk.worker", "Worker Service"),
+    ("microsoft.aspnetcore", "ASP.NET Core"),
+)
+
+_ENTRY_CANDIDATES = (
+    "Program.cs",
+    "src/Program.cs",
+    "Program.fs",
+    "src/Program.fs",
+    "Startup.cs",
+    "src/Startup.cs",
+)
+
+
+class DotnetDetector(AbstractDetector):
+    name = "dotnet"
+    priority = 32
+
+    def can_detect(self, context: DetectionContext) -> bool:
+        return any(
+            path.endswith((*_PROJECT_EXTENSIONS, ".sln"))
+            for path in flatten_file_tree(context.file_tree)
+        )
+
+    def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
+        all_paths = flatten_file_tree(context.file_tree)
+        project_paths = [p for p in all_paths if p.endswith(_PROJECT_EXTENSIONS)]
+
+        projects: list[CsprojProject] = []
+        for rel_path in project_paths:
+            project = parse_csproj(context.root / rel_path, rel_path)
+            if project is not None:
+                projects.append(project)
+
+        frameworks = self._collect_frameworks(projects)
+        signals = self._build_signals(projects)
+        entry_points = self._detect_entry_points(context, projects, frameworks)
+
+        manifests = project_paths + [p for p in all_paths if p.endswith(".sln")]
+        stack = StackDetection(
+            stack="dotnet",
+            detection_method="manifest",
+            confidence="high",
+            frameworks=frameworks,
+            package_manager="nuget",
+            manifests=manifests,
+            signals=signals,
+        )
+        return [stack], entry_points
+
+    def _collect_frameworks(self, projects: list[CsprojProject]) -> list[FrameworkDetection]:
+        seen: dict[str, FrameworkDetection] = {}
+        for project in projects:
+            content_lower = project.sdk.lower()
+            for pkg_name, _ in project.package_references:
+                content_lower += " " + pkg_name.lower()
+            for signal, framework_name in _FRAMEWORK_SIGNALS:
+                if signal in content_lower and framework_name not in seen:
+                    seen[framework_name] = FrameworkDetection(name=framework_name, source="manifest")
+        return list(seen.values())
+
+    def _build_signals(self, projects: list[CsprojProject]) -> list[str]:
+        if not projects:
+            return []
+        signals: list[str] = []
+
+        count = len(projects)
+        signals.append(f"{count} project{'s' if count != 1 else ''} detected")
+
+        type_counter: Counter[str] = Counter(p.project_type for p in projects)
+        type_parts = []
+        for ptype, n in type_counter.most_common():
+            type_parts.append(f"{ptype}×{n}" if n > 1 else ptype)
+        signals.append(f"project types: {', '.join(type_parts)}")
+
+        frameworks_seen: set[str] = set()
+        all_frameworks: list[str] = []
+        for project in projects:
+            for fw in project.target_frameworks:
+                if fw and fw not in frameworks_seen:
+                    frameworks_seen.add(fw)
+                    all_frameworks.append(fw)
+        if all_frameworks:
+            signals.append(f"target frameworks: {', '.join(all_frameworks[:4])}")
+
+        pattern = infer_architecture_pattern(projects)
+        if pattern:
+            signals.append(f"architecture: {pattern}")
+
+        return signals
+
+    def _detect_entry_points(
+        self,
+        context: DetectionContext,
+        projects: list[CsprojProject],
+        frameworks: list[FrameworkDetection],
+    ) -> list[EntryPoint]:
+        entry_points: list[EntryPoint] = []
+        framework_names = {f.name for f in frameworks}
+        has_web = bool(framework_names & {"ASP.NET Core", "Blazor"})
+
+        # Entry points from exe/web projects
+        for project in projects:
+            if project.project_type in ("webapi", "console", "worker", "blazor"):
+                kind = _project_type_to_entry_kind(project.project_type, has_web)
+                # Look for Program.cs/Startup.cs relative to the project dir
+                for candidate in _entry_file_candidates(project):
+                    if path_exists_in_tree(context.file_tree, candidate):
+                        entry_points.append(
+                            EntryPoint(
+                                path=candidate,
+                                stack="dotnet",
+                                kind=kind,
+                                source="manifest",
+                                confidence="high",
+                            )
+                        )
+                        break
+
+        # Fallback: known entry file patterns
+        if not entry_points:
+            kind = "api" if has_web else "cli"
+            for candidate in _ENTRY_CANDIDATES:
+                if path_exists_in_tree(context.file_tree, candidate):
+                    entry_points.append(
+                        EntryPoint(
+                            path=candidate,
+                            stack="dotnet",
+                            kind=kind,
+                            source="manifest",
+                            confidence="medium",
+                        )
+                    )
+                    break
+
+        return entry_points
+
+
+def _project_type_to_entry_kind(project_type: str, has_web: bool) -> str:
+    if project_type == "webapi":
+        return "api"
+    if project_type == "blazor":
+        return "web"
+    if project_type == "worker":
+        return "server"
+    return "cli"
+
+
+def _entry_file_candidates(project: CsprojProject) -> list[str]:
+    prefix = f"{project.project_dir}/" if project.project_dir else ""
+    candidates = [
+        f"{prefix}Program.cs",
+        f"{prefix}Program.fs",
+        f"{prefix}Startup.cs",
+    ]
+    # Also check without prefix for root-level projects
+    if prefix:
+        candidates += ["Program.cs", "src/Program.cs"]
+    return candidates

{sourcecode-0.23.0 → sourcecode-0.24.0}/src/sourcecode/graph_analyzer.py

@@ -21,6 +21,7 @@ class GraphAnalyzer:
     _NODE_EXTENSIONS = {".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"}
     _GO_EXTENSIONS = {".go"}
     _JVM_EXTENSIONS = {".java", ".kt", ".scala"}
+    _DOTNET_PROJECT_EXTENSIONS = {".csproj", ".fsproj", ".vbproj"}
     _SUPPORTED_EXTENSIONS = _PYTHON_EXTENSIONS | _NODE_EXTENSIONS | _GO_EXTENSIONS | _JVM_EXTENSIONS
     _DEFAULT_EDGE_KINDS: dict[GraphDetail, tuple[str, ...]] = {
         "high": ("imports",),
@@ -167,6 +168,23 @@ class GraphAnalyzer:
         go_imports = self._build_go_import_map(root, source_files)
         jvm_types = self._build_jvm_type_map(root, source_files)
 
+        # .NET: project-level graph from .csproj/.fsproj/.vbproj manifests
+        all_tree_paths = [p for p in flatten_file_tree(file_tree)]
+        dotnet_project_paths = [
+            p for p in all_tree_paths
+            if Path(p).suffix.lower() in self._DOTNET_PROJECT_EXTENSIONS
+            and (root / p).is_file()
+        ]
+        if dotnet_project_paths:
+            dn_nodes, dn_edges, dn_lims = self._analyze_dotnet_projects(
+                root, dotnet_project_paths, workspace
+            )
+            for node in dn_nodes:
+                self._append_node(nodes, node_ids, node)
+            for edge in dn_edges:
+                self._append_edge(edges, edge_keys, edge)
+            limitations.extend(dn_lims)
+
         for relative_path in source_files:
             absolute_path = root / relative_path
             try:
@@ -1144,6 +1162,62 @@ class GraphAnalyzer:
         edge_keys.add(key)
         edges.append(edge)
 
+    def _analyze_dotnet_projects(
+        self,
+        root: Path,
+        csproj_paths: list[str],
+        workspace: str | None,
+    ) -> tuple[list[GraphNode], list[GraphEdge], list[str]]:
+        from sourcecode.detectors.csproj_parser import parse_csproj
+
+        nodes: list[GraphNode] = []
+        edges: list[GraphEdge] = []
+        limitations: list[str] = []
+
+        projects = []
+        node_id_map: dict[str, str] = {}  # csproj_path → node_id
+
+        for rel_path in csproj_paths:
+            project = parse_csproj(root / rel_path, rel_path)
+            if project is None:
+                limitations.append(f"dotnet_parse_error:{rel_path}")
+                continue
+            projects.append(project)
+            node_path = project.project_dir if project.project_dir else project.name
+            node_id = f"module:{node_path}"
+            node_id_map[project.path] = node_id
+            nodes.append(
+                GraphNode(
+                    id=node_id,
+                    kind="module",
+                    language=project.language,
+                    path=node_path,
+                    display_name=project.name,
+                    workspace=workspace,
+                )
+            )
+
+        for project in projects:
+            source_id = node_id_map.get(project.path)
+            if source_id is None:
+                continue
+            for ref_path in project.project_references:
+                target_id = node_id_map.get(ref_path)
+                if target_id is None:
+                    limitations.append(f"dotnet_unresolved_ref:{project.path}:{ref_path}")
+                    continue
+                edges.append(
+                    GraphEdge(
+                        source=source_id,
+                        target=target_id,
+                        kind="imports",
+                        confidence="high",
+                        method="heuristic",
+                    )
+                )
+
+        return nodes, edges, limitations
+
     def _language_for_suffix(self, suffix: str) -> str:
         if suffix in self._PYTHON_EXTENSIONS:
             return "python"
@@ -1157,6 +1231,12 @@ class GraphAnalyzer:
             return "kotlin"
         if suffix == ".scala":
             return "scala"
+        if suffix == ".cs":
+            return "csharp"
+        if suffix == ".fs":
+            return "fsharp"
+        if suffix == ".vb":
+            return "vbnet"
         return "unknown"
 
     def _node_id(self, kind: str, path: str, symbol: str | None = None) -> str:

{sourcecode-0.23.0 → sourcecode-0.24.0}/src/sourcecode/schema.py

@@ -527,6 +527,6 @@ class SourceMap:
     code_notes: list[CodeNote] = field(default_factory=list)
     code_adrs: list[AdrRecord] = field(default_factory=list)
     code_notes_summary: Optional[CodeNotesSummary] = None
-    # Confidence & Explainability (v0.23.0)
+    # Confidence & Explainability (v0.24.0)
     confidence_summary: Optional[ConfidenceSummary] = None
     analysis_gaps: list[AnalysisGap] = field(default_factory=list)

{sourcecode-0.23.0 → sourcecode-0.24.0}/tests/test_dependency_analyzer_node_python.py

@@ -106,6 +106,6 @@ def test_python_requirements_without_lockfile_keeps_declared_versions(tmp_path:
     assert summary.direct_count == 2
     typer_dep = next(record for record in records if record.name == "typer")
     rich_dep = next(record for record in records if record.name == "rich")
-    assert typer_dep.declared_version == "==0.23.0"
+    assert typer_dep.declared_version == "==0.24.0"
     assert typer_dep.resolved_version is None
     assert rich_dep.declared_version == ">=13.0"