sourcecode 0.22.0__py3-none-any.whl → 0.23.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.23.0"

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

@@ -66,6 +66,14 @@ class HeuristicDetector(AbstractDetector):
             if filename in _ENTRYPOINT_NAMES:
                 stack, kind = _ENTRYPOINT_NAMES[filename]
                 entry_points.append(
-                    EntryPoint(path=path, stack=stack, kind=kind, source="heuristic")
+                    EntryPoint(
+                        path=path,
+                        stack=stack,
+                        kind=kind,
+                        source="heuristic",
+                        confidence="low",
+                        reason="entry_file_pattern",
+                        evidence=f"conventional filename: {filename}",
+                    )
                 )
         return stacks, entry_points

sourcecode/detectors/python.py

@@ -162,6 +162,8 @@ class PythonDetector(AbstractDetector):
                     kind=kind,
                     source="pyproject.toml",
                     confidence="high",
+                    reason="console_script",
+                    evidence="declared in [project.scripts]",
                 )
             )
 
@@ -180,6 +182,8 @@ class PythonDetector(AbstractDetector):
                         kind=kind,
                         source="convention",
                         confidence="medium",
+                        reason="entry_file_pattern",
+                        evidence=f"conventional filename: {fname}",
                     )
                 )
 
@@ -195,6 +199,8 @@ class PythonDetector(AbstractDetector):
                     kind="script",
                     source="code_signal",
                     confidence="low",
+                    reason="main_guard",
+                    evidence="if __name__ == '__main__' guard detected",
                 )
             )
 

sourcecode/prepare_context.py

@@ -1,8 +1,19 @@
-"""prepare_context.py — Task-aware context optimizer for LLM reasoning."""
+"""prepare_context.py — Task-aware context compiler for AI coding agents.
+
+Each task produces a focused context bundle:
+  - goal: what the agent should accomplish
+  - project_summary: value-oriented product description
+  - architecture_summary: flow description (entry → processing → output)
+  - relevant_files: ranked by relevance with why_these_files rationale
+  - key_dependencies: runtime-first, role-tagged
+  - confidence: detection quality indicator
+  - gaps: what's uncertain or not analyzed
+  - llm_prompt: ready-to-use prompt (optional, --llm-prompt)
+"""
 
 from __future__ import annotations
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Optional
 
@@ -105,6 +116,77 @@ untested or undertested areas of this codebase.
 4. Each test must have a clear name that describes exactly what it verifies.
 """
 
+_ONBOARD_PROMPT = """\
+You are an expert software engineer onboarding to a new codebase. \
+Your task is to understand and explain this project thoroughly.
+
+## Project
+
+{project_summary}
+
+{architecture_section}
+
+## Entry Points
+
+{relevant_files_section}
+
+{dependencies_section}
+
+## Instructions
+
+1. Describe what this project does and the problem it solves.
+2. Walk through the main execution flow from entry point to output.
+3. Identify the 3-5 most important files to understand first.
+4. Note any non-obvious conventions, constraints, or design decisions.
+5. List what you would need to know to safely modify this codebase.
+"""
+
+_REVIEW_PR_PROMPT = """\
+You are an expert code reviewer. Your task is to review the changes \
+in this pull request within the context of the full project.
+
+## Project Context
+
+{project_summary}
+
+{architecture_section}
+
+## Changed Files
+
+{relevant_files_section}
+
+{suspected_areas_section}
+
+## Instructions
+
+1. Review the changed files for correctness, security, and maintainability.
+2. Check that changes are consistent with the project's architecture.
+3. Identify any missing tests, edge cases, or error handling.
+4. Flag any breaking changes to public APIs or contracts.
+5. Suggest concrete improvements with specific file and line references.
+"""
+
+_DELTA_PROMPT = """\
+You are an expert software engineer reviewing incremental changes to a codebase.
+
+## Project Context
+
+{project_summary}
+
+## Changed Files
+
+{relevant_files_section}
+
+{suspected_areas_section}
+
+## Instructions
+
+1. Analyze the changed files and their relationship to the project architecture.
+2. Identify which entry points and components are affected.
+3. Assess the risk and impact of these changes.
+4. Flag any consistency issues with the rest of the codebase.
+"""
+
 
 # ─────────────────────────────────────────────────────────────────────────────
 # Task registry
@@ -170,6 +252,41 @@ TASKS: dict[str, TaskSpec] = {
         prompt_template=_GENERATE_TESTS_PROMPT,
         output_hint="test_gaps, relevant_files (source without tests), key_dependencies",
     ),
+    "onboard": TaskSpec(
+        name="onboard",
+        goal="Build complete project understanding for a new agent or developer joining the codebase.",
+        description="Full structural context: entry points, architecture, key files, dependencies.",
+        ranking_boosts=["main", "cli", "app", "core", "index", "schema", "config", "readme"],
+        ranking_penalties=[".min.", "__pycache__"],
+        enable_code_notes=False,
+        enable_dependencies=True,
+        prompt_template=_ONBOARD_PROMPT,
+        output_hint="project_summary, architecture_summary, relevant_files, key_dependencies, confidence, gaps",
+    ),
+    "review-pr": TaskSpec(
+        name="review-pr",
+        goal="Review pull request changes in the context of the full project architecture.",
+        description="Surface changed files, potential regressions, and architectural consistency.",
+        ranking_boosts=["handler", "service", "middleware", "router", "controller",
+                        "api", "schema", "model", "validator"],
+        ranking_penalties=[".min.", "__pycache__"],
+        enable_code_notes=True,
+        enable_dependencies=False,
+        prompt_template=_REVIEW_PR_PROMPT,
+        output_hint="relevant_files, suspected_areas, architecture_summary, code_notes_summary",
+    ),
+    "delta": TaskSpec(
+        name="delta",
+        goal="Produce incremental context for changed files — avoids re-reading the full repo.",
+        description="Git-aware context: changed files, affected entry points, dependency impact.",
+        ranking_boosts=["handler", "service", "middleware", "router", "controller",
+                        "api", "schema", "model"],
+        ranking_penalties=[".min.", "__pycache__"],
+        enable_code_notes=True,
+        enable_dependencies=False,
+        prompt_template=_DELTA_PROMPT,
+        output_hint="changed_files, affected_entry_points, dependency_impact, architecture_summary",
+    ),
 }
 
 
@@ -183,6 +300,7 @@ class RelevantFile:
     role: str    # entrypoint | source | test
     score: float
     reason: str
+    why: str = ""  # why this file matters for the specific task
 
 
 @dataclass
@@ -198,6 +316,11 @@ class TaskOutput:
     key_dependencies: list[dict[str, Any]]
     code_notes_summary: Optional[dict[str, Any]]
     limitations: list[str]
+    confidence: str = "medium"       # overall detection confidence
+    gaps: list[str] = field(default_factory=list)  # analysis gaps
+    why_these_files: dict[str, str] = field(default_factory=dict)  # path → why relevant
+    changed_files: list[str] = field(default_factory=list)         # delta task only
+    affected_entry_points: list[str] = field(default_factory=list) # delta task only
 
 
 # ─────────────────────────────────────────────────────────────────────────────
@@ -218,7 +341,7 @@ class TaskContextBuilder:
     def __init__(self, root: Path) -> None:
         self.root = root
 
-    def build(self, task_name: str) -> TaskOutput:
+    def build(self, task_name: str, *, since: Optional[str] = None) -> TaskOutput:
         if task_name not in TASKS:
             raise ValueError(
                 f"Unknown task '{task_name}'. Available: {', '.join(TASKS)}"
@@ -334,6 +457,42 @@ class TaskContextBuilder:
             untested.sort(key=lambda p: (len(p.split("/")), p))
             test_gaps = untested[:15]
 
+        # ── 8. Confidence + gaps ──────────────────────────────────────────────
+        from sourcecode.confidence_analyzer import ConfidenceAnalyzer
+        from dataclasses import asdict as _asdict
+
+        sm_for_conf = SourceMap(
+            metadata=AnalysisMetadata(analyzed_path=str(self.root)),
+            file_tree=file_tree,
+            stacks=stacks,
+            project_type=project_type,
+            entry_points=entry_points,
+        )
+        sm_for_conf.file_paths = all_paths
+        if spec.enable_dependencies and key_dependencies:
+            from sourcecode.schema import DependencySummary
+            sm_for_conf.dependency_summary = DependencySummary(
+                requested=True,
+                total_count=len(key_dependencies),
+            )
+
+        conf_summary, analysis_gaps = ConfidenceAnalyzer().analyze(sm_for_conf)
+        confidence = conf_summary.overall
+        gaps = [g.reason for g in analysis_gaps]
+
+        # ── 9. why_these_files ────────────────────────────────────────────────
+        why_these_files: dict[str, str] = {
+            rf.path: rf.reason for rf in relevant_files
+        }
+
+        # ── 10. Delta: git changed files ──────────────────────────────────────
+        changed_files: list[str] = []
+        affected_entry_points: list[str] = []
+        if task_name == "delta":
+            changed_files = self._get_git_changed_files(since=since)
+            ep_set = {ep.path for ep in entry_points}
+            affected_entry_points = [f for f in changed_files if f in ep_set]
+
         return TaskOutput(
             task=task_name,
             goal=spec.goal,
@@ -346,6 +505,11 @@ class TaskContextBuilder:
             key_dependencies=key_dependencies,
             code_notes_summary=code_notes_summary,
             limitations=limitations,
+            confidence=confidence,
+            gaps=gaps,
+            why_these_files=why_these_files,
+            changed_files=changed_files,
+            affected_entry_points=affected_entry_points,
         )
 
     def render_prompt(self, output: TaskOutput) -> str:
@@ -398,16 +562,21 @@ class TaskContextBuilder:
             "\n".join(f"- `{p}`" for p in output.test_gaps),
         )
 
-        return spec.prompt_template.format(
-            project_summary=project_summary,
-            architecture_section=architecture_section,
-            relevant_files_section=relevant_files_section,
-            dependencies_section=dependencies_section,
-            suspected_areas_section=suspected_areas_section,
-            code_notes_section=code_notes_section,
-            improvement_opportunities_section=improvement_opportunities_section,
-            test_gaps_section=test_gaps_section,
-        ).strip()
+        format_kwargs: dict[str, str] = {
+            "project_summary": project_summary,
+            "architecture_section": architecture_section,
+            "relevant_files_section": relevant_files_section,
+            "dependencies_section": dependencies_section,
+            "suspected_areas_section": suspected_areas_section,
+            "code_notes_section": code_notes_section,
+            "improvement_opportunities_section": improvement_opportunities_section,
+            "test_gaps_section": test_gaps_section,
+        }
+        # Only pass keys that the template actually uses
+        import re as _re
+        used_keys = set(_re.findall(r"\{(\w+)\}", spec.prompt_template))
+        filtered_kwargs = {k: v for k, v in format_kwargs.items() if k in used_keys}
+        return spec.prompt_template.format(**filtered_kwargs).strip()
 
     # ── Helpers ───────────────────────────────────────────────────────────────
 
@@ -484,3 +653,37 @@ class TaskContextBuilder:
 
     def _is_source(self, path: str) -> bool:
         return Path(path).suffix.lower() in _SOURCE_EXTENSIONS
+
+    def _get_git_changed_files(self, since: Optional[str] = None) -> list[str]:
+        """Get files changed since a git ref (default: HEAD~1) relative to root."""
+        import subprocess
+        ref = since or "HEAD~1"
+        try:
+            result = subprocess.run(
+                ["git", "diff", "--name-only", ref, "HEAD"],
+                cwd=str(self.root),
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode == 0:
+                return [
+                    line.strip() for line in result.stdout.splitlines()
+                    if line.strip()
+                ]
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+        # Fallback: uncommitted changes
+        try:
+            result = subprocess.run(
+                ["git", "diff", "--name-only"],
+                cwd=str(self.root),
+                capture_output=True,
+                text=True,
+                timeout=10,
+            )
+            if result.returncode == 0:
+                return [line.strip() for line in result.stdout.splitlines() if line.strip()]
+        except (subprocess.TimeoutExpired, FileNotFoundError):
+            pass
+        return []

sourcecode/schema.py

@@ -68,6 +68,8 @@ class EntryPoint:
     kind: str = "entry"
     source: str = "manifest"
     confidence: Literal["high", "medium", "low"] = "high"
+    reason: Optional[str] = None   # console_script | entry_file_pattern | main_guard | typer_app | heuristic | convention
+    evidence: Optional[str] = None  # brief evidence string
 
 
 @dataclass
@@ -83,7 +85,7 @@ class DependencyRecord:
     parent: Optional[str] = None
     manifest_path: Optional[str] = None
     workspace: Optional[str] = None
-    role: Optional[str] = None  # runtime | parsing | serialization | devtool | testtool
+    role: Optional[str] = None  # runtime | parsing | serialization | buildtool | observability | infra | devtool | testtool | unknown
 
 
 @dataclass
@@ -409,6 +411,30 @@ class CodeNotesSummary:
     limitations: list[str] = field(default_factory=list)
 
 
+# --- Confidence & Explainability ---
+
+@dataclass
+class ConfidenceSummary:
+    """Resumen de confianza y calidad del analisis."""
+
+    overall: Literal["high", "medium", "low"] = "medium"
+    stack_confidence: Literal["high", "medium", "low"] = "medium"
+    entry_point_confidence: Literal["high", "medium", "low"] = "medium"
+    hard_signals: list[str] = field(default_factory=list)   # manifest, lockfile, real entrypoint
+    soft_signals: list[str] = field(default_factory=list)   # heuristic, extension-based
+    ignored_signals: list[str] = field(default_factory=list)  # tooling dirs, aux manifests
+    anomalies: list[str] = field(default_factory=list)
+
+
+@dataclass
+class AnalysisGap:
+    """Gap o incertidumbre detectada en el analisis."""
+
+    area: str   # entry_points | dependencies | stack | architecture | env
+    reason: str
+    impact: Literal["high", "medium", "low"] = "medium"
+
+
 # --- Git Context ---
 
 @dataclass
@@ -501,3 +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_summary: Optional[ConfidenceSummary] = None
+    analysis_gaps: list[AnalysisGap] = field(default_factory=list)

sourcecode/serializer.py

@@ -55,30 +55,27 @@ def to_yaml(sm: SourceMap) -> str:
 
 
 def compact_view(sm: SourceMap, *, no_tree: bool = False) -> dict[str, Any]:
-    """Proyeccion compacta del SourceMap (~500-700 tokens).
+    """Context package ready for prompt or handoff (~600-800 tokens).
 
-    Incluye: schema_version, project_type, stacks, entry_points,
-    project_summary (siempre), architecture_summary (siempre),
-    dependency_summary + key_dependencies (cuando requested=True),
-    file_tree_depth1 (omitido si no_tree=True).
+    Answers: what it is, where it enters, what depends on what,
+    what signals matter, and what uncertainty exists.
 
-    Excluye: dependencies (lista larga), docs, module_graph.
-    """
-    depth1: dict[str, Any] | None = None
-    if not no_tree:
-        depth1 = {}
-        for name, value in sm.file_tree.items():
-            if isinstance(value, dict):
-                depth1[name] = {}
-            else:
-                depth1[name] = None
+    Includes: project_type, project_summary, architecture_summary,
+    stacks, entry_points, dependency_summary + key_dependencies (when analyzed),
+    env_summary (when analyzed), code_notes_summary (when analyzed),
+    confidence_summary, anomalies, analysis_gaps.
 
+    Excludes: file_tree, raw dependency lists, docs, module_graph.
+    Empty sections are explained when relevant.
+    """
     dep_summary_dict: Any = None
     key_deps: Any = None
     if sm.dependency_summary is not None and sm.dependency_summary.requested:
         dep_summary_dict = asdict(sm.dependency_summary)
         dep_summary_dict.pop("dependencies", None)
         key_deps = [asdict(d) for d in sm.key_dependencies]
+    elif sm.dependency_summary is None or not sm.dependency_summary.requested:
+        dep_summary_dict = None  # "not analyzed" — agent should add --dependencies
 
     env_summary_dict: Any = None
     if sm.env_summary is not None and sm.env_summary.requested:
@@ -88,21 +85,47 @@ def compact_view(sm: SourceMap, *, no_tree: bool = False) -> dict[str, Any]:
     if sm.code_notes_summary is not None and sm.code_notes_summary.requested:
         code_notes_summary_dict = asdict(sm.code_notes_summary)
 
+    # Entry points: strip None fields for compactness
+    entry_points_compact = [
+        {k: v for k, v in asdict(ep).items() if v is not None and v != ""}
+        for ep in sm.entry_points
+    ]
+    if not entry_points_compact:
+        entry_points_compact = None  # type: ignore[assignment]  # signal: not detected
+
+    # Confidence summary
+    conf_dict: Any = None
+    anomalies: Any = None
+    if sm.confidence_summary is not None:
+        conf_dict = asdict(sm.confidence_summary)
+        if sm.confidence_summary.anomalies:
+            anomalies = sm.confidence_summary.anomalies
+
+    # Analysis gaps
+    gaps_list: Any = None
+    if sm.analysis_gaps:
+        gaps_list = [asdict(g) for g in sm.analysis_gaps]
+
     result: dict[str, Any] = {
         "schema_version": sm.metadata.schema_version,
         "project_type": sm.project_type,
         "project_summary": sm.project_summary,
         "architecture_summary": sm.architecture_summary,
         "stacks": [asdict(stack) for stack in sm.stacks],
-        "entry_points": [asdict(entry_point) for entry_point in sm.entry_points],
+        "entry_points": entry_points_compact,
         "dependency_summary": dep_summary_dict,
         "key_dependencies": key_deps,
         "env_summary": env_summary_dict,
         "code_notes_summary": code_notes_summary_dict,
+        "confidence_summary": conf_dict,
+        "anomalies": anomalies,
+        "analysis_gaps": gaps_list,
     }
-    if not no_tree:
-        result["file_tree_depth1"] = depth1
-    return result
+    # Strip keys that are fully None and not informative
+    return {k: v for k, v in result.items() if v is not None or k in (
+        "project_type", "project_summary", "architecture_summary",
+        "dependency_summary", "confidence_summary",
+    )}
 
 
 def normalize_source_map(sm: SourceMap) -> SourceMap:
@@ -349,15 +372,16 @@ def agent_view(sm: SourceMap) -> dict[str, Any]:
     """Opinionated output for AI agents — structured, noise-free, gap-aware.
 
     Output order:
-        project   → what it is and what stack it uses
-        entry_points → where execution starts
-        architecture → how it's structured
-        key_dependencies → what runtime dependencies matter (when analyzed)
-        signals   → compact operational signals (env, notes, tests)
-        gaps      → what's uncertain or missing
+        1. project          → identity: type, summary, primary stack, frameworks
+        2. entry_points     → where execution starts (with reason/evidence)
+        3. architecture     → how it's structured (flow description)
+        4. key_dependencies → runtime dependencies that matter (when analyzed)
+        5. signals          → compact operational context (env, notes, tests)
+        6. confidence_summary → detection quality and hard/soft signals
+        7. analysis_gaps    → what's uncertain or missing
 
     Never includes: file_tree, file_paths, schema internals, empty sections,
-    null fields, raw dependency lists, or low-signal metadata.
+    null fields, raw dependency lists, metrics, docs, or low-signal metadata.
     """
     # ── 1. Identity ──────────────────────────────────────────────────────────
     primary = next((s for s in sm.stacks if s.primary), sm.stacks[0] if sm.stacks else None)
@@ -381,10 +405,11 @@ def agent_view(sm: SourceMap) -> dict[str, Any]:
 
     result: dict[str, Any] = {"project": project}
 
-    # ── 2. Entry points ───────────────────────────────────────────────────────
+    # ── 2. Entry points (with reason/evidence when available) ─────────────────
     if sm.entry_points:
+        _ep_skip = {"workspace"}
         result["entry_points"] = [
-            {k: v for k, v in asdict(ep).items() if v is not None and v != ""}
+            {k: v for k, v in asdict(ep).items() if v is not None and v != "" and k not in _ep_skip}
             for ep in sm.entry_points
         ]
 
@@ -394,9 +419,9 @@ def agent_view(sm: SourceMap) -> dict[str, Any]:
 
     # ── 4. Key dependencies (role-sorted, already computed) ───────────────────
     if sm.dependency_summary and sm.dependency_summary.requested and sm.key_dependencies:
-        _skip = {"parent", "manifest_path", "workspace", "source", "ecosystem"}
+        _dep_skip = {"parent", "manifest_path", "workspace", "source", "ecosystem"}
         result["key_dependencies"] = [
-            {k: v for k, v in asdict(d).items() if v is not None and k not in _skip}
+            {k: v for k, v in asdict(d).items() if v is not None and k not in _dep_skip}
             for d in sm.key_dependencies
         ]
 
@@ -428,29 +453,59 @@ def agent_view(sm: SourceMap) -> dict[str, Any]:
     if signals:
         result["signals"] = signals
 
-    # ── 6. Gaps — what's uncertain or missing ────────────────────────────────
-    gaps: list[str] = []
-
-    if not sm.entry_points:
-        gaps.append("No entry point detected — project structure may be non-standard")
-
-    if primary and primary.confidence == "low":
-        gaps.append(f"Low-confidence stack detection for '{primary.stack}' — no manifest found")
-
-    heuristic_stacks = [s for s in sm.stacks if s.detection_method == "heuristic"]
-    if heuristic_stacks:
-        gaps.append(
-            f"Heuristic-only detection (no manifest): {', '.join(s.stack for s in heuristic_stacks)}"
-        )
-
-    if sm.dependency_summary and sm.dependency_summary.requested:
-        for limitation in sm.dependency_summary.limitations[:3]:
-            gaps.append(limitation)
-    elif not sm.dependency_summary or not sm.dependency_summary.requested:
-        gaps.append("Dependencies not analyzed — add --dependencies for full context")
-
-    if gaps:
-        result["gaps"] = gaps
+    # ── 6. Confidence summary ─────────────────────────────────────────────────
+    if sm.confidence_summary is not None:
+        cs = sm.confidence_summary
+        conf: dict[str, Any] = {
+            "overall": cs.overall,
+            "stack": cs.stack_confidence,
+            "entry_points": cs.entry_point_confidence,
+        }
+        if cs.hard_signals:
+            conf["hard_signals"] = cs.hard_signals
+        if cs.soft_signals:
+            conf["soft_signals"] = cs.soft_signals
+        if cs.ignored_signals:
+            conf["ignored_signals"] = cs.ignored_signals
+        if cs.anomalies:
+            conf["anomalies"] = cs.anomalies
+        result["confidence_summary"] = conf
+
+    # ── 7. Analysis gaps ──────────────────────────────────────────────────────
+    analysis_gaps: list[dict[str, Any]] = []
+
+    if sm.analysis_gaps:
+        analysis_gaps = [asdict(g) for g in sm.analysis_gaps]
+    else:
+        # Fallback gap derivation when confidence_analyzer was not run
+        if not sm.entry_points:
+            analysis_gaps.append({
+                "area": "entry_points",
+                "reason": "No entry point detected — project structure may be non-standard",
+                "impact": "high",
+            })
+        if primary and primary.confidence == "low":
+            analysis_gaps.append({
+                "area": "stack",
+                "reason": f"Low-confidence detection for '{primary.stack}' — no manifest found",
+                "impact": "medium",
+            })
+        heuristic_stacks = [s for s in sm.stacks if s.detection_method == "heuristic"]
+        if heuristic_stacks:
+            analysis_gaps.append({
+                "area": "stack",
+                "reason": f"Heuristic-only detection (no manifest): {', '.join(s.stack for s in heuristic_stacks)}",
+                "impact": "medium",
+            })
+        if not sm.dependency_summary or not sm.dependency_summary.requested:
+            analysis_gaps.append({
+                "area": "dependencies",
+                "reason": "Dependencies not analyzed — add --dependencies for full context",
+                "impact": "medium",
+            })
+
+    if analysis_gaps:
+        result["analysis_gaps"] = analysis_gaps
 
     return result
 

{sourcecode-0.22.0.dist-info → sourcecode-0.23.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 0.22.0
+Version: 0.23.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.dist-info → sourcecode-0.23.0.dist-info}/RECORD

@@ -1,22 +1,23 @@
-sourcecode/__init__.py,sha256=fj7lPtxQ0hLFlBv6uWwpvAPQdgoXjKNjaM1Tpn2SFKg,100
+sourcecode/__init__.py,sha256=Dh82QypoDBYj3Gur3QVPfjnJcgmk8S2TvsTDOr0Z0Mc,100
 sourcecode/architecture_analyzer.py,sha256=zxgqeqn2FhIUDn06X-whjGKiXbrHFkRlzZcr2zKd0Gw,16874
 sourcecode/architecture_summary.py,sha256=rr-Q2LLe6bXZ27NuV2pYb0_LZyEFn3sngKMdXCZSGbE,13263
 sourcecode/classifier.py,sha256=Ft_RfYS-KOe0t7vjgUx04OoCJd1-DXK7k9-I0CFDSnU,6934
-sourcecode/cli.py,sha256=x_ZjTyy9IaBqCFXOLxwTvopB3OeHVCv2mk1s1E2Hc_g,29446
+sourcecode/cli.py,sha256=SyO5JHR0cKMoMEas-of1pnWneZMjr7JhTxURR7-Kv5w,30925
 sourcecode/code_notes_analyzer.py,sha256=rRd8bFYV0krjlxxQV0wenwE9K7pVpUQSR7KvSvUQKw4,9226
+sourcecode/confidence_analyzer.py,sha256=gvQ92XCeGsACskSGU-GWTB7OqU1tT0eTgV-A7XA_lGs,8968
 sourcecode/coverage_parser.py,sha256=q0LeZJaX1bnntLu-ImksdBsMlpsVmk_iUfSaB4eaJGo,19702
-sourcecode/dependency_analyzer.py,sha256=C-G2paetrBUCMTA2KlWrD04fl9Y4q75sk4X0M0utzpE,50863
+sourcecode/dependency_analyzer.py,sha256=Exq0BfInvfS5iAg9xAr6WI2uPNuotkIudTKcYJcRhB8,52757
 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/metrics_analyzer.py,sha256=4uh11v-Q0gdrN87BOxuFWUym3N3AOkOuy21K5N8peB8,20126
-sourcecode/prepare_context.py,sha256=yPRohYZ3wvX156GQSo1vYuoCDBIG3uy3G-3DdNbGHKU,19271
+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=YJhzdn5C9_S1OPWoMgn7gdtY9jgWfiESN-m9znBTjIg,15833
+sourcecode/schema.py,sha256=u8WorLBlbcG-I5oaB0ShTGHDoNaLcl4vyADNV6P2O9g,17159
 sourcecode/semantic_analyzer.py,sha256=asQfJf-EhzYaOTA-iMuZsrVXtbW7SV2WEKCxgsxa88Y,79413
-sourcecode/serializer.py,sha256=Yqn-AOZL0kSFwfY0U72yOvVuYi7quPjyq6xXHbW_vc0,22462
+sourcecode/serializer.py,sha256=-dNeUFingePa3WcCTjLe0o6jSdLu4PfL9rPlD8uuky4,25163
 sourcecode/summarizer.py,sha256=YdIA5gGEc0XSctPgmTnFnuZI72bprrOYhkJNoDmvHwM,12114
 sourcecode/tree_utils.py,sha256=Fj9OIuUksBvgibNd3feog0sMDjVypJzPexp5lvMoYWI,1424
 sourcecode/workspace.py,sha256=fQlVoNx8S-fSHpKoJ0JBvEHCFkxszH0KZVJed1i3TRk,6845
@@ -26,20 +27,20 @@ sourcecode/detectors/dart.py,sha256=QbqaL5v18-_ort75HihVBt8MsKUfOcFDF8IpWFLiXpI,
 sourcecode/detectors/dotnet.py,sha256=UC-74VW850r3admcl36R-rl3M0-nBFXw8ph5e9RSas8,1978
 sourcecode/detectors/elixir.py,sha256=jCpvt5Yi6jvplc80ovRtWh17q-11ZGo9qX7o8b57TJE,1713
 sourcecode/detectors/go.py,sha256=KehAyvC3H_s8zwwqFM0bAbztQbbUBDjpNbGvM2kQlk8,1836
-sourcecode/detectors/heuristic.py,sha256=253JB1iD0IXC72AdGRivQtZNgGziyOJOJrJeztOzdJs,1953
+sourcecode/detectors/heuristic.py,sha256=JWb_dXNI1YDxk9a3DFeXTbKYfAGOFqV6jVxxqouWSiA,2238
 sourcecode/detectors/java.py,sha256=qFVpMy5mu490ENhutO1LV2Gidms4ZZUfNX5Qv5Qxh2I,7188
 sourcecode/detectors/jvm_ext.py,sha256=EgHJ5W8EE-ZTN9V607mVzohyKgZE8Mc2jCi-DF8RAZU,2616
 sourcecode/detectors/nodejs.py,sha256=qNJ1m0E_TsPiR_iNcSgK4igb4mm99h-HDKE7C8gME6o,4762
 sourcecode/detectors/parsers.py,sha256=ugPg8yNUf0Ai1gA7Fnn6wAkYGFjTxRodSP3IeViYJJ4,2290
 sourcecode/detectors/php.py,sha256=W_AQD0WMVDdWHa9h_ilX6W8XSpz0X4ctpMK2WXfXf1I,1887
 sourcecode/detectors/project.py,sha256=YCynNC8drJutPMiDGPutlYaL49IO8M-1Ms_RwVY09ss,6221
-sourcecode/detectors/python.py,sha256=EGhHxvgjSVAZujOswdrK7awuKj79bfYRKXI38pqpJs8,9504
+sourcecode/detectors/python.py,sha256=GLuLxJw-6tTrnC1Ng8NLDtt8AOT7waM1MxVWc9jBaEw,9846
 sourcecode/detectors/ruby.py,sha256=Q4B5ePAw6-T4DLfanKJiuLHLqUigTPVrzylcXJMei3M,1591
 sourcecode/detectors/rust.py,sha256=V23NO6Y8NsrhrUlGC2feUEcNK63hf3gc1y3jI4tes1Q,2264
 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.22.0.dist-info/METADATA,sha256=R7dNRAnWzgeRSNAnDT78YOaThzkojXX0eKZXkyVD6Pw,30326
-sourcecode-0.22.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-0.22.0.dist-info/entry_points.txt,sha256=voDtdlGU2-jR3wCZpQoOls_0eUKaDVCKIfajGHFDATs,50
-sourcecode-0.22.0.dist-info/RECORD,,
+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,,