sourcecode 1.32.1__py3-none-any.whl → 1.32.2__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/cli.py

@@ -140,7 +140,21 @@ def _check_pipeline_coherence(sm: "SourceMap") -> list[str]:  # type: ignore[nam
 
     return issues
 
-_HELP = """\
+def _build_help_text() -> str:
+    """Build --help text dynamically based on current license state."""
+    try:
+        from sourcecode.license import is_pro as _is_pro
+    except Exception:
+        _is_pro = False
+
+    if _is_pro:
+        plan_badge = "[bold green]● Pro[/bold green]"
+    else:
+        plan_badge = "[yellow]Free[/yellow]  ·  [dim]sourcecode activate <key>[/dim] to unlock Pro"
+
+    text = f"""\
+[bold]sourcecode[/bold]  {plan_badge}
+
 Deterministic codebase context for AI coding agents.
 
 [bold]Primary usage:[/bold]
@@ -164,6 +178,26 @@ Deterministic codebase context for AI coding agents.
   version
 """
 
+    if not _is_pro:
+        text += """\
+
+[dim bold]Locked (Pro):[/dim bold]
+  [dim]impact                              blast radius before any change[/dim]
+  [dim]modernize (full)                    dead zones, tangles, full coupling[/dim]
+  [dim]fix-bug (full)                      complete risk-ranked file list[/dim]
+  [dim]review-pr (expanded)               CI-grade PR review[/dim]
+  [dim]prepare-context delta               incremental context for CI/CD[/dim]
+  [dim]prepare-context generate-tests      test gap analysis[/dim]
+  [dim]--full                              removes all truncation limits[/dim]
+
+  [dim cyan]→ sourcecode activate <key>[/dim cyan]
+"""
+
+    return text
+
+
+_HELP = _build_help_text()
+
 # Known subcommand names — tokens matching these are routed as subcommands,
 # not consumed as a repository path.
 _SUBCOMMANDS: frozenset[str] = frozenset(
@@ -344,6 +378,10 @@ def _get_command_with_preprocessing(typer_instance: Any) -> Any:
     cmd = _orig_get_command(typer_instance)
     if typer_instance is not app:
         return cmd  # only wrap the root app, not telemetry_app etc.
+
+    # Refresh help text at invocation time so it reflects current license state.
+    cmd.help = _build_help_text()
+
     _orig_cmd_main = cmd.main
 
     def _cmd_main(args: Optional[list[str]] = None, **kwargs: Any) -> Any:
@@ -2011,6 +2049,15 @@ def main(
         except Exception:
             pass  # non-fatal: cache write failure
 
+    # Update RIS with aggregated snapshot data (non-fatal side-effect).
+    if not no_cache and not _pipeline_error and _core_key:
+        try:
+            from sourcecode.serializer import core_view as _ris_core_view
+            from sourcecode.ris import maybe_update_ris as _ris_update
+            _ris_update(target, _ris_core_view(sm), _git_sha)
+        except Exception:
+            pass
+
     if _pipeline_error:
         raise typer.Exit(code=2)
 
@@ -3147,6 +3194,14 @@ def endpoints_cmd(
         raise typer.Exit(code=1)
 
     data = _extract_java_endpoints(target)
+
+    # Update RIS api_surface section (non-fatal side-effect).
+    try:
+        from sourcecode.ris import update_ris_api_surface as _ris_ep
+        _ris_ep(target, data)
+    except Exception:
+        pass
+
     output = _serialize_dict(data, format)
 
     if output_path is not None:

sourcecode/mcp/server.py

@@ -109,6 +109,42 @@ def _check_repo_path(path: str) -> "CallToolResult | None":
     return None
 
 
+@mcp.tool()
+def get_cold_start_context(repo_path: str = ".") -> dict:
+    """Instant session bootstrap from persisted Repository Intelligence Snapshot (RIS).
+
+    CALL THIS FIRST at the start of every MCP session.  Returns cached structural
+    context built from prior analysis runs — zero re-analysis cost.
+
+    status values:
+      "cold_start_ready"  — RIS exists and matches the current git HEAD.
+      "cold_start_stale"  — RIS exists but HEAD has changed since last analysis.
+                            Data is still useful; run get_compact_context to refresh.
+      "no_ris"            — No RIS yet for this repo; run get_compact_context first.
+
+    Returns: status, repo_id, git_head, stale (bool), last_updated_at,
+             summary (compact snapshot), entrypoints, endpoints, hotspots.
+
+    repo_path: absolute path to the repository (default: current working directory).
+    """
+    _raw = repo_path
+    try:
+        if not isinstance(repo_path, str):
+            return _err("repo_path must be a string", "INVALID_ARGUMENT")
+        repo_path = _normalize_repo_path(repo_path)
+        _path_err = _check_repo_path(repo_path)
+        if _path_err is not None:
+            return _path_err
+        from pathlib import Path as _Path
+        from sourcecode.ris import get_cold_start_context as _gcs
+        return _ok(_gcs(_Path(repo_path)))
+    except Exception as exc:
+        return _err(
+            f"Internal error: {type(exc).__name__}: {exc} — repo_path: {_raw}",
+            "INTERNAL_ERROR",
+        )
+
+
 @mcp.tool()
 def get_compact_context(repo_path: str = ".", git_context: bool = False) -> dict:
     """Compact human/LLM summary of a repository (~1000-3000 tokens). USE THIS FIRST.

sourcecode/ris.py

@@ -0,0 +1,372 @@
+"""Repository Intelligence Snapshot (RIS) — persistent repo-level semantic state.
+
+RIS aggregates outputs from per-commit L1/L2 snapshots into a single artifact
+that survives across git commits.  It enables cold-start bootstrapping for MCP
+sessions: on first tool call, agents receive structural context immediately
+without triggering re-analysis.
+
+Storage layout:
+    ~/.sourcecode/cache/<repo_id>/ris.json.gz
+
+Build lifecycle:
+    1. After every successful analysis run, ``maybe_update_ris`` is called with
+       the L1 core_dict (already in scope in cli.py after ``write_core``).
+    2. If the git HEAD matches the stored RIS → only compact/agent/git sections
+       are refreshed (the API surface from ``endpoints`` is preserved).
+    3. If the git HEAD changed → all sections are rebuilt from the new core_dict
+       (api_surface preserved if the caller does not provide updated endpoints).
+    4. ``get_cold_start_context`` reads the RIS and returns a lightweight
+       bootstrap object.  It is safe to call from MCP on every session init.
+
+RIS is NOT a command cache.  It stores a semantic model of the repository
+derived from existing snapshot outputs, not raw command results.
+"""
+from __future__ import annotations
+
+import gzip
+import json
+import subprocess
+from dataclasses import asdict, dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+RIS_SCHEMA_VERSION: str = "1.0"
+_RIS_FILENAME: str = "ris.json.gz"
+
+
+# ---------------------------------------------------------------------------
+# Schema
+# ---------------------------------------------------------------------------
+
+@dataclass
+class RepositoryIntelligenceSnapshot:
+    repo_id: str
+    created_at: str
+    last_updated_at: str
+    git_head: str
+    version: str
+    structural_map: dict
+    api_surface: dict
+    dependency_graph: dict
+    compact_summary: dict
+    agent_index: dict
+    git_context_snapshot: dict
+    metadata: dict
+
+
+# ---------------------------------------------------------------------------
+# Storage helpers
+# ---------------------------------------------------------------------------
+
+def _ris_path(repo_root: Path) -> Path:
+    from sourcecode.cache import cache_dir as _cache_dir
+    return _cache_dir(repo_root) / _RIS_FILENAME
+
+
+def load_ris(repo_root: Path) -> Optional[RepositoryIntelligenceSnapshot]:
+    """Load RIS from disk.  Returns None on any error (missing, corrupt, stale schema)."""
+    try:
+        p = _ris_path(repo_root)
+        if not p.exists():
+            return None
+        raw = gzip.decompress(p.read_bytes())
+        d = json.loads(raw)
+        if not isinstance(d, dict) or d.get("version") != RIS_SCHEMA_VERSION:
+            return None
+        return RepositoryIntelligenceSnapshot(
+            repo_id=d.get("repo_id", ""),
+            created_at=d.get("created_at", ""),
+            last_updated_at=d.get("last_updated_at", ""),
+            git_head=d.get("git_head", ""),
+            version=d.get("version", ""),
+            structural_map=d.get("structural_map", {}),
+            api_surface=d.get("api_surface", {}),
+            dependency_graph=d.get("dependency_graph", {}),
+            compact_summary=d.get("compact_summary", {}),
+            agent_index=d.get("agent_index", {}),
+            git_context_snapshot=d.get("git_context_snapshot", {}),
+            metadata=d.get("metadata", {}),
+        )
+    except Exception:
+        return None
+
+
+def save_ris(repo_root: Path, ris: RepositoryIntelligenceSnapshot) -> None:
+    """Write RIS to disk as gzip-compressed JSON.  Never raises."""
+    try:
+        p = _ris_path(repo_root)
+        p.parent.mkdir(parents=True, exist_ok=True)
+        raw = json.dumps(asdict(ris), ensure_ascii=False, separators=(",", ":"))
+        p.write_bytes(gzip.compress(raw.encode("utf-8"), compresslevel=6))
+    except Exception:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Data extraction from L1 core_dict
+# ---------------------------------------------------------------------------
+
+def _extract_structural_map(agent_data: dict) -> dict:
+    """Extract structural map from agent_view output."""
+    entry_points = agent_data.get("entry_points", [])
+
+    layers = []
+    domains = []
+    arch = agent_data.get("architecture")
+    if isinstance(arch, dict):
+        layers = arch.get("layers") or []
+        domains = arch.get("domains") or []
+
+    controllers: list = []
+    services: list = []
+    for layer in layers:
+        if not isinstance(layer, dict):
+            continue
+        name = (layer.get("name") or "").lower()
+        files = layer.get("files") or []
+        if any(kw in name for kw in ("controller", "rest", "api", "endpoint")):
+            controllers.extend(files)
+        elif any(kw in name for kw in ("service", "business", "domain", "use_case")):
+            services.extend(files)
+
+    return {
+        "entrypoints": entry_points,
+        "controllers": controllers,
+        "services": services,
+        "modules": domains,
+    }
+
+
+def _extract_api_surface(agent_data: dict) -> dict:
+    """Extract API surface from agent_view output (Java security surface if present)."""
+    endpoints: list = []
+    controllers_index: list = []
+
+    signals = agent_data.get("signals") or {}
+    sec = signals.get("security_surface") or {}
+    if isinstance(sec, dict):
+        raw_endpoints = sec.get("endpoints") or []
+        if isinstance(raw_endpoints, list):
+            endpoints = raw_endpoints
+        controllers_index = sec.get("controllers") or []
+
+    return {
+        "endpoints": endpoints,
+        "controllers_index": controllers_index,
+    }
+
+
+def _extract_dependency_graph(compact_data: dict, agent_data: dict) -> dict:
+    """Extract dependency graph summary from view outputs."""
+    nodes = agent_data.get("key_dependencies") or compact_data.get("key_dependencies") or []
+    summary = compact_data.get("dependency_summary") or {}
+
+    return {
+        "nodes": nodes,
+        "edges": [],
+        "summary": summary,
+    }
+
+
+def _extract_git_context_snapshot(agent_data: dict) -> dict:
+    """Extract git context from agent_view output."""
+    gc = agent_data.get("git_context") or {}
+    if not isinstance(gc, dict):
+        return {"last_commits": [], "hotspots": []}
+    return {
+        "last_commits": gc.get("recent_commits") or [],
+        "hotspots": gc.get("top_hotspots") or [],
+    }
+
+
+# ---------------------------------------------------------------------------
+# Build / update
+# ---------------------------------------------------------------------------
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _build_from_core(
+    repo_root: Path,
+    core_dict: dict,
+    git_head: str,
+    existing_api_surface: Optional[dict] = None,
+) -> RepositoryIntelligenceSnapshot:
+    from sourcecode.cache import repo_id as _repo_id_fn
+
+    compact_data = core_dict.get("_compact") or {}
+    agent_data = core_dict.get("_agent") or {}
+
+    # Strip file_relevance — large and not needed for cold-start
+    agent_index = {k: v for k, v in agent_data.items() if k != "file_relevance"}
+
+    now = _now_iso()
+    return RepositoryIntelligenceSnapshot(
+        repo_id=_repo_id_fn(repo_root),
+        created_at=now,
+        last_updated_at=now,
+        git_head=git_head,
+        version=RIS_SCHEMA_VERSION,
+        structural_map=_extract_structural_map(agent_data),
+        api_surface=existing_api_surface or _extract_api_surface(agent_data),
+        dependency_graph=_extract_dependency_graph(compact_data, agent_data),
+        compact_summary=compact_data,
+        agent_index=agent_index,
+        git_context_snapshot=_extract_git_context_snapshot(agent_data),
+        metadata={
+            "snapshot_source": "existing_snapshot_system",
+            "confidence": float(
+                1.0 if agent_data else (0.5 if compact_data else 0.0)
+            ),
+            "partial": not bool(agent_data),
+        },
+    )
+
+
+def maybe_update_ris(repo_root: Path, core_dict: dict, git_head: str) -> None:
+    """Update (or create) the RIS artifact from an L1 core_dict.
+
+    Called from cli.py after every successful write_core.  Never raises.
+    """
+    try:
+        if not isinstance(core_dict, dict):
+            return
+
+        existing = load_ris(repo_root)
+
+        if existing is not None and existing.git_head == git_head and git_head:
+            # Same commit — refresh analysis sections, preserve api_surface
+            compact_data = core_dict.get("_compact") or {}
+            agent_data = core_dict.get("_agent") or {}
+            agent_index = {k: v for k, v in agent_data.items() if k != "file_relevance"}
+
+            updated = RepositoryIntelligenceSnapshot(
+                repo_id=existing.repo_id,
+                created_at=existing.created_at,
+                last_updated_at=_now_iso(),
+                git_head=git_head,
+                version=RIS_SCHEMA_VERSION,
+                structural_map=_extract_structural_map(agent_data) if agent_data else existing.structural_map,
+                api_surface=existing.api_surface,  # preserve explicit endpoint data
+                dependency_graph=_extract_dependency_graph(compact_data, agent_data) if compact_data else existing.dependency_graph,
+                compact_summary=compact_data if compact_data else existing.compact_summary,
+                agent_index=agent_index if agent_index else existing.agent_index,
+                git_context_snapshot=_extract_git_context_snapshot(agent_data) if agent_data else existing.git_context_snapshot,
+                metadata={
+                    "snapshot_source": "existing_snapshot_system",
+                    "confidence": float(1.0 if agent_data else (0.5 if compact_data else 0.0)),
+                    "partial": not bool(agent_data),
+                },
+            )
+            save_ris(repo_root, updated)
+        else:
+            # New commit or first build — rebuild all sections (preserve api_surface if available)
+            existing_api = existing.api_surface if existing is not None else None
+            ris = _build_from_core(repo_root, core_dict, git_head, existing_api_surface=existing_api)
+            if existing is not None:
+                # Preserve creation timestamp
+                ris = RepositoryIntelligenceSnapshot(
+                    **{**asdict(ris), "created_at": existing.created_at}
+                )
+            save_ris(repo_root, ris)
+    except Exception:
+        pass
+
+
+def update_ris_api_surface(repo_root: Path, endpoints_data: dict) -> None:
+    """Update the api_surface section from an ``endpoints`` command output.
+
+    Called from endpoints_cmd after _extract_java_endpoints().  Never raises.
+    """
+    try:
+        if not isinstance(endpoints_data, dict):
+            return
+        endpoints = endpoints_data.get("endpoints") or []
+        existing = load_ris(repo_root)
+        if existing is None:
+            # No RIS yet — create a minimal stub so api_surface is persisted
+            from sourcecode.cache import repo_id as _repo_id_fn
+            now = _now_iso()
+            existing = RepositoryIntelligenceSnapshot(
+                repo_id=_repo_id_fn(repo_root),
+                created_at=now,
+                last_updated_at=now,
+                git_head="",
+                version=RIS_SCHEMA_VERSION,
+                structural_map={},
+                api_surface={},
+                dependency_graph={},
+                compact_summary={},
+                agent_index={},
+                git_context_snapshot={},
+                metadata={"snapshot_source": "existing_snapshot_system", "confidence": 0.0, "partial": True},
+            )
+
+        # Build controllers_index from endpoint controller fields
+        ctrl_set: set[str] = set()
+        for ep in endpoints:
+            if isinstance(ep, dict):
+                ctrl = ep.get("controller") or ep.get("controller_class") or ""
+                if ctrl:
+                    ctrl_set.add(ctrl)
+
+        updated_api = {
+            "endpoints": endpoints,
+            "controllers_index": sorted(ctrl_set),
+        }
+        updated = RepositoryIntelligenceSnapshot(
+            **{**asdict(existing), "api_surface": updated_api, "last_updated_at": _now_iso()}
+        )
+        save_ris(repo_root, updated)
+    except Exception:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Cold-start context
+# ---------------------------------------------------------------------------
+
+def _current_git_head(repo_root: Path) -> str:
+    """Return current HEAD SHA.  Returns '' on any error or non-git directory."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", str(repo_root), "rev-parse", "HEAD"],
+            capture_output=True,
+            text=True,
+            timeout=2,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except Exception:
+        pass
+    return ""
+
+
+def get_cold_start_context(repo_root: Path) -> dict:
+    """Return a lightweight bootstrap object from the persisted RIS.
+
+    Never raises.  Returns ``{"status": "no_ris"}`` when no RIS exists.
+    """
+    try:
+        ris = load_ris(repo_root)
+        if ris is None:
+            return {"status": "no_ris"}
+
+        current_head = _current_git_head(repo_root)
+        stale = bool(current_head and ris.git_head and current_head != ris.git_head)
+
+        return {
+            "status": "cold_start_stale" if stale else "cold_start_ready",
+            "repo_id": ris.repo_id,
+            "git_head": ris.git_head,
+            "stale": stale,
+            "last_updated_at": ris.last_updated_at,
+            "summary": ris.compact_summary,
+            "entrypoints": ris.structural_map.get("entrypoints", []),
+            "endpoints": ris.api_surface.get("endpoints", []),
+            "hotspots": ris.git_context_snapshot.get("hotspots", []),
+        }
+    except Exception:
+        return {"status": "no_ris"}

{sourcecode-1.32.1.dist-info → sourcecode-1.32.2.dist-info}/METADATA

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

{sourcecode-1.32.1.dist-info → sourcecode-1.32.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sourcecode/__init__.py,sha256=fI8Cp1YcT6ueuKNKvHveO2gFDtDkSHrDE6DpgADO1i8,103
+sourcecode/__init__.py,sha256=tfPDIqlBjWLMfih5Bz8aKlWeo9EJQJnFkI8wjOakF7w,103
 sourcecode/adaptive_scanner.py,sha256=XffluXKzJUXrMtjEiAOnSNPZnztdIcts17T9ouHeID0,10521
 sourcecode/architecture_analyzer.py,sha256=qh749a7ykPtGmQI1MR9y6j8TtL_jBdVYFx9YRsLqOMw,44121
 sourcecode/architecture_summary.py,sha256=z34_6v7cSwy98cof2UVciGho7SCrZ93tiqMmq5WNzRQ,20405
@@ -6,7 +6,7 @@ sourcecode/ast_extractor.py,sha256=_btmeOJIe3t-NicF94D5ZAesa2YIJ0_QNExGnbHxGFE,5
 sourcecode/cache.py,sha256=pBrPdpPrOgpXHHQO670U3aUfVf5N3A3obsTKgiZtN4I,23030
 sourcecode/canonical_ir.py,sha256=_HM3AUmKSdna9u4dCoU6rpgSA6HdF8gzOKZykIUCNGY,23277
 sourcecode/classifier.py,sha256=2lYoSH3vOTkXZYPU7Go2WIet1-IuNzTWVhc-ULnXtgw,8024
-sourcecode/cli.py,sha256=xV3CKxTAzc1tcEJ6-lfGCuYlBWdLQgxv1-thMzQ3cpk,163863
+sourcecode/cli.py,sha256=l3PJ9pK6JQ_JUxYSD3xnpvCIvR9kvOvbEEvHvqfij9A,165743
 sourcecode/code_notes_analyzer.py,sha256=EJemNCNc9Dn-1RZYu-aNbK0ELzmsyC4s6FdHi3XyNEI,9392
 sourcecode/confidence_analyzer.py,sha256=_jckZSxksV-OU38vbkxfVNBnWCtlCq8Vwfg23x1uspA,19054
 sourcecode/context_scorer.py,sha256=QpChSpsmaAYz91rXA4Ue5xzQmNz_ZboZN09YOHScq1U,14679
@@ -35,6 +35,7 @@ sourcecode/redactor.py,sha256=SB4hwIvg8h-hvcqKcDWaZvA-aSyn-at-BIRwa0tUv5E,3227
 sourcecode/relevance_scorer.py,sha256=MYF4FFkveAQps9SmTeTlh6ODiBz2F--_hWNeHMLtUHQ,8405
 sourcecode/repo_classifier.py,sha256=FG1vaWKdWXsWdl-S8hjVMiTqcwgaRXkDyvK4rPcOGtQ,22681
 sourcecode/repository_ir.py,sha256=-NjBQUT7zyya4ng8Hq0-ChoiHZkUif9lr-Q878gmj8M,153163
+sourcecode/ris.py,sha256=iy1O04SiQ3cFIK5Qn8iHt3fZTiXIgbXvWkjbBG0fTBo,14000
 sourcecode/runtime_classifier.py,sha256=uTAD6BDCiBLUZEDRfqk718kM4RTT_vAbfkcOI2_Xx58,18432
 sourcecode/scanner.py,sha256=WdOQ78mMzjR1NjmKTlbxdgwinnCTfAhxCVLBEFQiFHU,8899
 sourcecode/schema.py,sha256=aHNXDf8LGyUC8ZDE_VS9kiskC2-Oswhi_WnpdGy6HDw,24897
@@ -66,7 +67,7 @@ sourcecode/detectors/terraform.py,sha256=cxORPR_zVLOJpHlh4e9JnFpkQsn_UnqMMom5yG6
 sourcecode/detectors/tooling.py,sha256=8CKbtxwQoABP-WyBRNmdAmHDOvAH57AR1cF4UKuWEdQ,2074
 sourcecode/mcp/__init__.py,sha256=XU4HfRGbdid8wdUA0x_4f7uKZD1z3mv_XUY_WU_T9Mw,179
 sourcecode/mcp/runner.py,sha256=YSw2DXEICau6mCBr3Gfia3D_tKxMbRvIIXEh4cHC1SY,1390
-sourcecode/mcp/server.py,sha256=zbc4G5j2VAlVnluAksoSk6zV_wwgDevaH5Q4oVsl2kA,24018
+sourcecode/mcp/server.py,sha256=jUCDNjJKUIhse52M8-Lp63CDxlm21xOYUOVlv3z6_uk,25556
 sourcecode/mcp/onboarding/__init__.py,sha256=sj2PWqEBmMc4zBNkomg89WtL0M6S7A9yb7_wAuSWNP4,66
 sourcecode/mcp/onboarding/applier.py,sha256=B9CneieWTpaDSDIyW3S5nrlRlBpvfqUcgi93-mm_ApQ,2135
 sourcecode/mcp/onboarding/backup.py,sha256=ihqGOR8QTX8HASRSEDyfFyXr5bkXrygPHamv4p9KTmk,1452
@@ -78,8 +79,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-1.32.1.dist-info/METADATA,sha256=llWp2sPfqGuDQXERl94vF19Sxpktl_zPUyDNDwT4ORM,31100
-sourcecode-1.32.1.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-1.32.1.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-1.32.1.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-1.32.1.dist-info/RECORD,,
+sourcecode-1.32.2.dist-info/METADATA,sha256=PwMFojaNy2nH80htoS7Q_-p-AQ2GSwiTr49Mv8EGXJE,31100
+sourcecode-1.32.2.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-1.32.2.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-1.32.2.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-1.32.2.dist-info/RECORD,,