sourcecode 0.22.0__tar.gz → 0.24.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 0.22.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.22.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.22.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.22.0",
+    "sourcecode_version": "0.24.0",
     "analyzed_path": "/abs/path/to/project"
   },
   "file_tree": {

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "sourcecode"
-version = "0.22.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.22.0 → sourcecode-0.24.0}/src/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-0.22.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.22.0 → sourcecode-0.24.0}/src/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-0.24.0/src/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-0.22.0 → sourcecode-0.24.0}/src/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"