sourcecode 0.22.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.22.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/cli.py

@@ -623,6 +623,12 @@ def main(
     for _finding in validate_cross_analyzer_consistency(sm, strict=False):
         typer.echo(f"[consistency] {_finding}", err=True)
 
+    # Build confidence summary + analysis gaps (always runs, lightweight)
+    from sourcecode.confidence_analyzer import ConfidenceAnalyzer
+    from dataclasses import replace as _replace
+    _conf_summary, _analysis_gaps = ConfidenceAnalyzer().analyze(sm)
+    sm = _replace(sm, confidence_summary=_conf_summary, analysis_gaps=_analysis_gaps)
+
     # 4. Serializar
     if agent:
         data = agent_view(sm)
@@ -666,13 +672,18 @@ def main(
 def prepare_context_cmd(
     task: Optional[str] = typer.Argument(
         None,
-        help="Task: explain | fix-bug | refactor | generate-tests",
+        help="Task: explain | fix-bug | refactor | generate-tests | onboard | review-pr | delta",
     ),
     path: Path = typer.Option(
         Path("."),
         "--path", "-p",
         help="Project directory to analyze (default: current directory)",
     ),
+    since: Optional[str] = typer.Option(
+        None,
+        "--since",
+        help="Git ref for delta task: show files changed since this ref (e.g. HEAD~3, main)",
+    ),
     llm_prompt: bool = typer.Option(
         False,
         "--llm-prompt",
@@ -689,13 +700,24 @@ def prepare_context_cmd(
         help="Show what would be analyzed without running it",
     ),
 ) -> None:
-    """Prepare task-aware context optimized for LLM reasoning.
+    """Compile task-aware context for AI coding agents.
+
+    \b
+    Tasks:
+      explain        Project overview: structure, entry points, dependencies
+      fix-bug        Risk-ranked files, suspected areas, code annotations
+      refactor       Structural issues, improvement opportunities
+      generate-tests Untested source files, test gap analysis
+      onboard        Full project context for a new agent or developer
+      review-pr      PR review context: changed files + architecture
+      delta          Incremental context: git-changed files only
 
     \b
-    Note: PATH must be provided before the subcommand (default: '.'):
+    Examples:
       sourcecode . prepare-context explain
       sourcecode . prepare-context fix-bug --path /my/project
-      sourcecode . prepare-context generate-tests --llm-prompt
+      sourcecode . prepare-context delta --since main
+      sourcecode . prepare-context onboard --llm-prompt
       sourcecode . prepare-context --task-help
     """
     from sourcecode.prepare_context import TASKS, TaskContextBuilder
@@ -734,22 +756,28 @@ def prepare_context_cmd(
         typer.echo(f"path:        {target}")
         typer.echo(f"analyzers:   dependencies={'yes' if spec.enable_dependencies else 'no'}"
                    f", code_notes={'yes' if spec.enable_code_notes else 'no'}")
+        if since:
+            typer.echo(f"since:       {since}")
         typer.echo(f"output:      {spec.output_hint}")
         raise typer.Exit()
 
     from dataclasses import asdict
 
     builder = TaskContextBuilder(target)
-    output = builder.build(task)
+    output = builder.build(task, since=since)
 
     out: dict[str, Any] = {
         "task": output.task,
         "goal": output.goal,
         "project_summary": output.project_summary,
         "architecture_summary": output.architecture_summary,
+        "confidence": output.confidence,
         "relevant_files": [asdict(f) for f in output.relevant_files],
+        "why_these_files": output.why_these_files,
         "key_dependencies": output.key_dependencies,
     }
+    if output.gaps:
+        out["gaps"] = output.gaps
     if output.suspected_areas:
         out["suspected_areas"] = output.suspected_areas
     if output.improvement_opportunities:
@@ -758,6 +786,10 @@ def prepare_context_cmd(
         out["test_gaps"] = output.test_gaps
     if output.code_notes_summary:
         out["code_notes_summary"] = output.code_notes_summary
+    if output.changed_files:
+        out["changed_files"] = output.changed_files
+    if output.affected_entry_points:
+        out["affected_entry_points"] = output.affected_entry_points
     if output.limitations:
         out["limitations"] = output.limitations
     if llm_prompt:

sourcecode/confidence_analyzer.py

@@ -0,0 +1,190 @@
+"""confidence_analyzer.py — Builds ConfidenceSummary and AnalysisGap list from SourceMap.
+
+Analyzes detection quality post-facto:
+  - Classifies signals as hard (manifest/lockfile) vs soft (heuristic/extension)
+  - Identifies auxiliary paths that were found but correctly ignored
+  - Detects anomalies (conflicting signals, low-confidence detections)
+  - Produces structured analysis gaps for agent consumption
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from sourcecode.schema import AnalysisGap, ConfidenceSummary, SourceMap
+
+if TYPE_CHECKING:
+    pass
+
+_AUXILIARY_DIR_PREFIXES = (
+    ".claude/", ".cursor/", ".vscode/", ".github/", ".idea/",
+    ".devcontainer/", ".husky/",
+)
+
+_FIXTURE_DIR_SEGMENTS = {"fixtures", "fixture", "testdata", "test_data", "__fixtures__"}
+_TEST_DIR_SEGMENTS = {"tests", "test", "spec", "specs", "__tests__"}
+_DOC_DIR_SEGMENTS = {"docs", "doc", "documentation", "wiki"}
+_GENERATED_DIR_SEGMENTS = {"dist", "build", "target", "out", "output", ".next", "__pycache__"}
+
+_HARD_SOURCES = {"manifest", "lockfile", "pyproject.toml", "package.json", "go.mod",
+                 "Cargo.toml", "pom.xml", "build.gradle"}
+_SOFT_SOURCES = {"heuristic", "code_signal", "convention"}
+
+
+class ConfidenceAnalyzer:
+    """Analyzes SourceMap quality and produces confidence + gap metadata."""
+
+    def analyze(self, sm: SourceMap) -> tuple[ConfidenceSummary, list[AnalysisGap]]:
+        hard_signals: list[str] = []
+        soft_signals: list[str] = []
+        ignored_signals: list[str] = []
+        anomalies: list[str] = []
+        gaps: list[AnalysisGap] = []
+
+        # ── Stack signals ─────────────────────────────────────────────────────
+        for stack in sm.stacks:
+            if stack.detection_method == "manifest" and stack.confidence in ("high", "medium"):
+                for manifest in stack.manifests:
+                    sig = f"stack:{stack.stack} via {manifest}"
+                    if sig not in hard_signals:
+                        hard_signals.append(sig)
+            elif stack.detection_method == "heuristic":
+                sig = f"stack:{stack.stack} (heuristic, no manifest)"
+                if sig not in soft_signals:
+                    soft_signals.append(sig)
+            elif stack.detection_method == "lockfile":
+                sig = f"stack:{stack.stack} via lockfile"
+                if sig not in hard_signals:
+                    hard_signals.append(sig)
+
+        # ── Entry point signals ───────────────────────────────────────────────
+        for ep in sm.entry_points:
+            if ep.source in _HARD_SOURCES or ep.reason == "console_script":
+                sig = f"entry:{ep.path} ({ep.reason or ep.source})"
+                if sig not in hard_signals:
+                    hard_signals.append(sig)
+            else:
+                sig = f"entry:{ep.path} ({ep.reason or ep.source})"
+                if sig not in soft_signals:
+                    soft_signals.append(sig)
+
+        # ── Ignored auxiliary paths ───────────────────────────────────────────
+        aux_dirs_found: set[str] = set()
+        for path in sm.file_paths:
+            norm = path.replace("\\", "/")
+            for prefix in _AUXILIARY_DIR_PREFIXES:
+                if norm.startswith(prefix):
+                    top = prefix.rstrip("/")
+                    aux_dirs_found.add(top)
+                    break
+
+        for aux in sorted(aux_dirs_found):
+            ignored_signals.append(f"aux_dir:{aux} (tooling, not analyzed as project source)")
+
+        # ── Anomaly: multiple stacks, ambiguous primary ───────────────────────
+        primary_stacks = [s for s in sm.stacks if s.primary]
+        heuristic_only = [s for s in sm.stacks if s.detection_method == "heuristic"]
+
+        if len(primary_stacks) == 0 and sm.stacks:
+            anomalies.append("No primary stack marked — multiple stacks detected with equal weight")
+        if len(primary_stacks) > 1:
+            names = ", ".join(s.stack for s in primary_stacks)
+            anomalies.append(f"Multiple stacks marked as primary: {names}")
+        if heuristic_only and not any(s.detection_method != "heuristic" for s in sm.stacks):
+            anomalies.append("All stacks detected via heuristic only — no manifest found")
+
+        # ── Anomaly: entry points all low-confidence ──────────────────────────
+        if sm.entry_points and all(ep.confidence == "low" for ep in sm.entry_points):
+            anomalies.append("All entry points are low-confidence (heuristic/code_signal only)")
+
+        # ── Gaps ──────────────────────────────────────────────────────────────
+        if not sm.entry_points:
+            gaps.append(AnalysisGap(
+                area="entry_points",
+                reason="No entry point detected — project may use non-standard structure or be a library",
+                impact="high",
+            ))
+        elif all(ep.confidence == "low" for ep in sm.entry_points):
+            gaps.append(AnalysisGap(
+                area="entry_points",
+                reason="Entry points inferred from code patterns only, no manifest declaration found",
+                impact="medium",
+            ))
+
+        if not sm.stacks:
+            gaps.append(AnalysisGap(
+                area="stack",
+                reason="No stack detected — project may be infrastructure-only or use an unsupported language",
+                impact="high",
+            ))
+        elif all(s.detection_method == "heuristic" for s in sm.stacks):
+            gaps.append(AnalysisGap(
+                area="stack",
+                reason="Stack inferred from file extensions only — no manifest or lockfile found",
+                impact="medium",
+            ))
+
+        dep_summary = sm.dependency_summary
+        if dep_summary is None or not dep_summary.requested:
+            gaps.append(AnalysisGap(
+                area="dependencies",
+                reason="Dependencies not analyzed — run with --dependencies for full context",
+                impact="medium",
+            ))
+        elif dep_summary.requested and dep_summary.total_count == 0:
+            gaps.append(AnalysisGap(
+                area="dependencies",
+                reason="No dependencies found — project may have no external dependencies or manifest is non-standard",
+                impact="low",
+            ))
+
+        env_summary = sm.env_summary
+        if env_summary is None or not env_summary.requested:
+            gaps.append(AnalysisGap(
+                area="env",
+                reason="Environment variables not analyzed — run with --env-map for operational context",
+                impact="low",
+            ))
+
+        # ── Compute overall confidence ─────────────────────────────────────────
+        # Stack: use best manifest-detected stack, fall back to min
+        manifest_stacks = [s for s in sm.stacks if s.detection_method != "heuristic"]
+        stack_conf = (
+            _max_confidence([s.confidence for s in manifest_stacks])
+            if manifest_stacks
+            else _min_confidence([s.confidence for s in sm.stacks] or ["low"])
+        )
+        # Entry points: use best available (highest-confidence EP wins)
+        ep_conf = _max_confidence([ep.confidence for ep in sm.entry_points] or ["low"])
+        overall = _min_confidence([stack_conf, ep_conf])
+
+        # Downgrade if gaps are severe
+        high_impact_gaps = [g for g in gaps if g.impact == "high"]
+        if high_impact_gaps:
+            overall = "low" if overall != "high" else "medium"
+
+        summary = ConfidenceSummary(
+            overall=overall,  # type: ignore[arg-type]
+            stack_confidence=stack_conf,  # type: ignore[arg-type]
+            entry_point_confidence=ep_conf,  # type: ignore[arg-type]
+            hard_signals=hard_signals,
+            soft_signals=soft_signals,
+            ignored_signals=ignored_signals,
+            anomalies=anomalies,
+        )
+        return summary, gaps
+
+
+def _min_confidence(values: list[str]) -> str:
+    rank = {"high": 2, "medium": 1, "low": 0}
+    if not values:
+        return "low"
+    return min(values, key=lambda v: rank.get(v, 0))
+
+
+def _max_confidence(values: list[str]) -> str:
+    rank = {"high": 2, "medium": 1, "low": 0}
+    if not values:
+        return "low"
+    return max(values, key=lambda v: rank.get(v, 0))

sourcecode/dependency_analyzer.py

@@ -32,6 +32,22 @@ _PY_PARSING: frozenset[str] = frozenset({
     "pathspec", "gitpython", "lxml", "beautifulsoup4", "html5lib",
     "regex", "pyparsing",
 })
+_PY_BUILDTOOLS: frozenset[str] = frozenset({
+    "setuptools", "hatchling", "flit-core", "flit", "wheel", "build", "twine",
+    "hatch", "poetry-core", "maturin", "cython",
+})
+_PY_OBSERVABILITY: frozenset[str] = frozenset({
+    "sentry-sdk", "datadog", "prometheus-client", "opentelemetry-api",
+    "opentelemetry-sdk", "structlog", "loguru", "elastic-apm", "ddtrace",
+    "opentelemetry-instrumentation",
+})
+_PY_INFRA: frozenset[str] = frozenset({
+    "boto3", "botocore", "azure-storage-blob", "azure-identity",
+    "google-cloud-storage", "google-cloud-bigquery", "kubernetes",
+    "paramiko", "fabric", "celery", "dramatiq", "redis", "aioredis",
+    "psycopg2", "psycopg2-binary", "asyncpg", "sqlalchemy", "motor",
+    "pymongo", "aiomysql", "mysql-connector-python",
+})
 
 _NODE_TESTTOOLS: frozenset[str] = frozenset({
     "jest", "@jest/globals", "mocha", "jasmine", "chai", "karma",
@@ -39,8 +55,22 @@ _NODE_TESTTOOLS: frozenset[str] = frozenset({
     "sinon", "nock", "supertest",
 })
 _NODE_DEVTOOLS: frozenset[str] = frozenset({
-    "eslint", "prettier", "typescript", "@types/node", "webpack", "rollup",
-    "parcel", "@babel/core", "husky", "lint-staged", "nodemon", "ts-node", "tsx",
+    "eslint", "prettier", "typescript", "@types/node", "husky",
+    "lint-staged", "nodemon", "ts-node", "tsx",
+})
+_NODE_BUILDTOOLS: frozenset[str] = frozenset({
+    "webpack", "webpack-cli", "rollup", "parcel", "@babel/core", "@babel/preset-env",
+    "esbuild", "@swc/core", "vite", "turbopack", "postcss", "autoprefixer",
+    "tailwindcss", "sass", "less",
+})
+_NODE_OBSERVABILITY: frozenset[str] = frozenset({
+    "@sentry/node", "dd-trace", "pino", "winston", "morgan",
+    "@opentelemetry/sdk-node", "pino-http",
+})
+_NODE_INFRA: frozenset[str] = frozenset({
+    "aws-sdk", "@aws-sdk/client-s3", "azure-storage", "firebase-admin",
+    "bull", "bullmq", "amqplib", "kafkajs", "ioredis", "pg", "mysql2",
+    "mongoose", "prisma", "@prisma/client", "typeorm", "sequelize",
 })
 
 _DEV_SCOPES: frozenset[str] = frozenset({"dev", "optional"})
@@ -49,13 +79,17 @@ _ROLE_PRIORITY: dict[str, int] = {
     "runtime": 0,
     "parsing": 1,
     "serialization": 2,
-    "testtool": 3,
-    "devtool": 4,
+    "observability": 3,
+    "infra": 4,
+    "buildtool": 5,
+    "testtool": 6,
+    "devtool": 7,
+    "unknown": 8,
 }
 
 
 def _infer_role(name: str, ecosystem: str, scope: str) -> str:
-    """Infer dependency role: runtime | parsing | serialization | devtool | testtool."""
+    """Infer dependency role: runtime | parsing | serialization | buildtool | observability | infra | devtool | testtool | unknown."""
     n = name.lower()
     is_dev = scope in _DEV_SCOPES or scope.startswith(("optional:", "group:"))
 
@@ -64,8 +98,14 @@ def _infer_role(name: str, ecosystem: str, scope: str) -> str:
             return "testtool"
         if n in _PY_DEVTOOLS:
             return "devtool"
+        if n in _PY_BUILDTOOLS:
+            return "buildtool"
         if is_dev:
             return "devtool"
+        if n in _PY_OBSERVABILITY:
+            return "observability"
+        if n in _PY_INFRA:
+            return "infra"
         if n in _PY_SERIALIZATION:
             return "serialization"
         if n in _PY_PARSING:
@@ -77,8 +117,14 @@ def _infer_role(name: str, ecosystem: str, scope: str) -> str:
             return "testtool"
         if n in _NODE_DEVTOOLS:
             return "devtool"
+        if n in _NODE_BUILDTOOLS:
+            return "buildtool"
         if is_dev:
             return "devtool"
+        if n in _NODE_OBSERVABILITY:
+            return "observability"
+        if n in _NODE_INFRA:
+            return "infra"
         return "runtime"
 
     return "devtool" if is_dev else "runtime"

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"