sourcecode 0.23.0__py3-none-any.whl → 0.24.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.24.0"

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/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/detectors/dotnet.py

@@ -1,15 +1,39 @@
 from __future__ import annotations
 
+from collections import Counter
+
 from sourcecode.detectors.base import (
     AbstractDetector,
     DetectionContext,
     EntryPoint,
     StackDetection,
 )
-from sourcecode.detectors.parsers import read_text_lines, unique_strings
+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"
@@ -17,35 +41,25 @@ class DotnetDetector(AbstractDetector):
 
     def can_detect(self, context: DetectionContext) -> bool:
         return any(
-            path.endswith((".csproj", ".sln"))
+            path.endswith((*_PROJECT_EXTENSIONS, ".sln"))
             for path in flatten_file_tree(context.file_tree)
         )
 
     def detect(self, context: DetectionContext) -> tuple[list[StackDetection], list[EntryPoint]]:
-        manifests = [
-            path
-            for path in flatten_file_tree(context.file_tree)
-            if path.endswith((".csproj", ".sln"))
-        ]
-        content = "\n".join(
-            "\n".join(read_text_lines(context.root / manifest))
-            for manifest in manifests
-        ).lower()
+        all_paths = flatten_file_tree(context.file_tree)
+        project_paths = [p for p in all_paths if p.endswith(_PROJECT_EXTENSIONS)]
 
-        frameworks: list[FrameworkDetection] = []
-        if "microsoft.net.sdk.web" in content or "microsoft.aspnetcore" in content:
-            frameworks.append(FrameworkDetection(name="ASP.NET Core", source="manifest"))
+        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)
 
-        entry_points: list[EntryPoint] = []
-        for path in unique_strings(
-            ["Program.cs", "src/Program.cs", "Program.fs", "src/Program.fs"]
-        ):
-            if path_exists_in_tree(context.file_tree, path):
-                kind = "api" if frameworks else "cli"
-                entry_points.append(
-                    EntryPoint(path=path, stack="dotnet", kind=kind, source="manifest")
-                )
+        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",
@@ -53,5 +67,116 @@ class DotnetDetector(AbstractDetector):
             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/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/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.dist-info → sourcecode-0.24.0.dist-info}/METADATA

@@ -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.dist-info → sourcecode-0.24.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-sourcecode/__init__.py,sha256=Dh82QypoDBYj3Gur3QVPfjnJcgmk8S2TvsTDOr0Z0Mc,100
+sourcecode/__init__.py,sha256=7ljM1Wbn_nskADHVqGmTI-Vmy84xpdNbAYtpFWq826E,100
 sourcecode/architecture_analyzer.py,sha256=zxgqeqn2FhIUDn06X-whjGKiXbrHFkRlzZcr2zKd0Gw,16874
-sourcecode/architecture_summary.py,sha256=rr-Q2LLe6bXZ27NuV2pYb0_LZyEFn3sngKMdXCZSGbE,13263
+sourcecode/architecture_summary.py,sha256=EyCKVK_q0EZd1xtBODWEOLKKgMfvRw-UVEuo1Z4BRNI,15171
 sourcecode/classifier.py,sha256=Ft_RfYS-KOe0t7vjgUx04OoCJd1-DXK7k9-I0CFDSnU,6934
 sourcecode/cli.py,sha256=SyO5JHR0cKMoMEas-of1pnWneZMjr7JhTxURR7-Kv5w,30925
 sourcecode/code_notes_analyzer.py,sha256=rRd8bFYV0krjlxxQV0wenwE9K7pVpUQSR7KvSvUQKw4,9226
@@ -10,12 +10,12 @@ sourcecode/dependency_analyzer.py,sha256=Exq0BfInvfS5iAg9xAr6WI2uPNuotkIudTKcYJc
 sourcecode/doc_analyzer.py,sha256=Ec3orx6vBKsh5cNM3-F4y2Got2KuKx8w3dErwtdtM-A,19891
 sourcecode/env_analyzer.py,sha256=JZxBOuIxnM0xw0IaJFL6LiPJBErL848L3XoTOHGBqZI,13554
 sourcecode/git_analyzer.py,sha256=S9PGt8RDasBQYQUsZh9-H_KWVlPvzwR4jgM7TKN9ZCk,7643
-sourcecode/graph_analyzer.py,sha256=cxl7Xb88aGxIVOCsatZJAE1CtgXGzIbJfqytV-9kkFs,45172
+sourcecode/graph_analyzer.py,sha256=t5D1MpoGeyINol9UK3cQyn0e79q7cvC5MLc2p4JWXhI,48132
 sourcecode/metrics_analyzer.py,sha256=4uh11v-Q0gdrN87BOxuFWUym3N3AOkOuy21K5N8peB8,20126
 sourcecode/prepare_context.py,sha256=1Z8UcefgIWu1J_tYXVIu2qNbTt08S72gW7QUe9c7u0s,27561
 sourcecode/redactor.py,sha256=xuGcadGEHaPw4qZXlMDvzMCsr4VOkdp3oBQptHyJk8c,2884
 sourcecode/scanner.py,sha256=aM3h9-DCQ3xKpeHpHYdo2vX6T5P95HA_YwZbkAVNwmo,8288
-sourcecode/schema.py,sha256=u8WorLBlbcG-I5oaB0ShTGHDoNaLcl4vyADNV6P2O9g,17159
+sourcecode/schema.py,sha256=FaXyEKYoYEE8YCpay8u2k5CfW0-79PV0HNwpvSRq-Pc,17159
 sourcecode/semantic_analyzer.py,sha256=asQfJf-EhzYaOTA-iMuZsrVXtbW7SV2WEKCxgsxa88Y,79413
 sourcecode/serializer.py,sha256=-dNeUFingePa3WcCTjLe0o6jSdLu4PfL9rPlD8uuky4,25163
 sourcecode/summarizer.py,sha256=YdIA5gGEc0XSctPgmTnFnuZI72bprrOYhkJNoDmvHwM,12114
@@ -23,8 +23,9 @@ sourcecode/tree_utils.py,sha256=Fj9OIuUksBvgibNd3feog0sMDjVypJzPexp5lvMoYWI,1424
 sourcecode/workspace.py,sha256=fQlVoNx8S-fSHpKoJ0JBvEHCFkxszH0KZVJed1i3TRk,6845
 sourcecode/detectors/__init__.py,sha256=A0AACJFF6HWf_RgatNtWu3PUzstcKtIGM9f1PoFcJug,1987
 sourcecode/detectors/base.py,sha256=C2EqfZudQ1ITK4DID4M70nPxqoh9bl1zn_ta6XRaGWs,1168
+sourcecode/detectors/csproj_parser.py,sha256=2Vxfo6h_ucF1KPTTOYLzNnCGRfHWIATVMeaHY45PbQY,6756
 sourcecode/detectors/dart.py,sha256=QbqaL5v18-_ort75HihVBt8MsKUfOcFDF8IpWFLiXpI,1432
-sourcecode/detectors/dotnet.py,sha256=UC-74VW850r3admcl36R-rl3M0-nBFXw8ph5e9RSas8,1978
+sourcecode/detectors/dotnet.py,sha256=p44WohTC8a6Xwxa5mUK0FRM3aT8tOotckmDnYgAqbZ8,6493
 sourcecode/detectors/elixir.py,sha256=jCpvt5Yi6jvplc80ovRtWh17q-11ZGo9qX7o8b57TJE,1713
 sourcecode/detectors/go.py,sha256=KehAyvC3H_s8zwwqFM0bAbztQbbUBDjpNbGvM2kQlk8,1836
 sourcecode/detectors/heuristic.py,sha256=JWb_dXNI1YDxk9a3DFeXTbKYfAGOFqV6jVxxqouWSiA,2238
@@ -40,7 +41,7 @@ sourcecode/detectors/rust.py,sha256=V23NO6Y8NsrhrUlGC2feUEcNK63hf3gc1y3jI4tes1Q,
 sourcecode/detectors/systems.py,sha256=nYaKbGDFu0EOXFcd_1doWFT3tTUdkbxc2DjHUF5TcqQ,1627
 sourcecode/detectors/terraform.py,sha256=cxORPR_zVLOJpHlh4e9JnFpkQsn_UnqMMom5yG65hZ4,1693
 sourcecode/detectors/tooling.py,sha256=hIvop80No22pqyGVJ32NKliSdjkHRePQkIRroqG01bY,1875
-sourcecode-0.23.0.dist-info/METADATA,sha256=EwoOCYdt8LinpV5ymkOsnd3A01aEcFxbeidutgfwPsw,30326
-sourcecode-0.23.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-0.23.0.dist-info/entry_points.txt,sha256=voDtdlGU2-jR3wCZpQoOls_0eUKaDVCKIfajGHFDATs,50
-sourcecode-0.23.0.dist-info/RECORD,,
+sourcecode-0.24.0.dist-info/METADATA,sha256=6zBHS6C-B7sxfs54ThpVQBcEMnGvohExI-hy69n2dRQ,30326
+sourcecode-0.24.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-0.24.0.dist-info/entry_points.txt,sha256=voDtdlGU2-jR3wCZpQoOls_0eUKaDVCKIfajGHFDATs,50
+sourcecode-0.24.0.dist-info/RECORD,,