sourcecode 0.38.0__py3-none-any.whl → 0.41.0__py3-none-any.whl

sourcecode/__init__.py

@@ -1,3 +1,3 @@
 """sourcecode — Deterministic codebase context maps for AI coding agents."""
 
-__version__ = "0.38.0"
+__version__ = "0.41.0"

sourcecode/cli.py

@@ -220,6 +220,29 @@ def _preprocess_argv() -> None:
     _sys.argv = _sys.argv[:1] + modified
 
 
+def _copy_to_clipboard(content: str) -> bool:
+    """Copy text to system clipboard. Returns True on success, False otherwise (never raises)."""
+    import subprocess
+    import sys as _sys
+    try:
+        if _sys.platform == "darwin":
+            subprocess.run(["pbcopy"], input=content.encode("utf-8"), check=True, timeout=10)
+            return True
+        elif _sys.platform == "win32":
+            subprocess.run(["clip"], input=content.encode("utf-16"), check=True, timeout=10)
+            return True
+        else:
+            for cmd in (["xclip", "-selection", "clipboard"], ["xsel", "--clipboard", "--input"]):
+                try:
+                    subprocess.run(cmd, input=content.encode("utf-8"), check=True, timeout=10)
+                    return True
+                except (FileNotFoundError, subprocess.CalledProcessError):
+                    continue
+            return False
+    except Exception:
+        return False
+
+
 app = typer.Typer(
     name="sourcecode",
     help=_HELP,
@@ -543,7 +566,7 @@ def main(
     entrypoints_only: bool = typer.Option(
         False,
         "--entrypoints-only",
-        help="Contract mode: include only files that are entrypoints or have exported symbols.",
+        help="Contract mode: include only files that are runtime entrypoints or have exported symbols (public API surface). Note: 'entrypoints' here includes all files with exports, not strictly detected runtime entry points.",
     ),
     changed_only: bool = typer.Option(
         False,
@@ -571,6 +594,12 @@ def main(
         "--symbol",
         help="Contract mode: extract localized context for a specific symbol name. Returns defining file + all importers.",
     ),
+    copy: bool = typer.Option(
+        False,
+        "--copy",
+        "-c",
+        help="Copy output to system clipboard after a successful run. No-op when --output is used or clipboard is unavailable.",
+    ),
 ) -> None:
     """Analyze a repository and produce structured context for AI coding agents.
 
@@ -1127,11 +1156,15 @@ def main(
 
         _all_call_files = set(_fan_in) | set(_fan_out)
         _hotspots: list[dict] = []
-        # Filter test paths from hotspots — they dominate fan-in by calling many modules
+        # Filter test, noise, and auxiliary paths — they dominate fan-in but carry no signal
         _TEST_MARKERS = {"/test", "/tests", "/spec", "/specs", "_test.", ".test.", ".spec."}
+        from sourcecode.ranking_engine import RankingEngine as _RankingEngine
+        _sem_engine = _RankingEngine(sm.monorepo_packages)
         for _p in _all_call_files:
             if any(_m in _p for _m in _TEST_MARKERS) or _p.startswith("test"):
                 continue
+            if _sem_engine.is_noise(_p) or _sem_engine.is_auxiliary(_p):
+                continue
             _in = _fan_in[_p]
             _out = _fan_out[_p]
             _score = _in * 2.0 + _out * 1.0
@@ -1386,6 +1419,13 @@ def main(
     # 6. Write output (CLI-04)
     write_output(content, output=output)
 
+    # 7. Clipboard copy (--copy / -c)
+    if copy and output is None:
+        _trimmed = content.strip()
+        if _trimmed and _trimmed not in ("{}", "[]", "null"):
+            if _copy_to_clipboard(content):
+                typer.echo("✓ copied to clipboard", err=True)
+
 
 @app.command("prepare-context")
 def prepare_context_cmd(
@@ -1417,6 +1457,12 @@ def prepare_context_cmd(
         "--dry-run",
         help="Show what would be analyzed without running it",
     ),
+    copy: bool = typer.Option(
+        False,
+        "--copy",
+        "-c",
+        help="Copy output to system clipboard after a successful run. No-op when clipboard is unavailable.",
+    ),
 ) -> None:
     """Task-specific context for AI coding agents.
 
@@ -1514,7 +1560,14 @@ def prepare_context_cmd(
     if llm_prompt:
         out["llm_prompt"] = builder.render_prompt(output)
 
-    typer.echo(json.dumps(out, indent=2, ensure_ascii=False))
+    _pc_content = json.dumps(out, indent=2, ensure_ascii=False)
+    typer.echo(_pc_content)
+
+    if copy:
+        _trimmed = _pc_content.strip()
+        if _trimmed and _trimmed not in ("{}", "[]", "null"):
+            if _copy_to_clipboard(_pc_content):
+                typer.echo("✓ copied to clipboard", err=True)
 
 
 # ── Telemetry commands ────────────────────────────────────────────────────────

sourcecode/contract_model.py

@@ -91,6 +91,7 @@ class FileContract:
     fan_out: int = 0  # how many files this imports
     is_entrypoint: bool = False
     is_changed: bool = False
+    ranking_reasons: list[str] = field(default_factory=list)
 
     # Extraction quality
     extraction_method: str = "heuristic"  # ast | tree_sitter | heuristic

sourcecode/contract_pipeline.py

@@ -17,6 +17,7 @@ from typing import Any, Literal, Optional
 
 from sourcecode.ast_extractor import AstExtractor, _LANGUAGE_MAP
 from sourcecode.contract_model import ContractSummary, FileContract
+from sourcecode.ranking_engine import RankingEngine
 from sourcecode.relevance_scorer import RelevanceScorer
 from sourcecode.schema import EntryPoint, MonorepoPackageInfo
 
@@ -27,22 +28,6 @@ from sourcecode.schema import EntryPoint, MonorepoPackageInfo
 _MAX_FILES = 500      # hard cap on files extracted per run
 _SRC_EXTENSIONS: frozenset[str] = frozenset(_LANGUAGE_MAP.keys())
 
-# Role-based score adjustments applied after contract extraction.
-# Runtime roles get a boost; config/util are neutral or penalized.
-_ROLE_SCORE: dict[str, float] = {
-    "entrypoint": 0.15,
-    "service":    0.10,
-    "route":      0.10,
-    "api":        0.08,
-    "middleware": 0.06,
-    "store":      0.05,
-    "model":      0.05,
-    "hook":       0.05,
-    "component":  0.03,
-    "util":       0.00,
-    "config":    -0.10,
-    "unknown":    0.00,
-}
 
 RankStrategy = Literal["relevance", "centrality", "git-churn"]
 
@@ -194,6 +179,7 @@ class ContractPipeline:
         """
         entry_paths = {ep.path.replace("\\", "/") for ep in (entry_points or [])}
         scorer = RelevanceScorer(monorepo_packages)
+        engine = RankingEngine(monorepo_packages)
 
         # 1. Changed files (for --changed-only and ranking)
         changed_files: set[str] = set()
@@ -267,9 +253,24 @@ class ContractPipeline:
         if rank_by == "git-churn":
             churn = _get_git_churn(root, [c.path for c in contracts])
 
-        # 6. Compute relevance scores
+        # 6. Compute relevance scores via unified ranking engine
+        max_fan_in = max((c.fan_in for c in contracts), default=1) if contracts else 1
+        max_churn_val = max(churn.values(), default=1) if churn else 1
         for c in contracts:
-            c.relevance_score = self._score(c, scorer, churn)
+            fs = engine.score(
+                c.path,
+                fan_in=c.fan_in,
+                fan_out=c.fan_out,
+                max_fan_in=max_fan_in,
+                git_churn=churn.get(c.path, 0),
+                max_churn=max_churn_val,
+                is_entrypoint=c.is_entrypoint,
+                is_changed=c.is_changed,
+                export_count=len(c.exports),
+                task="default",
+            )
+            c.relevance_score = fs.display_score
+            c.ranking_reasons = fs.reasons
 
         # 7. Rank
         contracts = self._rank(contracts, rank_by)
@@ -285,7 +286,7 @@ class ContractPipeline:
                     known_paths=set(src_paths),
                     entry_paths=entry_paths,
                     changed_files=changed_files,
-                    scorer=scorer,
+                    engine=engine,
                 )
 
         # 9. Entrypoints-only filter
@@ -312,45 +313,13 @@ class ContractPipeline:
         )
         return contracts, summary
 
-    def _score(
-        self,
-        c: FileContract,
-        scorer: RelevanceScorer,
-        churn: dict[str, int],
-    ) -> float:
-        base = scorer.score(c.path)
-
-        if c.is_entrypoint:
-            base += 0.3
-        if c.is_changed:
-            base += 0.2
-
-        # Fan-in is the strongest signal: many callers = critical contract
-        fi_score = min(c.fan_in / 10.0, 0.3)
-        fo_score = min(c.fan_out / 15.0, 0.15)
-        base += fi_score + fo_score
-
-        # Exported API value
-        export_count = len(c.exports)
-        base += min(export_count / 20.0, 0.1)
-
-        # Churn
-        churn_score = min(churn.get(c.path, 0) / 20.0, 0.1)
-        base += churn_score
-
-        # Role-based boost: runtime roles score higher than auxiliary
-        base += _ROLE_SCORE.get(c.role, 0.0)
-
-        return min(1.0, base)
-
     def _rank(self, contracts: list[FileContract], rank_by: RankStrategy) -> list[FileContract]:
         if rank_by == "centrality":
-            # Approximate centrality: fan_in + fan_out
-            return sorted(contracts, key=lambda c: -(c.fan_in + c.fan_out))
+            return sorted(contracts, key=lambda c: (-(c.fan_in + c.fan_out), c.path))
         if rank_by == "git-churn":
-            return sorted(contracts, key=lambda c: (-c.is_changed, -c.relevance_score))
-        # Default: relevance
-        return sorted(contracts, key=lambda c: (-c.is_entrypoint, -c.relevance_score))
+            return sorted(contracts, key=lambda c: (-c.is_changed, -c.relevance_score, c.path))
+        # Default: relevance — path breaks ties deterministically
+        return sorted(contracts, key=lambda c: (-c.is_entrypoint, -c.relevance_score, c.path))
 
     def _symbol_deep_scan(
         self,
@@ -359,7 +328,7 @@ class ContractPipeline:
         known_paths: set[str],
         entry_paths: set[str],
         changed_files: set[str],
-        scorer: RelevanceScorer,
+        engine: RankingEngine,
     ) -> list[FileContract]:
         """Grep-based fallback when the shallow scan missed the defining files.
 
@@ -367,7 +336,7 @@ class ContractPipeline:
         extracts contracts for candidates not already processed, then re-applies
         the symbol filter. Fan-in/fan-out are not computed for these contracts.
         """
-        candidates = _find_symbol_files(root, symbol, known_paths, scorer)
+        candidates = _find_symbol_files(root, symbol, known_paths, engine)
         if not candidates:
             return []
 
@@ -379,7 +348,9 @@ class ContractPipeline:
                 continue
             contract.is_entrypoint = rel_path in entry_paths
             contract.is_changed = rel_path in changed_files
-            contract.relevance_score = scorer.score(rel_path)
+            fs = engine.score(rel_path, is_entrypoint=contract.is_entrypoint, is_changed=contract.is_changed)
+            contract.relevance_score = fs.display_score
+            contract.ranking_reasons = fs.reasons
             extra.append(contract)
 
         return _filter_by_symbol(extra, symbol)
@@ -531,7 +502,7 @@ def _find_symbol_files(
     root: Path,
     symbol: str,
     known_paths: set[str],
-    scorer: RelevanceScorer,
+    engine: RankingEngine,
 ) -> list[str]:
     """Find source files outside *known_paths* that contain *symbol* as text.
 
@@ -560,7 +531,7 @@ def _find_symbol_files(
             if line.startswith("./"):
                 line = line[2:]
             line = line.replace("\\", "/")
-            if line and line not in known_paths and not scorer.is_noise(line):
+            if line and line not in known_paths and not engine.is_noise(line):
                 found.append(line)
         return found
     except Exception:
@@ -578,7 +549,7 @@ def _find_symbol_files(
                 rel_str = str(rel).replace("\\", "/")
             except ValueError:
                 continue
-            if rel_str in known_paths or scorer.is_noise(rel_str):
+            if rel_str in known_paths or engine.is_noise(rel_str):
                 continue
             try:
                 content = Path(full).read_text(encoding="utf-8", errors="replace")

sourcecode/doc_analyzer.py

@@ -185,6 +185,13 @@ class DocAnalyzer:
         if any(r.doc_text and r.doc_text.endswith(self._TRUNCATION_SUFFIX) for r in records):
             truncated = True
 
+        # Explicit absence signal: scanned files but found nothing
+        if total_count == 0 and file_paths:
+            limitations.append(
+                f"no_docs_found: {len(file_paths)} file(s) scanned, "
+                "no docstrings or JSDoc comments found"
+            )
+
         summary = DocSummary(
             requested=True,
             total_count=total_count,

sourcecode/git_analyzer.py

@@ -20,12 +20,13 @@ _RELEASE_COMMIT_RE = re.compile(
 )
 # Matches version-bump phrases anywhere in the commit subject (multilingual)
 _RELEASE_COMMIT_CONTAINS_RE = re.compile(
-    r"subiendo a v?[\d.]"          # Spanish: "subiendo a v.0.28.0"
+    r"subiendo a v?[\d.]"              # Spanish: "subiendo a 0.38.0", "subiendo a v.0.31.0"
+    r"|actualizando a v?[\d.]"         # Spanish: "actualizando a 0.15.1"
     r"|bumping to v?[\d.]"
     r"|preparing (?:v|release)[\d. ]"
     r"|releasing v?[\d.]"
     r"|cut v?[\d.]"
-    r"|\bv\d+\.\d+\.\d+\b",       # bare version tag in middle of message
+    r"|\bv\d+\.\d+\.\d+\b",           # bare version tag in middle of message
     re.IGNORECASE,
 )
 
@@ -34,12 +35,25 @@ _HOTSPOT_ADMIN_FILENAMES: frozenset[str] = frozenset({
     "CHANGELOG.md", "CHANGELOG", "CHANGES.md", "CHANGES", "HISTORY.md",
     "RELEASE.md", "RELEASES.md", "RELEASE_NOTES.md", "CHANGELOG.rst", "NEWS.md", "NEWS.rst",
     "VERSION", "VERSION.txt", "version.txt", ".version",
+    "_version.py", "__version__.py", "version.py",
+    "pyproject.toml", "setup.cfg",
     "package-lock.json", "yarn.lock", "pnpm-lock.yaml", "bun.lockb",
     "Cargo.lock", "poetry.lock", "Pipfile.lock", "composer.lock",
     "go.sum", "Gemfile.lock",
 })
 _HOTSPOT_ADMIN_SUFFIXES: tuple[str, ...] = (".lock", ".snap", ".min.js", ".min.css")
 
+# Auxiliary directory names whose files should be excluded from hotspots —
+# docs, examples, benchmarks etc. are high-commit but low operational signal.
+_HOTSPOT_AUX_DIRS: frozenset[str] = frozenset({
+    "docs", "doc", "benchmark", "benchmarks", "example", "examples",
+    "demo", "demos", "playground", "playgrounds", "fixture", "fixtures",
+    "generated", "generate", "storybook", ".storybook", "stories",
+    "sandbox", "sandboxes",
+    "ci", "translations", "locales", "locale", "i18n", "l10n",
+    ".planning",
+})
+
 
 def _run_git(args: list[str], cwd: Path, timeout: int = 15) -> tuple[str, int]:
     result = subprocess.run(
@@ -191,7 +205,7 @@ def _parse_commits(output: str) -> list:
 
 
 def _is_hotspot_admin(path: str) -> bool:
-    """True for files that are noisy from release/bot commits, not semantic changes."""
+    """True for files that are noisy from release/bot commits or auxiliary dirs."""
     filename = path.rsplit("/", 1)[-1]
     if filename in _HOTSPOT_ADMIN_FILENAMES:
         return True
@@ -202,9 +216,15 @@ def _is_hotspot_admin(path: str) -> bool:
     _lower = filename.lower()
     if _lower.startswith("changelog.") or _lower.startswith("changes."):
         return True
-    # lerna.json and root-level package.json are modified by version bumps, not dev work
+    # lerna.json is modified by version bumps, not dev work
     if filename in ("lerna.json",):
         return True
+    # Auxiliary directory parts — docs, benchmarks, examples, demos, etc.
+    # These may have high commit counts but are not operational signal for agents.
+    parts = path.split("/")
+    for part in parts[:-1]:  # check directory components, not the filename itself
+        if part.lower() in _HOTSPOT_AUX_DIRS:
+            return True
     return False
 
 
@@ -231,6 +251,9 @@ def _parse_hotspots(output: str) -> list:
             continue
         if skip_commit:
             continue
+        # Skip git artifact lines that are not file paths: flags (-o, --), separators, etc.
+        if line.startswith("-") or not ("/" in line or "." in line):
+            continue
         if _is_hotspot_admin(line):
             continue
         file_counts[line] += 1

sourcecode/prepare_context.py

@@ -627,94 +627,81 @@ class TaskContextBuilder:
         git_hotspots: Optional[dict[str, int]] = None,
         uncommitted_files: Optional[set[str]] = None,
     ) -> list[RelevantFile]:
-        from sourcecode.relevance_scorer import RelevanceScorer
+        from sourcecode.ranking_engine import RankingEngine
         from sourcecode.file_classifier import FileClassifier
-        scorer = RelevanceScorer(monorepo_packages or [])
-        file_classifier = FileClassifier(self.root, [
-            # _rank_files only needs production path evidence; EntryPoint objects
-            # are not available here, so category evidence is best-effort below.
-        ], monorepo_packages or [])
 
-        # Auxiliary entry points (benchmark, docs, examples) must not get
-        # the production entry boost — they are not runtime signals.
-        runtime_entry_set = {ep for ep in entry_set if not scorer.is_auxiliary(ep)}
+        engine = RankingEngine(monorepo_packages or [])
+        file_classifier = FileClassifier(self.root, [], monorepo_packages or [])
+
+        # Auxiliary entry points (benchmark, docs, examples) are not runtime
+        runtime_entry_set = {ep for ep in entry_set if not engine.is_auxiliary(ep)}
 
         _hotspots = git_hotspots or {}
         _uncommitted = uncommitted_files or set()
         _max_churn = max(_hotspots.values(), default=1)
 
-        scored: list[tuple[float, RelevantFile]] = []
+        scored: list[tuple[float, str, RelevantFile]] = []
 
         for path in all_paths:
             if Path(path).suffix.lower() not in _ALL_EXTENSIONS:
                 continue
             if any(pen in path for pen in spec.ranking_penalties):
                 continue
-
-            # Hard filter: tooling/config noise
-            if scorer.is_noise(path):
+            if engine.is_noise(path):
                 continue
 
             is_test = path in test_set
             if is_test and task_name != "generate-tests":
                 continue
 
-            score = 0.0
-            reasons: list[str] = []
+            # Structural + git signals from unified engine (task-weighted)
+            fs = engine.score(
+                path,
+                is_entrypoint=(path in runtime_entry_set),
+                git_churn=_hotspots.get(path, 0),
+                max_churn=_max_churn,
+                is_changed=(path in _uncommitted),
+                task=task_name,
+            )
 
-            # Only runtime entry points get the production boost
-            if path in runtime_entry_set:
-                score += 3.0
-                reasons.append("entry point")
+            if fs.score < -50:  # hard noise
+                continue
 
+            # Content classification boost (reads file imports)
+            content_boost = 0.0
+            content_reasons: list[str] = []
             file_class = file_classifier.classify(path)
             if file_class is not None:
-                score += file_class.relevance * 2.0
-                reasons.append(f"{file_class.category}: {file_class.reason}")
+                content_boost = file_class.relevance * 2.0
+                content_reasons.append(f"{file_class.category}: {file_class.reason}")
 
             if is_test:
-                score += 2.0
-                reasons.append("existing test")
-            elif self._is_source(path):
-                score += 0.5
-                if not reasons:
-                    reasons.append("source file with supported extension")
-
-            # Operational relevance boost/penalty from package role
-            rel = scorer.score(path)
-            score += (rel - 0.3) * 2.0  # center around 0.3 baseline
-
-            # Suppress auxiliary dirs (benchmarks, docs, examples, demos)
-            if scorer.is_auxiliary(path):
-                score -= 2.0
-
-            # Git churn: frequently changed files are high-signal for active work
-            churn = _hotspots.get(path, 0)
-            if churn > 0:
-                score += (churn / _max_churn) * 1.5
-                reasons.append(f"git churn ({churn})")
-
-            # Uncommitted changes: files actively being edited rank highest
-            if path in _uncommitted:
-                score += 1.0
-                reasons.append("uncommitted changes")
-
-            if score <= 0:
+                content_boost += 2.0
+                content_reasons.append("existing test")
+            elif self._is_source(path) and not content_reasons:
+                content_boost += 0.5
+
+            total = fs.score + content_boost
+            if total <= 0:
                 continue
 
             role = (
                 "entrypoint" if path in runtime_entry_set
                 else ("test" if is_test else "source")
             )
-            scored.append((score, RelevantFile(
+            all_reasons = [r for r in fs.reasons if r != "source file"] + content_reasons
+            reason_str = ", ".join(all_reasons) if all_reasons else "source file"
+
+            scored.append((total, path, RelevantFile(
                 path=path,
                 role=role,
-                score=round(score, 1),
-                reason=", ".join(reasons) if reasons else "source file",
+                score=round(min(total / 3.0, 1.0), 2),
+                reason=reason_str,
             )))
 
-        scored.sort(key=lambda x: -x[0])
-        return [f for _, f in scored[:15]]
+        # Deterministic: score desc, then path asc as tiebreaker
+        scored.sort(key=lambda x: (-x[0], x[1]))
+        return [f for _, _, f in scored[:15]]
 
     def _is_test(self, path: str) -> bool:
         name = Path(path).name.lower()

sourcecode/ranking_engine.py

@@ -0,0 +1,231 @@
+from __future__ import annotations
+
+"""Unified, deterministic file ranking engine.
+
+Single source of truth for scoring files by AI-agent relevance.
+Used by: contract_pipeline, prepare_context, serializer (_file_relevance).
+
+Score components (all weighted by task profile):
+  path_relevance  — structural path signals (source roots, entrypoint stems, noise)
+  entrypoint      — runtime entry point boost
+  fan_in          — import centrality: how many other files import this
+  fan_out         — hub signal: how many files this imports
+  git_churn       — recent commit frequency
+  code_notes      — bug/fixme annotation density
+  exports         — public API surface size
+  is_changed      — uncommitted or recently modified
+
+Determinism: callers should sort by (-score, path). Path breaks all ties
+reproducibly so re-runs on an unchanged repo produce identical rankings.
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+from sourcecode.relevance_scorer import RelevanceScorer
+from sourcecode.schema import MonorepoPackageInfo
+
+
+@dataclass
+class FileScore:
+    path: str
+    score: float          # raw ranking score (higher = more relevant)
+    display_score: float  # 0.0–1.0 for backward-compat output fields
+    reasons: list[str]    # human-readable signal labels
+
+
+@dataclass
+class TaskWeights:
+    """Per-signal weights for a specific task profile."""
+    path_relevance: float = 1.0
+    entrypoint: float = 1.0
+    fan_in: float = 1.0
+    fan_out: float = 0.5
+    git_churn: float = 0.5
+    code_notes: float = 0.5
+    exports: float = 0.3
+    is_changed: float = 0.8
+
+
+# Task profiles: each emphasizes different signals for different agent goals.
+# The contrast between profiles is intentional — fix-bug and explain must
+# produce meaningfully different ranked sets from the same codebase.
+TASK_WEIGHTS: dict[str, TaskWeights] = {
+    # fix-bug: files with bug annotations, recent churn, actively changed logic
+    "fix-bug": TaskWeights(
+        path_relevance=0.5, entrypoint=0.5,
+        fan_in=0.8, fan_out=0.3,
+        git_churn=1.5, code_notes=3.0,
+        exports=0.2, is_changed=2.0,
+    ),
+    # refactor: highly-coupled files, technical debt, complex hubs
+    "refactor": TaskWeights(
+        path_relevance=0.8, entrypoint=0.3,
+        fan_in=2.0, fan_out=2.0,
+        git_churn=0.3, code_notes=2.0,
+        exports=1.0, is_changed=0.3,
+    ),
+    # explain: stable core, entrypoints, central modules — ignore churn noise
+    "explain": TaskWeights(
+        path_relevance=2.0, entrypoint=3.0,
+        fan_in=0.8, fan_out=0.3,
+        git_churn=0.0, code_notes=0.0,
+        exports=0.5, is_changed=0.0,
+    ),
+    # onboard: same as explain but also values hub modules
+    "onboard": TaskWeights(
+        path_relevance=2.0, entrypoint=3.0,
+        fan_in=1.2, fan_out=0.5,
+        git_churn=0.0, code_notes=0.0,
+        exports=1.0, is_changed=0.0,
+    ),
+    # generate-tests: source files with large public API, not yet covered
+    "generate-tests": TaskWeights(
+        path_relevance=0.8, entrypoint=0.3,
+        fan_in=1.5, fan_out=0.8,
+        git_churn=0.5, code_notes=0.5,
+        exports=2.5, is_changed=0.5,
+    ),
+    # review-pr: changed files and their importers
+    "review-pr": TaskWeights(
+        path_relevance=0.5, entrypoint=0.5,
+        fan_in=1.5, fan_out=0.5,
+        git_churn=0.5, code_notes=0.8,
+        exports=0.3, is_changed=3.0,
+    ),
+    # delta: changed files and dependency impact
+    "delta": TaskWeights(
+        path_relevance=0.5, entrypoint=0.5,
+        fan_in=1.5, fan_out=0.5,
+        git_churn=0.5, code_notes=0.5,
+        exports=0.3, is_changed=3.0,
+    ),
+    # default: balanced, no task bias
+    "default": TaskWeights(),
+}
+
+_WORKSPACE_CORE_ROLES = frozenset({
+    "runtime_core", "backend_runtime", "frontend_runtime", "plugin_host",
+    "composition_layer",
+})
+_WORKSPACE_NOISE_ROLES = frozenset({
+    "benchmark_layer", "tooling_layer", "docs_layer", "test_layer",
+})
+
+
+class RankingEngine:
+    """Unified file ranking engine.
+
+    Stateless once constructed. Create one instance per analysis run.
+    """
+
+    def __init__(
+        self,
+        monorepo_packages: Optional[list[MonorepoPackageInfo]] = None,
+    ) -> None:
+        self._scorer = RelevanceScorer(monorepo_packages or [])
+
+    def score(
+        self,
+        path: str,
+        *,
+        fan_in: int = 0,
+        fan_out: int = 0,
+        max_fan_in: int = 10,
+        git_churn: int = 0,
+        max_churn: int = 10,
+        is_entrypoint: bool = False,
+        is_changed: bool = False,
+        code_note_count: int = 0,
+        export_count: int = 0,
+        task: str = "default",
+    ) -> FileScore:
+        """Compute a scored, explained ranking for a single file.
+
+        Returns FileScore with:
+          score         — raw float for ranking comparisons
+          display_score — clamped 0.0–1.0 for output fields
+          reasons       — list of human-readable signal labels
+        """
+        norm = path.replace("\\", "/").lstrip("/")
+
+        if self._scorer.is_noise(norm):
+            return FileScore(path=path, score=-100.0, display_score=0.0, reasons=["noise"])
+
+        w = TASK_WEIGHTS.get(task, TASK_WEIGHTS["default"])
+        reasons: list[str] = []
+        raw = 0.0
+
+        # 1. Structural path relevance (0.0–1.0 from RelevanceScorer)
+        path_rel = self._scorer.score(norm)
+        raw += path_rel * w.path_relevance
+
+        # 2. Runtime entrypoint
+        if is_entrypoint:
+            raw += 0.3 * w.entrypoint
+            reasons.append("runtime entrypoint")
+
+        # 3. Fan-in: import centrality
+        if fan_in > 0 and w.fan_in > 0:
+            fi_norm = min(fan_in / max(max_fan_in, 1), 1.0)
+            raw += fi_norm * 0.3 * w.fan_in
+            if fan_in >= 5:
+                reasons.append(f"high import centrality (fan_in={fan_in})")
+            elif fan_in >= 2:
+                reasons.append(f"imported by {fan_in} modules")
+            else:
+                reasons.append(f"imported by {fan_in} module")
+
+        # 4. Fan-out: hub signal (only when significant to avoid false positives)
+        if fan_out >= 5 and w.fan_out > 0:
+            fo_norm = min(fan_out / 20.0, 1.0)
+            raw += fo_norm * 0.15 * w.fan_out
+            reasons.append(f"hub module (fan_out={fan_out})")
+
+        # 5. Git churn: recently active files are high-signal for fix/review tasks
+        if git_churn > 0 and w.git_churn > 0:
+            churn_norm = min(git_churn / max(max_churn, 1), 1.0)
+            raw += churn_norm * 0.2 * w.git_churn
+            reasons.append(f"recent churn ({git_churn} commits)")
+
+        # 6. Code annotation density (TODO/FIXME/BUG/HACK)
+        if code_note_count > 0 and w.code_notes > 0:
+            notes_norm = min(code_note_count / 10.0, 1.0)
+            raw += notes_norm * 0.15 * w.code_notes
+            reasons.append(f"bug-note density ({code_note_count} annotations)")
+
+        # 7. Export surface size
+        if export_count > 0 and w.exports > 0:
+            raw += min(export_count / 20.0, 0.1) * w.exports
+
+        # 8. Uncommitted or recently changed
+        if is_changed and w.is_changed > 0:
+            raw += 0.2 * w.is_changed
+            reasons.append("uncommitted changes")
+
+        # Monorepo package role
+        pkg_role = self._scorer.package_role(norm)
+        if pkg_role in _WORKSPACE_CORE_ROLES:
+            reasons.append("workspace source root")
+        elif pkg_role in _WORKSPACE_NOISE_ROLES:
+            raw -= 0.3
+
+        # Auxiliary dir hard penalty (docs, benchmarks, examples, demos)
+        if self._scorer.is_auxiliary(norm):
+            raw -= 2.0
+
+        if not reasons:
+            reasons.append("source file")
+
+        display = max(0.0, min(1.0, raw))
+        return FileScore(path=path, score=raw, display_score=display, reasons=reasons)
+
+    def rank(self, scores: list[FileScore]) -> list[FileScore]:
+        """Deterministic sort: highest score first, path breaks all ties."""
+        return sorted(scores, key=lambda s: (-s.score, s.path))
+
+    def is_noise(self, path: str) -> bool:
+        return self._scorer.is_noise(path)
+
+    def is_auxiliary(self, path: str) -> bool:
+        return self._scorer.is_auxiliary(path)

sourcecode/relevance_scorer.py

@@ -222,6 +222,10 @@ class RelevanceScorer:
     def _is_auxiliary(self, norm: str) -> bool:
         return any(p.search(norm) for p in _AUXILIARY_DIR_PATTERNS)
 
+    def package_role(self, path: str) -> str:
+        """Return the monorepo package role for this path, or empty string."""
+        return self._package_role(path.replace("\\", "/").lstrip("/"))
+
     def _package_role(self, norm: str) -> str:
         for prefix, role in self._pkg_roles.items():
             if norm.startswith(prefix):

sourcecode/semantic_analyzer.py

@@ -105,9 +105,13 @@ class SemanticAnalyzer:
 
         # 1. Flatten file_tree and filter to Python files
         all_paths = flatten_file_tree(file_tree)
+        from sourcecode.relevance_scorer import RelevanceScorer as _RS
+        _is_noise = _RS([]).is_noise
         source_files = [
             p for p in all_paths
-            if Path(p).suffix in _PY_EXTENSIONS and (root / p).is_file()
+            if Path(p).suffix in _PY_EXTENSIONS
+            and (root / p).is_file()
+            and not _is_noise(p)
         ]
 
         # Files referenced in tree but not on disk (read_error)
@@ -347,7 +351,9 @@ class SemanticAnalyzer:
         # -----------------------------------------------------------------------
         js_source_files = [
             p for p in all_paths
-            if Path(p).suffix in self._NODE_EXTENSIONS and (root / p).is_file()
+            if Path(p).suffix in self._NODE_EXTENSIONS
+            and (root / p).is_file()
+            and not _is_noise(p)
         ]
         internal_module_paths: set[str] = set(js_source_files)
 

sourcecode/serializer.py

@@ -171,34 +171,91 @@ def _dep_import_key(name: str) -> str:
 
 
 def _file_relevance(sm: SourceMap, *, limit: int = 15) -> list[dict[str, Any]]:
+    from sourcecode.ranking_engine import RankingEngine
+
     root = Path(sm.metadata.analyzed_path) if sm.metadata.analyzed_path else Path(".")
     classifier = FileClassifier(root, sm.entry_points, sm.monorepo_packages)
-    items = classifier.classify_paths(sm.file_paths, limit=limit)
-    return [asdict(item) for item in items]
+    engine = RankingEngine(sm.monorepo_packages)
+
+    # Incorporate git hotspots when --git-context was passed
+    git_churn: dict[str, int] = {}
+    gc = sm.git_context
+    if (gc and gc.requested and gc.change_hotspots
+            and not any(lim in gc.limitations
+                        for lim in ("no_git_repo", "git_not_found", "git_timeout"))):
+        git_churn = {h.file: h.commit_count for h in gc.change_hotspots}
+    max_churn = max(git_churn.values(), default=1)
+
+    entry_paths = {ep.path for ep in sm.entry_points}
+    scored: list[tuple[float, dict[str, Any]]] = []
+
+    for path in sm.file_paths:
+        file_class = classifier.classify(path)
+        fs = engine.score(
+            path,
+            git_churn=git_churn.get(path, 0),
+            max_churn=max_churn,
+            is_entrypoint=path in entry_paths,
+        )
+
+        if fs.score < -50:  # hard noise
+            continue
+
+        content_rel = file_class.relevance if file_class else 0.0
+        combined = fs.score + content_rel
+
+        if combined <= 0 and not (file_class and file_class.relevance > 0.3):
+            continue
+
+        item: dict[str, Any] = {
+            "path": path,
+            "category": file_class.category if file_class else "source",
+            "confidence": file_class.confidence if file_class else "low",
+            "relevance": round(max(0.0, min(1.0, combined / 2.0)), 3),
+            "reason": file_class.reason if file_class else (fs.reasons[0] if fs.reasons else "source file"),
+            "evidence": file_class.evidence if file_class else [],
+        }
+
+        ranking_reasons = [r for r in fs.reasons if r != "source file"]
+        if ranking_reasons:
+            item["ranking_reasons"] = ranking_reasons
+
+        scored.append((combined, item))
+
+    # Deterministic sort: score desc, then path asc
+    scored.sort(key=lambda x: (-x[0], x[1]["path"]))
+    return [item for _, item in scored[:limit]]
 
 
 def _architecture_context(sm: SourceMap) -> dict[str, Any]:
     arch = sm.architecture
     if arch is not None and arch.requested:
-        pattern = arch.pattern if arch.pattern not in (None, "unknown", "flat") else "no confirmed architecture pattern; inferred partial layering"
-        return {
+        pattern = arch.pattern if arch.pattern not in (None, "unknown", "flat") else None
+        ctx: dict[str, Any] = {
             "summary": sm.architecture_summary,
-            "pattern": pattern,
+            "pattern": pattern or "insufficient_evidence",
             "confidence": arch.confidence,
             "method": arch.method,
-            "layers": [
+        }
+        if arch.layers:
+            ctx["layers"] = [
                 {
                     "name": layer.name,
                     "confidence": layer.confidence,
                     "file_count": len(layer.files),
                 }
                 for layer in arch.layers
-            ],
-            "limitations": arch.limitations,
-        }
+            ]
+        else:
+            ctx["no_layers_detected"] = True
+        if arch.confidence == "low" and not pattern:
+            ctx["note"] = "directory structure insufficient for reliable architectural inference; use --semantics for higher accuracy"
+        if arch.limitations:
+            ctx["limitations"] = arch.limitations
+        return ctx
     return {
         "summary": sm.architecture_summary,
-        "pattern": "no confirmed architecture pattern; inferred partial layering",
+        "pattern": "insufficient_evidence",
         "confidence": "low",
         "method": "not_requested",
         "limitations": [
@@ -207,6 +264,18 @@ def _architecture_context(sm: SourceMap) -> dict[str, Any]:
     }
 
 
+def _serialize_file_metric(m: Any) -> dict[str, Any]:
+    """Serialize FileMetrics, omitting null cyclomatic_complexity when availability is unavailable.
+
+    Prevents 100% of JS/TS/Go/Rust files from appearing as errors due to null complexity.
+    The complexity_availability field already communicates the reason — the null value adds noise.
+    """
+    d = asdict(m)
+    if d.get("complexity_availability") == "unavailable":
+        d.pop("cyclomatic_complexity", None)
+    return d
+
+
 def _section_confidence(sm: SourceMap) -> dict[str, str]:
     cs = sm.confidence_summary
     dep_conf = "low"
@@ -254,12 +323,33 @@ def compact_view(sm: SourceMap, *, no_tree: bool = False) -> dict[str, Any]:
         dep_summary_dict = None  # "not analyzed" — agent should add --dependencies
 
     env_summary_dict: Any = None
+    env_map_items: Any = None
     if sm.env_summary is not None and sm.env_summary.requested:
         env_summary_dict = asdict(sm.env_summary)
+        if sm.env_map:
+            _sorted_env = sorted(
+                sm.env_map,
+                key=lambda e: (not getattr(e, "required", False), getattr(e, "key", "")),
+            )
+            env_map_items = [
+                {k: v for k, v in asdict(e).items() if v is not None and v != "" and v != []}
+                for e in _sorted_env[:15]
+            ]
 
     code_notes_summary_dict: Any = None
+    code_notes_items: Any = None
     if sm.code_notes_summary is not None and sm.code_notes_summary.requested:
         code_notes_summary_dict = asdict(sm.code_notes_summary)
+        if sm.code_notes:
+            _SEVERITY_ORDER = {"BUG": 0, "FIXME": 1, "DEPRECATED": 2, "TODO": 3, "HACK": 4, "WARNING": 5}
+            _sorted_notes = sorted(
+                sm.code_notes,
+                key=lambda n: (_SEVERITY_ORDER.get(getattr(n, "kind", "").upper(), 9), getattr(n, "path", "")),
+            )
+            code_notes_items = [
+                {k: v for k, v in asdict(n).items() if v is not None}
+                for n in _sorted_notes[:20]
+            ]
 
     # Entry points: production runtime only. Auxiliary and development entries
     # are exposed separately so agents do not mix tooling with execution paths.
@@ -298,7 +388,9 @@ def compact_view(sm: SourceMap, *, no_tree: bool = False) -> dict[str, Any]:
         "dependency_summary": dep_summary_dict,
         "key_dependencies": key_deps,
         "env_summary": env_summary_dict,
+        "env_map": env_map_items,
         "code_notes_summary": code_notes_summary_dict,
+        "code_notes": code_notes_items,
         "confidence_summary": conf_dict,
         "anomalies": anomalies,
         "analysis_gaps": gaps_list,
@@ -682,11 +774,33 @@ def agent_view(sm: SourceMap) -> dict[str, Any]:
         }
         if sm.env_summary.categories:
             signals["env_vars"]["categories"] = sm.env_summary.categories
+        if sm.env_map:
+            _sorted_env = sorted(
+                sm.env_map,
+                key=lambda e: (not getattr(e, "required", False), getattr(e, "key", "")),
+            )
+            signals["env_vars"]["keys"] = [
+                {k: v for k, v in asdict(e).items() if v is not None and v != "" and v != []}
+                for e in _sorted_env[:10]
+            ]
 
     if sm.code_notes_summary and sm.code_notes_summary.requested and sm.code_notes_summary.total > 0:
         by_kind = {k: v for k, v in sm.code_notes_summary.by_kind.items() if v > 0}
+        _code_notes_signal: dict[str, Any] = {}
         if by_kind:
-            signals["code_notes"] = {"total": sm.code_notes_summary.total, "by_kind": by_kind}
+            _code_notes_signal = {"total": sm.code_notes_summary.total, "by_kind": by_kind}
+        if sm.code_notes:
+            _SEVERITY_ORDER = {"BUG": 0, "FIXME": 1, "DEPRECATED": 2, "TODO": 3, "HACK": 4, "WARNING": 5}
+            _sorted_notes = sorted(
+                sm.code_notes,
+                key=lambda n: (_SEVERITY_ORDER.get(getattr(n, "kind", "").upper(), 9), getattr(n, "path", "")),
+            )
+            _code_notes_signal["top"] = [
+                {k: v for k, v in asdict(n).items() if v is not None}
+                for n in _sorted_notes[:10]
+            ]
+        if _code_notes_signal:
+            signals["code_notes"] = _code_notes_signal
         if sm.code_notes_summary.adr_count > 0:
             signals["adrs"] = sm.code_notes_summary.adr_count
 
@@ -849,7 +963,7 @@ def standard_view(sm: SourceMap, *, include_tree: bool = False) -> dict[str, Any
 
     if sm.metrics_summary is not None and sm.metrics_summary.requested:
         result["metrics_summary"] = asdict(sm.metrics_summary)
-        result["file_metrics"] = [asdict(m) for m in sm.file_metrics]
+        result["file_metrics"] = [_serialize_file_metric(m) for m in sm.file_metrics]
 
     if sm.architecture is not None and sm.architecture.requested:
         result["architecture"] = asdict(sm.architecture)
@@ -1131,6 +1245,12 @@ def _serialize_contract_minimal(c: Any) -> dict[str, Any]:
     if c.hooks_used:
         item["hooks"] = c.hooks_used
 
+    # Ranking signals: why this file was ranked here
+    if getattr(c, "ranking_reasons", None):
+        non_trivial = [r for r in c.ranking_reasons if r not in ("source file", "noise")]
+        if non_trivial:
+            item["why"] = non_trivial
+
     return item
 
 
@@ -1231,6 +1351,10 @@ def _contract_view_standard(
                 item["dependencies"] = c.dependencies
             if c.limitations:
                 item["limitations"] = c.limitations
+            if getattr(c, "ranking_reasons", None):
+                non_trivial = [r for r in c.ranking_reasons if r not in ("source file", "noise")]
+                if non_trivial:
+                    item["ranking_reasons"] = non_trivial
             item["method"] = c.extraction_method
             serialized.append(item)
         result["file_contracts"] = serialized

{sourcecode-0.38.0.dist-info → sourcecode-0.41.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 0.38.0
+Version: 0.41.0
 Summary: Deterministic codebase context for AI coding agents
 License:                                  Apache License
                                    Version 2.0, January 2004

{sourcecode-0.38.0.dist-info → sourcecode-0.41.0.dist-info}/RECORD

@@ -1,33 +1,34 @@
-sourcecode/__init__.py,sha256=RjrfBH06OIJiq-xk4Hadj8Zl3Soer5r1Ct1ogF0xqaU,103
+sourcecode/__init__.py,sha256=Z0LOxVp01ZH1jSUmGwFp1S832KRn_Hq6x3bcAaQ-10c,103
 sourcecode/adaptive_scanner.py,sha256=6dh34C2qZXyRbw-8xBhbEwDdXanM6CRFRWayVoYITnA,10190
 sourcecode/architecture_analyzer.py,sha256=H6noGgVArUJ25z1qC0fFA0KvJJeHZYyhKvKSkOyWHUk,23096
 sourcecode/architecture_summary.py,sha256=rSY5MRiaz4N1YdG0pqDTDuFjSN7PO_Zplx-dtNzv2Yo,19985
 sourcecode/ast_extractor.py,sha256=0OHQwTUBBc9lmqPLryVeB1z8dGIC6NhLlar800CD9oI,41129
 sourcecode/classifier.py,sha256=GKTMN8qKZX7ponSwDJfN08RrasI4CVpq1_gFBgEopps,7093
-sourcecode/cli.py,sha256=dJ0kkwC0pQ4LJyhjlbtHKSpD-TvRQQyhdhvjRCHPA8o,65280
+sourcecode/cli.py,sha256=BBAS66tCeNt48iZrykJZ-H0TpI3zmgrAs6P3H3NSIws,67589
 sourcecode/code_notes_analyzer.py,sha256=rRd8bFYV0krjlxxQV0wenwE9K7pVpUQSR7KvSvUQKw4,9226
 sourcecode/confidence_analyzer.py,sha256=HxJMPLI5ulqtkncnv98W4iVO6yMbpQo87VuxiuNbDmY,12167
 sourcecode/context_summarizer.py,sha256=CiQrfBEzun949bWvmLabWoj2HhPn6Lw62ofqnsy0FlQ,6503
-sourcecode/contract_model.py,sha256=vr-9WHf0EBlbnuZGtTpUvSnbbjCBsm0q0tpLyxBJ-xI,3287
-sourcecode/contract_pipeline.py,sha256=Pu9SjgkngLgWoFaNj2ftKsk4lPngophW4840h0FvuEw,23187
+sourcecode/contract_model.py,sha256=wpYNWGzHAVnyGxniGqNMk96TCmWbVVOqNSc3Kauajrg,3348
+sourcecode/contract_pipeline.py,sha256=m2xPFLYWkTRvEv9L7iV9gqE0JRDxYhnx_IcQNo5P9es,22793
 sourcecode/coverage_parser.py,sha256=q0LeZJaX1bnntLu-ImksdBsMlpsVmk_iUfSaB4eaJGo,19702
 sourcecode/dependency_analyzer.py,sha256=Exq0BfInvfS5iAg9xAr6WI2uPNuotkIudTKcYJcRhB8,52757
-sourcecode/doc_analyzer.py,sha256=Ec3orx6vBKsh5cNM3-F4y2Got2KuKx8w3dErwtdtM-A,19891
+sourcecode/doc_analyzer.py,sha256=KLQ8g5cFTLEnZfH2xh7Z1t936oS6N6fP5L6YplhbtzM,20182
 sourcecode/entrypoint_classifier.py,sha256=a69dMGyxCTd_LOm3oqj-EXWpRmbmeujN7T1mr2eJ1as,3877
 sourcecode/env_analyzer.py,sha256=slvq-eT24RVMNczLNDlZbe0hU8JXIIPxybqubvrrnSQ,14409
 sourcecode/file_classifier.py,sha256=_KfFIIolharaIxbSTrCkaWauQIqNHCyor_n47RGyDh8,8577
-sourcecode/git_analyzer.py,sha256=s7tJTd_GAczhrH7j9JhBNp7ozhkW3lzBN0TMNwFqJwE,9977
+sourcecode/git_analyzer.py,sha256=khF1AOT8dL5RP9d_tDqDpE8FXEvCa6Ns14L4BXjFcs0,11179
 sourcecode/graph_analyzer.py,sha256=hMOsLLz9B0UnQ4xwbHdgr3bFvqpw0bQ8kN-xmEn3Krk,64156
 sourcecode/metrics_analyzer.py,sha256=e2cFwB9XubFq_dIVsP2PLjpr4wX0N6ulb3ol3sGDUeo,20777
-sourcecode/prepare_context.py,sha256=vxEzr8czS3MFbdTx4hBJQlJLrl9cuvbHdL3ZokxFkvo,31384
+sourcecode/prepare_context.py,sha256=zYRcRFc9OXN_V-3eKcVmA6wwO9A8uhUjM2cqkkp1dV0,30892
+sourcecode/ranking_engine.py,sha256=XdhzahKGleYNW3N0GqGW9salPOXx2BNp8KqXpaeHHmw,8247
 sourcecode/redactor.py,sha256=xuGcadGEHaPw4qZXlMDvzMCsr4VOkdp3oBQptHyJk8c,2884
-sourcecode/relevance_scorer.py,sha256=ea7_7AHVgahVEWK3ebKOpG67agzG_pGICu5f2KgzrIA,8133
+sourcecode/relevance_scorer.py,sha256=E74w7nlsNVobO3LqKHiMtBd84ONwGp8uDpwXJEjRtLA,8330
 sourcecode/repo_classifier.py,sha256=FG1vaWKdWXsWdl-S8hjVMiTqcwgaRXkDyvK4rPcOGtQ,22681
 sourcecode/runtime_classifier.py,sha256=zWX3r3HCKHc-qtIobErOa8aKMmaoPYREtJKvPcBGPjQ,14792
 sourcecode/scanner.py,sha256=aM3h9-DCQ3xKpeHpHYdo2vX6T5P95HA_YwZbkAVNwmo,8288
 sourcecode/schema.py,sha256=dVA-3EbHBakHLkgeZF-LfjKClEFRgPZkzblXpDTshFA,20796
-sourcecode/semantic_analyzer.py,sha256=asQfJf-EhzYaOTA-iMuZsrVXtbW7SV2WEKCxgsxa88Y,79413
-sourcecode/serializer.py,sha256=qJRJV_z-T_wU615KMA1ez5IIeV3wcexh29lY4-fcgjs,51329
+sourcecode/semantic_analyzer.py,sha256=CBRRt92AFucf8vhKbly24132sM3EEIaZZpzFsUDpsUI,79617
+sourcecode/serializer.py,sha256=1wWmBUTY1SoRBedVnE4_mPEzEL8xYsoZ8hamvpQiTvc,56477
 sourcecode/summarizer.py,sha256=ZuzIdm3t8A-d5MuQL0TSNLrd-L0IQIuguIxeNXMNJf8,16070
 sourcecode/tree_utils.py,sha256=Fj9OIuUksBvgibNd3feog0sMDjVypJzPexp5lvMoYWI,1424
 sourcecode/workspace.py,sha256=fQlVoNx8S-fSHpKoJ0JBvEHCFkxszH0KZVJed1i3TRk,6845
@@ -58,8 +59,8 @@ sourcecode/telemetry/consent.py,sha256=wLMvGNJeSSyZoNkQXpoUioY6mMv4Qdvuw7S9jAEWn
 sourcecode/telemetry/events.py,sha256=oEvvulfsv5GIDWG2174gSS6tNB95w38AIYiYeifGKlE,2294
 sourcecode/telemetry/filters.py,sha256=Asa71oRl7q3Wt_FMwuufIZJFzSYdgRNKS8LHCIyFeYE,4805
 sourcecode/telemetry/transport.py,sha256=KJeIPCPWMdmbCP3ySGs2iUlia34U6vWne2dZsUezesw,1560
-sourcecode-0.38.0.dist-info/METADATA,sha256=-RJ8bdDTHeuGmWN-iNo4eYkjPTuSnfriYYD1O59Gmwc,25209
-sourcecode-0.38.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-0.38.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-0.38.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-0.38.0.dist-info/RECORD,,
+sourcecode-0.41.0.dist-info/METADATA,sha256=NinjVy-jlbAy-be1L-ejAtO5j7HiAZwi5B3C4CbOCqk,25209
+sourcecode-0.41.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-0.41.0.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-0.41.0.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-0.41.0.dist-info/RECORD,,