sourcecode 1.32.3__py3-none-any.whl → 1.32.4__py3-none-any.whl

sourcecode/__init__.py

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

sourcecode/cache.py

@@ -92,6 +92,8 @@ _CAS_FIELDS: frozenset[str] = frozenset([
 _CAS_THRESHOLD: int = 4096
 
 _DEFAULT_KEEP_COMMITS: int = 5
+_DEFAULT_MAX_CORES: int = 20
+_DEFAULT_MAX_SIZE_MB: int = 50
 
 # Matches "snapshot-<hex_commit>-<hex_flags>.json.gz"
 _SNAPSHOT_RE = re.compile(r"^snapshot-([0-9a-f]+)-[0-9a-f]+\.json\.gz$")
@@ -124,6 +126,58 @@ def cache_dir(repo_root: Path) -> Path:
     return base / repo_id(repo_root)
 
 
+# ---------------------------------------------------------------------------
+# Public API — observability
+# ---------------------------------------------------------------------------
+
+def status(repo_root: Path) -> dict[str, Any]:
+    """Return a stats dict describing the current cache state for *repo_root*.
+
+    Keys: ``cache_dir``, ``cores``, ``snapshots``, ``views``, ``cas_blobs``,
+    ``total_size_bytes``, ``total_size_mb``.
+    """
+    cache_d = cache_dir(repo_root)
+    if not cache_d.exists():
+        return {
+            "cache_dir": str(cache_d),
+            "cores": 0, "snapshots": 0, "views": 0, "cas_blobs": 0,
+            "total_size_bytes": 0, "total_size_mb": 0.0,
+        }
+    cores = list(cache_d.glob("core-*.json.gz"))
+    snapshots = list(cache_d.glob("snapshot-*.json.gz"))
+    views = list(cache_d.glob("view-*.json.gz"))
+    cas_blobs = list((_cas_dir(cache_d)).glob("*.gz")) if _cas_dir(cache_d).exists() else []
+    all_files = cores + snapshots + views + cas_blobs
+    total_bytes = sum(f.stat().st_size for f in all_files if f.exists())
+    return {
+        "cache_dir": str(cache_d),
+        "cores": len(cores),
+        "snapshots": len(snapshots),
+        "views": len(views),
+        "cas_blobs": len(cas_blobs),
+        "total_size_bytes": total_bytes,
+        "total_size_mb": round(total_bytes / (1024 * 1024), 2),
+    }
+
+
+def clear(repo_root: Path) -> int:
+    """Delete all cache files for *repo_root*.  Returns the number of files removed."""
+    cache_d = cache_dir(repo_root)
+    if not cache_d.exists():
+        return 0
+    removed = 0
+    for pattern in ("core-*.json.gz", "snapshot-*.json.gz", "view-*.json.gz"):
+        for f in cache_d.glob(pattern):
+            _safe_unlink(f)
+            removed += 1
+    cas_d = _cas_dir(cache_d)
+    if cas_d.exists():
+        for f in cas_d.glob("*.gz"):
+            _safe_unlink(f)
+            removed += 1
+    return removed
+
+
 # ---------------------------------------------------------------------------
 # Public API — read / write
 # ---------------------------------------------------------------------------
@@ -193,7 +247,7 @@ def write(
     try:
         cache_d.mkdir(parents=True, exist_ok=True)
         payload = _build_envelope(cache_key, content, fmt, layers or {}, cache_d)
-        dest.write_bytes(payload)
+        _atomic_write(dest, payload)
     except Exception:
         return  # non-fatal
 
@@ -275,7 +329,7 @@ def write_core(repo_root: Path, core_key: str, core_data: dict[str, Any]) -> str
             json.dumps(envelope, ensure_ascii=False).encode("utf-8"),
             compresslevel=6,
         )
-        dest.write_bytes(payload)
+        _atomic_write(dest, payload)
     except Exception:
         pass
 
@@ -327,7 +381,7 @@ def write_view(
     try:
         cache_d.mkdir(parents=True, exist_ok=True)
         payload = _build_envelope(view_key, content, fmt, layers or {}, cache_d)
-        dest.write_bytes(payload)
+        _atomic_write(dest, payload)
     except Exception:
         pass
 
@@ -529,12 +583,16 @@ def _cas_restore(
 def _gc(cache_d: Path) -> None:
     """Evict old snapshots/cores/views and sweep orphaned CAS blobs.
 
-    Keeps snapshots and cores from the last ``SOURCECODE_CACHE_KEEP_COMMITS``
-    distinct git commits (determined by newest mtime within each commit group).
-    Views are then pruned: a view survives only when its core-hash prefix
-    matches a core file in the surviving set.
+    Three eviction passes (all non-fatal):
+    1. Commit-based: keep only last SOURCECODE_CACHE_KEEP_COMMITS distinct SHAs.
+    2. Core-count: keep at most SOURCECODE_CACHE_MAX_CORES core files (LRU).
+    3. Size-based: if total cache exceeds SOURCECODE_CACHE_MAX_SIZE_MB, evict
+       oldest core+snapshot files until under budget.
+    Views and CAS blobs are swept after each pass.
     """
     keep = int(os.environ.get("SOURCECODE_CACHE_KEEP_COMMITS", _DEFAULT_KEEP_COMMITS))
+    max_cores = int(os.environ.get("SOURCECODE_CACHE_MAX_CORES", _DEFAULT_MAX_CORES))
+    max_size_bytes = int(os.environ.get("SOURCECODE_CACHE_MAX_SIZE_MB", _DEFAULT_MAX_SIZE_MB)) * 1024 * 1024
 
     try:
         all_snapshots = list(cache_d.glob("snapshot-*.json.gz"))
@@ -544,7 +602,7 @@ def _gc(cache_d: Path) -> None:
         if not all_snapshots and not all_cores and not all_views:
             return
 
-        # Group snapshot + core files by commit SHA
+        # ── Pass 1: commit-based eviction ──────────────────────────────────
         groups: dict[str, list[Path]] = {}
         for f in all_snapshots:
             m = _SNAPSHOT_RE.match(f.name)
@@ -558,7 +616,6 @@ def _gc(cache_d: Path) -> None:
         surviving: list[Path]
 
         if keep <= 0 or len(groups) <= keep:
-            # No eviction needed — but still sweep views + CAS
             surviving = all_snapshots + all_cores
         else:
             def _newest_mtime(commit: str) -> float:
@@ -573,7 +630,33 @@ def _gc(cache_d: Path) -> None:
                     for f in groups[commit]:
                         _safe_unlink(f)
 
+        # ── Pass 2: per-repo core count cap ────────────────────────────────
+        if max_cores > 0:
+            surviving_cores = [p for p in surviving if p.name.startswith("core-") and p.exists()]
+            if len(surviving_cores) > max_cores:
+                surviving_cores.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+                for evict in surviving_cores[max_cores:]:
+                    _safe_unlink(evict)
+                    surviving = [p for p in surviving if p != evict]
+
+        # ── Pass 3: total size cap ──────────────────────────────────────────
+        if max_size_bytes > 0:
+            size_candidates = [p for p in surviving if p.exists()]
+            total = sum(p.stat().st_size for p in size_candidates if not p.name.startswith("view-"))
+            if total > max_size_bytes:
+                # Sort oldest-first; evict core+snapshot files until under budget
+                size_candidates.sort(key=lambda p: p.stat().st_mtime)
+                for evict in size_candidates:
+                    if evict.name.startswith("view-"):
+                        continue
+                    total -= evict.stat().st_size if evict.exists() else 0
+                    _safe_unlink(evict)
+                    surviving = [p for p in surviving if p != evict]
+                    if total <= max_size_bytes:
+                        break
+
         # Prune view files whose core hash is no longer in the surviving set
+        all_views = list(cache_d.glob("view-*.json.gz"))
         _gc_views(cache_d, surviving, all_views)
 
         # Sweep orphaned CAS blobs (surviving snapshots + view files may ref them)
@@ -648,6 +731,23 @@ def _gc_cas(cache_d: Path, surviving_snapshots: list[Path]) -> None:
 # Utilities
 # ---------------------------------------------------------------------------
 
+def _atomic_write(dest: Path, data: bytes) -> None:
+    """Write *data* to *dest* atomically via a sibling .tmp file + rename.
+
+    On POSIX, ``Path.replace()`` is a single ``rename(2)`` syscall — the
+    destination either has the old content or the new content, never a partial
+    write.  The .tmp suffix keeps the partial file out of glob patterns used
+    by the cache reader and GC.
+    """
+    tmp = dest.with_suffix(".tmp")
+    try:
+        tmp.write_bytes(data)
+        tmp.replace(dest)
+    except Exception:
+        _safe_unlink(tmp)
+        raise
+
+
 def _safe_unlink(path: Path) -> None:
     try:
         path.unlink(missing_ok=True)

sourcecode/cache.tmp_new

@@ -0,0 +1,772 @@
+"""
+Snapshot cache manager for sourcecode — v2.
+
+Cache layout
+------------
+    ~/.sourcecode/cache/<repo_id>/
+        snapshot-<git_sha>-<flags_hash>.json.gz   ← versioned envelope
+        core-<git_sha>-<flags_hash>.json.gz        ← L1 core analysis
+        view-<core_hash16>-<view_flags_hash>.json.gz  ← L2 derived view
+        cas/
+            <blob_hash16>.gz                       ← content-addressed blobs
+
+Schema
+------
+Every snapshot file is a gzip-compressed JSON *envelope*:
+
+    {
+      "sv":     "2",                       // schema version — bump to invalidate all
+      "key":    "abc1234-aabbccdd",        // cache key (git_sha + flags_hash)
+      "ts":     "2026-05-24T22:00:00Z",   // write timestamp (ISO-8601 UTC)
+      "fmt":    "json",                    // output format: "json" | "yaml"
+      "layers": {"heuristic": "...", ...}, // analyzer fingerprints at write time
+      // ── content (one of two forms) ──────────────────────────────────────
+      "snap":   {...},                     // inline fields (small) — JSON mode
+      "cas":    {"file_paths": "<h16>",…}  // large fields deduped into CAS store
+      // — OR —
+      "raw":    "<content string>"         // YAML or unparseable JSON stored as-is
+    }
+
+Content-addressed store (CAS)
+-----------------------------
+Large top-level JSON fields (> _CAS_THRESHOLD bytes) are extracted into the
+``cas/`` directory as individual gzip-compressed blobs identified by a 16-char
+SHA-256 hash of their uncompressed bytes.  Two snapshots that share an
+identical ``file_paths`` array reference the *same* blob — zero duplication.
+
+Eviction / GC
+-------------
+After each write, ``_gc()`` keeps snapshots from the last
+``SOURCECODE_CACHE_KEEP_COMMITS`` distinct git commits (default 5, override via
+env var).  A CAS sweep runs concurrently: blobs unreferenced by any surviving
+snapshot are deleted.
+
+Backward compatibility
+----------------------
+v1 files (raw gzip'd content, no envelope) are detected by the absence of an
+``sv`` key in the decompressed JSON, and served transparently.  Legacy files
+in ``<repo>/.sourcecode-cache/`` are also checked as a final fallback.
+
+Env vars
+--------
+  SOURCECODE_CACHE_DIR          Override global cache base (default: ~/.sourcecode/cache)
+  SOURCECODE_CACHE_KEEP_COMMITS How many git commits to retain (default: 5; 0 = unlimited)
+  SOURCECODE_CACHE_MAX_CORES    Max L1 core files to retain (default: 20; 0 = unlimited)
+  SOURCECODE_CACHE_MAX_SIZE_MB  Max total cache size in MB (default: 50; 0 = unlimited)
+"""
+from __future__ import annotations
+
+import gzip
+import hashlib
+import json
+import os
+import re
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+
+# ---------------------------------------------------------------------------
+# Version / constants
+# ---------------------------------------------------------------------------
+
+#: Bump this string to invalidate *all* existing cached snapshots.
+SCHEMA_VERSION: str = "2"
+
+#: Bump to invalidate all L1 core caches (independent of snapshot version).
+CORE_SCHEMA_VERSION: str = "1"
+
+#: Fields eligible for CAS deduplication (applied to top-level JSON dict keys).
+_CAS_FIELDS: frozenset[str] = frozenset([
+    "file_paths",
+    "entry_points",
+    "docs",
+    "dependencies",
+    "graph",
+    "semantic_calls",
+    "semantic_symbols",
+    "architecture",
+    "metrics",
+    "git_history",
+    "env_map",
+    "code_notes",
+])
+
+#: Serialised size threshold (bytes) above which a field is moved to CAS.
+_CAS_THRESHOLD: int = 4096
+
+_DEFAULT_KEEP_COMMITS: int = 5
+_DEFAULT_MAX_CORES: int = 20
+_DEFAULT_MAX_SIZE_MB: int = 50
+
+# Matches "snapshot-<hex_commit>-<hex_flags>.json.gz"
+_SNAPSHOT_RE = re.compile(r"^snapshot-([0-9a-f]+)-[0-9a-f]+\.json\.gz$")
+
+# Matches "core-<hex_commit>-<hex_analysis>.json.gz"
+_CORE_RE = re.compile(r"^core-([0-9a-f]+)-[0-9a-f]+\.json\.gz$")
+
+# Matches "view-<hex_core_hash16>-<hex_view_flags>.json.gz"
+_VIEW_RE = re.compile(r"^view-([0-9a-f]{16})-[0-9a-f]+\.json\.gz$")
+
+
+# ---------------------------------------------------------------------------
+# Public API — location helpers
+# ---------------------------------------------------------------------------
+
+
+def repo_id(repo_root: Path) -> str:
+    """Stable 16-char hex identifier derived from the canonical repo path."""
+    return hashlib.sha256(str(repo_root.resolve()).encode()).hexdigest()[:16]
+
+
+def cache_dir(repo_root: Path) -> Path:
+    """
+    Return the per-repo cache directory (``~/.sourcecode/cache/<repo_id>/``).
+
+    Override the base via ``SOURCECODE_CACHE_DIR``.
+    """
+    env_base = os.environ.get("SOURCECODE_CACHE_DIR", "")
+    base: Path = Path(env_base) if env_base else Path.home() / ".sourcecode" / "cache"
+    return base / repo_id(repo_root)
+
+
+# ---------------------------------------------------------------------------
+# Public API — observability
+# ---------------------------------------------------------------------------
+
+def status(repo_root: Path) -> dict[str, Any]:
+    """Return a dict describing the current cache state for *repo_root*.
+
+    Keys: cache_dir, cores, snapshots, views, cas_blobs,
+          total_size_bytes, total_size_mb.
+    Always succeeds — returns zeros when the cache directory does not exist.
+    """
+    cache_d = cache_dir(repo_root)
+    if not cache_d.exists():
+        return {
+            "cache_dir": str(cache_d),
+            "cores": 0,
+            "snapshots": 0,
+            "views": 0,
+            "cas_blobs": 0,
+            "total_size_bytes": 0,
+            "total_size_mb": 0.0,
+        }
+    cores = list(cache_d.glob("core-*.json.gz"))
+    snapshots = list(cache_d.glob("snapshot-*.json.gz"))
+    views = list(cache_d.glob("view-*.json.gz"))
+    cas_d = _cas_dir(cache_d)
+    cas_blobs = list(cas_d.glob("*.gz")) if cas_d.exists() else []
+    all_files = cores + snapshots + views + cas_blobs
+    total_bytes = sum(f.stat().st_size for f in all_files if f.exists())
+    return {
+        "cache_dir": str(cache_d),
+        "cores": len(cores),
+        "snapshots": len(snapshots),
+        "views": len(views),
+        "cas_blobs": len(cas_blobs),
+        "total_size_bytes": total_bytes,
+        "total_size_mb": round(total_bytes / (1024 * 1024), 2),
+    }
+
+
+def clear(repo_root: Path) -> int:
+    """Delete all cache files for *repo_root*.  Returns the number of files removed.
+
+    Removes cores, snapshots, views, and CAS blobs.
+    Always succeeds — returns 0 when cache directory does not exist.
+    """
+    cache_d = cache_dir(repo_root)
+    if not cache_d.exists():
+        return 0
+    removed = 0
+    for pattern in ("core-*.json.gz", "snapshot-*.json.gz", "view-*.json.gz"):
+        for f in cache_d.glob(pattern):
+            _safe_unlink(f)
+            removed += 1
+    cas_d = _cas_dir(cache_d)
+    if cas_d.exists():
+        for f in cas_d.glob("*.gz"):
+            _safe_unlink(f)
+            removed += 1
+    return removed
+
+
+# ---------------------------------------------------------------------------
+# Public API — read / write
+# ---------------------------------------------------------------------------
+
+def read(repo_root: Path, cache_key: str) -> Optional[str]:
+    """
+    Return the cached snapshot string for *cache_key*, or ``None`` on miss.
+
+    Lookup order:
+    1. ``<cache_dir>/snapshot-<cache_key>.json.gz``  — v2 envelope (new)
+    2. ``<repo_root>/.sourcecode-cache/snapshot-<cache_key>.json``  — legacy
+    """
+    cache_d = cache_dir(repo_root)
+
+    # ── 1. Global location (.json.gz, v2 envelope or v1 raw) ───────────────
+    gz_path = cache_d / f"snapshot-{cache_key}.json.gz"
+    if gz_path.exists():
+        try:
+            result = _parse_envelope(gz_path.read_bytes(), cache_d)
+            if result is not None:
+                return result
+        except Exception:
+            pass
+        _safe_unlink(gz_path)  # corrupted or version mismatch — evict
+        return None
+
+    # ── 2. Legacy location (<repo>/.sourcecode-cache/*.json) ───────────────
+    legacy = repo_root / ".sourcecode-cache" / f"snapshot-{cache_key}.json"
+    if legacy.exists():
+        try:
+            return legacy.read_text(encoding="utf-8")
+        except Exception:
+            return None
+
+    return None
+
+
+def write(
+    repo_root: Path,
+    cache_key: str,
+    content: str,
+    *,
+    fmt: str = "json",
+    layers: Optional[dict[str, str]] = None,
+) -> None:
+    """
+    Persist *content* as a versioned, optionally CAS-deduped snapshot.
+
+    Parameters
+    ----------
+    repo_root : Path
+        Root directory of the analysed repository.
+    cache_key : str
+        ``"{git_sha}-{flags_hash}"`` identifying this analysis.
+    content : str
+        Final rendered output (JSON or YAML string).
+    fmt : str
+        ``"json"`` or ``"yaml"`` — determines whether CAS extraction applies.
+    layers : dict[str, str], optional
+        Analyzer fingerprints (from ``_compute_analyzer_fingerprints()``).
+        Stored in the envelope for future layer-aware reuse.
+
+    Writes are always best-effort: any failure is silently swallowed.
+    """
+    cache_d = cache_dir(repo_root)
+    dest = cache_d / f"snapshot-{cache_key}.json.gz"
+    try:
+        cache_d.mkdir(parents=True, exist_ok=True)
+        payload = _build_envelope(cache_key, content, fmt, layers or {}, cache_d)
+        _atomic_write(dest, payload)
+    except Exception:
+        return  # non-fatal
+
+    _gc(cache_d)
+
+
+# ---------------------------------------------------------------------------
+# Layer 1 — Core Analysis cache
+# ---------------------------------------------------------------------------
+
+def read_core(repo_root: Path, core_key: str) -> Optional[tuple[dict[str, Any], str]]:
+    """Read core analysis artifacts from L1 cache.
+
+    Returns ``(core_dict, core_hash)`` on hit, or ``None`` on miss.
+    ``core_hash`` is the 16-char SHA-256 of the stored core JSON, used as
+    the L2 view-key prefix so that different views of the same core share
+    a common ancestry without a full re-analysis.
+    """
+    cache_d = cache_dir(repo_root)
+    gz_path = cache_d / f"core-{core_key}.json.gz"
+    if not gz_path.exists():
+        return None
+    try:
+        raw_bytes = gzip.decompress(gz_path.read_bytes())
+        envelope = json.loads(raw_bytes.decode("utf-8"))
+    except Exception:
+        _safe_unlink(gz_path)
+        return None
+
+    if not isinstance(envelope, dict):
+        _safe_unlink(gz_path)
+        return None
+    if envelope.get("csv") != CORE_SCHEMA_VERSION:
+        _safe_unlink(gz_path)  # schema mismatch — evict
+        return None
+
+    core_data = envelope.get("data")
+    core_hash = envelope.get("hash", "")
+    if not isinstance(core_data, dict) or not core_hash:
+        _safe_unlink(gz_path)
+        return None
+
+    return core_data, core_hash
+
+
+def write_core(repo_root: Path, core_key: str, core_data: dict[str, Any]) -> str:
+    """Persist core analysis dict to L1 cache.
+
+    Returns the 16-char SHA-256 hash of the core JSON (the L2 key prefix).
+    Writes are always best-effort; failures are silently swallowed.
+
+    File layout::
+
+        ~/.sourcecode/cache/<repo_id>/core-<core_key>.json.gz
+
+    Envelope schema::
+
+        { "csv": "1",       // CORE_SCHEMA_VERSION
+          "key": "...",     // core_key passed in
+          "hash": "<h16>",  // SHA-256[:16] of core JSON — used as L2 prefix
+          "ts":  "...",     // ISO-8601 UTC write time
+          "data": {...} }   // core_view(sm) dict
+    """
+    core_json = json.dumps(core_data, ensure_ascii=False)
+    core_hash = hashlib.sha256(core_json.encode()).hexdigest()[:16]
+
+    cache_d = cache_dir(repo_root)
+    dest = cache_d / f"core-{core_key}.json.gz"
+    try:
+        cache_d.mkdir(parents=True, exist_ok=True)
+        envelope: dict[str, Any] = {
+            "csv": CORE_SCHEMA_VERSION,
+            "key": core_key,
+            "hash": core_hash,
+            "ts": _now_iso(),
+            "data": core_data,
+        }
+        payload = gzip.compress(
+            json.dumps(envelope, ensure_ascii=False).encode("utf-8"),
+            compresslevel=6,
+        )
+        _atomic_write(dest, payload)
+    except Exception:
+        pass
+
+    return core_hash
+
+
+# ---------------------------------------------------------------------------
+# Layer 2 — Derived View cache
+# ---------------------------------------------------------------------------
+
+def read_view(repo_root: Path, view_key: str) -> Optional[str]:
+    """Read a rendered view string from L2 cache.
+
+    Views are stored as ``view-{view_key}.json.gz`` using the same
+    envelope+CAS format as snapshot files.  Returns the content string
+    (JSON or YAML) or ``None`` on miss.
+    """
+    cache_d = cache_dir(repo_root)
+    gz_path = cache_d / f"view-{view_key}.json.gz"
+    if not gz_path.exists():
+        return None
+    try:
+        result = _parse_envelope(gz_path.read_bytes(), cache_d)
+        if result is not None:
+            return result
+    except Exception:
+        pass
+    _safe_unlink(gz_path)
+    return None
+
+
+def write_view(
+    repo_root: Path,
+    view_key: str,
+    content: str,
+    *,
+    fmt: str = "json",
+    layers: Optional[dict[str, str]] = None,
+) -> None:
+    """Persist a rendered view string to L2 cache as ``view-{view_key}.json.gz``.
+
+    Reuses the envelope+CAS infrastructure so large fields (file_paths,
+    graph, docs …) are automatically deduplicated with other snapshots/views.
+    Writes are always best-effort; GC is **not** triggered here — callers
+    that want eviction should invoke ``_gc(cache_dir(repo_root))`` explicitly.
+    """
+    cache_d = cache_dir(repo_root)
+    dest = cache_d / f"view-{view_key}.json.gz"
+    try:
+        cache_d.mkdir(parents=True, exist_ok=True)
+        payload = _build_envelope(view_key, content, fmt, layers or {}, cache_d)
+        _atomic_write(dest, payload)
+    except Exception:
+        pass
+
+
+# ---------------------------------------------------------------------------
+# Envelope (de)serialisation
+# ---------------------------------------------------------------------------
+
+def _now_iso() -> str:
+    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+
+def _build_envelope(
+    cache_key: str,
+    content: str,
+    fmt: str,
+    layers: dict[str, str],
+    cache_d: Path,
+) -> bytes:
+    """Build a versioned envelope and return gzip-compressed bytes."""
+    envelope: dict[str, Any] = {
+        "sv": SCHEMA_VERSION,
+        "key": cache_key,
+        "ts": _now_iso(),
+        "fmt": fmt,
+        "layers": layers,
+    }
+
+    if fmt == "json":
+        # Try to parse and extract large fields into CAS
+        try:
+            snap_dict = json.loads(content)
+            if isinstance(snap_dict, dict):
+                inline, cas_refs = _cas_extract(snap_dict, cache_d)
+                envelope["snap"] = inline
+                if cas_refs:
+                    envelope["cas"] = cas_refs
+            else:
+                # JSON array or primitive — store as-is
+                envelope["raw"] = content
+        except Exception:
+            envelope["raw"] = content
+    else:
+        # YAML or unknown format — store raw string
+        envelope["raw"] = content
+
+    return gzip.compress(
+        json.dumps(envelope, ensure_ascii=False).encode("utf-8"),
+        compresslevel=6,
+    )
+
+
+def _parse_envelope(data: bytes, cache_d: Path) -> Optional[str]:
+    """
+    Decompress *data*, parse envelope, resolve CAS refs, return content string.
+
+    Returns ``None`` on schema version mismatch, CAS miss, or parse failure.
+    v1 files (no envelope wrapper) are detected and served transparently.
+    """
+    try:
+        raw_bytes = gzip.decompress(data)
+    except Exception:
+        return None
+
+    # ── v1 detection ────────────────────────────────────────────────────────
+    # v1 stored the content string directly (gzip'd UTF-8), not an envelope.
+    # Heuristic: if decompressed bytes are not a JSON object with an "sv" key,
+    # treat as v1 and return the raw bytes as the content string.
+    try:
+        envelope = json.loads(raw_bytes.decode("utf-8"))
+    except Exception:
+        # Not JSON at all (e.g. YAML v1) — return as-is
+        try:
+            return raw_bytes.decode("utf-8")
+        except Exception:
+            return None
+
+    if not isinstance(envelope, dict) or envelope.get("sv") != SCHEMA_VERSION:
+        # dict without "sv" → v1 JSON snapshot; non-matching sv → old envelope
+        # Serve v1 transparently; reject mismatched schema versions as a miss.
+        if isinstance(envelope, dict) and "sv" in envelope:
+            return None  # schema version mismatch
+        # No "sv" at all → v1 format, raw content
+        return raw_bytes.decode("utf-8")
+
+    # ── v2 envelope ─────────────────────────────────────────────────────────
+    if "raw" in envelope:
+        return envelope["raw"]
+
+    if "snap" in envelope:
+        inline: dict[str, Any] = envelope["snap"]
+        cas_refs: dict[str, str] = envelope.get("cas", {})
+        if cas_refs:
+            restored = _cas_restore(inline, cas_refs, cache_d)
+            if restored is None:
+                return None  # CAS miss (blob evicted or corrupted)
+        else:
+            restored = dict(inline)
+        # Re-serialise with the same parameters used by the pipeline.
+        # json.loads → json.dumps round-trips correctly: Python 3.7+ preserves
+        # dict insertion order and the pipeline uses indent=2, ensure_ascii=False.
+        return json.dumps(restored, indent=2, ensure_ascii=False)
+
+    return None  # malformed envelope
+
+
+# ---------------------------------------------------------------------------
+# CAS store
+# ---------------------------------------------------------------------------
+
+def _cas_dir(cache_d: Path) -> Path:
+    return cache_d / "cas"
+
+
+def _cas_path(cache_d: Path, blob_hash: str) -> Path:
+    return _cas_dir(cache_d) / f"{blob_hash}.gz"
+
+
+def _cas_store_blob(cache_d: Path, serialised: str) -> str:
+    """
+    Store *serialised* (a JSON string) in the CAS.  Idempotent.
+
+    Returns the 16-char SHA-256 hex hash that identifies the blob.
+    """
+    raw = serialised.encode("utf-8")
+    blob_hash = hashlib.sha256(raw).hexdigest()[:16]
+    path = _cas_path(cache_d, blob_hash)
+    if not path.exists():
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(gzip.compress(raw, compresslevel=6))
+    return blob_hash
+
+
+def _cas_load_blob(cache_d: Path, blob_hash: str) -> Optional[str]:
+    """Return the stored JSON string for *blob_hash*, or ``None`` if absent."""
+    path = _cas_path(cache_d, blob_hash)
+    if not path.exists():
+        return None
+    try:
+        return gzip.decompress(path.read_bytes()).decode("utf-8")
+    except Exception:
+        return None
+
+
+def _cas_extract(
+    snap_dict: dict[str, Any],
+    cache_d: Path,
+) -> tuple[dict[str, Any], dict[str, str]]:
+    """
+    Walk *snap_dict* top-level fields.  Fields that:
+      - are in ``_CAS_FIELDS``
+      - serialise to more than ``_CAS_THRESHOLD`` bytes
+
+    … are stored as CAS blobs and replaced with their hash in the returned
+    ``cas_refs`` mapping.  Other fields remain inline.
+    """
+    inline: dict[str, Any] = {}
+    cas_refs: dict[str, str] = {}
+
+    for key, value in snap_dict.items():
+        if key in _CAS_FIELDS and value is not None:
+            serialised = json.dumps(value, ensure_ascii=False)
+            if len(serialised.encode("utf-8")) > _CAS_THRESHOLD:
+                blob_hash = _cas_store_blob(cache_d, serialised)
+                cas_refs[key] = blob_hash
+                continue
+        inline[key] = value
+
+    return inline, cas_refs
+
+
+def _cas_restore(
+    inline: dict[str, Any],
+    cas_refs: dict[str, str],
+    cache_d: Path,
+) -> Optional[dict[str, Any]]:
+    """
+    Reconstruct a full snapshot dict by loading CAS blobs for *cas_refs*.
+
+    Returns ``None`` if any blob is missing (treat as cache miss).
+    """
+    result: dict[str, Any] = dict(inline)
+    for field, blob_hash in cas_refs.items():
+        blob_str = _cas_load_blob(cache_d, blob_hash)
+        if blob_str is None:
+            return None  # blob evicted or corrupted → full miss
+        try:
+            result[field] = json.loads(blob_str)
+        except Exception:
+            return None
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Eviction / GC
+# ---------------------------------------------------------------------------
+
+def _gc(cache_d: Path) -> None:
+    """Evict old snapshots/cores/views and sweep orphaned CAS blobs.
+
+    Three eviction passes:
+    1. Commit-based: keep only the last SOURCECODE_CACHE_KEEP_COMMITS distinct
+       git commits (by newest mtime within each commit group).
+    2. Core count cap: if surviving core files exceed SOURCECODE_CACHE_MAX_CORES,
+       evict oldest by mtime until under the cap.
+    3. Size cap: if total cache size exceeds SOURCECODE_CACHE_MAX_SIZE_MB,
+       evict oldest core/snapshot files until under the cap.
+    Views are pruned after all passes: only views traceable to a surviving core
+    survive.  CAS blobs are swept last.
+    """
+    keep = int(os.environ.get("SOURCECODE_CACHE_KEEP_COMMITS", _DEFAULT_KEEP_COMMITS))
+    max_cores = int(os.environ.get("SOURCECODE_CACHE_MAX_CORES", _DEFAULT_MAX_CORES))
+    max_size_bytes = (
+        int(os.environ.get("SOURCECODE_CACHE_MAX_SIZE_MB", _DEFAULT_MAX_SIZE_MB))
+        * 1024 * 1024
+    )
+
+    try:
+        all_snapshots = list(cache_d.glob("snapshot-*.json.gz"))
+        all_cores = list(cache_d.glob("core-*.json.gz"))
+        all_views = list(cache_d.glob("view-*.json.gz"))
+
+        if not all_snapshots and not all_cores and not all_views:
+            return
+
+        # ── Pass 1: commit-based eviction ───────────────────────────────────
+        groups: dict[str, list[Path]] = {}
+        for f in all_snapshots:
+            m = _SNAPSHOT_RE.match(f.name)
+            if m:
+                groups.setdefault(m.group(1), []).append(f)
+        for f in all_cores:
+            m = _CORE_RE.match(f.name)
+            if m:
+                groups.setdefault(m.group(1), []).append(f)
+
+        surviving: list[Path]
+
+        if keep <= 0 or len(groups) <= keep:
+            surviving = all_snapshots + all_cores
+        else:
+            def _newest_mtime(commit: str) -> float:
+                return max(p.stat().st_mtime for p in groups[commit])
+
+            sorted_commits = sorted(groups, key=_newest_mtime, reverse=True)
+            surviving = []
+            for i, commit in enumerate(sorted_commits):
+                if i < keep:
+                    surviving.extend(groups[commit])
+                else:
+                    for f in groups[commit]:
+                        _safe_unlink(f)
+
+        # ── Pass 2: core count cap ───────────────────────────────────────────
+        if max_cores > 0:
+            surviving_cores = [
+                p for p in surviving
+                if p.name.startswith("core-") and p.exists()
+            ]
+            if len(surviving_cores) > max_cores:
+                surviving_cores.sort(key=lambda p: p.stat().st_mtime, reverse=True)
+                for evict in surviving_cores[max_cores:]:
+                    _safe_unlink(evict)
+                    surviving = [p for p in surviving if p != evict]
+
+        # ── Pass 3: size cap ─────────────────────────────────────────────────
+        if max_size_bytes > 0:
+            size_candidates = [p for p in surviving if p.exists()]
+            total = sum(
+                p.stat().st_size
+                for p in size_candidates
+                if not p.name.startswith("view-")
+            )
+            if total > max_size_bytes:
+                size_candidates.sort(key=lambda p: p.stat().st_mtime)
+                for evict in size_candidates:
+                    if evict.name.startswith("view-"):
+                        continue
+                    total -= evict.stat().st_size if evict.exists() else 0
+                    _safe_unlink(evict)
+                    surviving = [p for p in surviving if p != evict]
+                    if total <= max_size_bytes:
+                        break
+
+        # ── Prune orphaned views + CAS ───────────────────────────────────────
+        all_views = list(cache_d.glob("view-*.json.gz"))
+        _gc_views(cache_d, surviving, all_views)
+        surviving_with_views = surviving + [v for v in all_views if v.exists()]
+        _gc_cas(cache_d, surviving_with_views)
+
+    except Exception:
+        pass  # GC failure is non-fatal
+
+
+def _gc_views(cache_d: Path, surviving: list[Path], all_views: list[Path]) -> None:
+    """Delete view files not traceable to a surviving core.
+
+    Collects the ``hash`` field from every surviving core envelope, then
+    deletes view files whose filename core-hash prefix is absent from that
+    set.  View files with unrecognisable names are left untouched.
+    """
+    if not all_views:
+        return
+
+    # Collect live core hashes from surviving core-*.json.gz files
+    live_hashes: set[str] = set()
+    for path in surviving:
+        if not path.name.startswith("core-"):
+            continue
+        try:
+            env = json.loads(gzip.decompress(path.read_bytes()).decode("utf-8"))
+            h = env.get("hash", "")
+            if h:
+                live_hashes.add(h)
+        except Exception:
+            pass  # unreadable core — conservatively keep its views unknown
+
+    for vp in all_views:
+        m = _VIEW_RE.match(vp.name)
+        if m and m.group(1) not in live_hashes:
+            _safe_unlink(vp)
+
+
+def _gc_cas(cache_d: Path, surviving_snapshots: list[Path]) -> None:
+    """
+    Delete CAS blobs not referenced by any snapshot in *surviving_snapshots*.
+
+    Walks each snapshot's ``cas`` dict to collect live hashes; deletes the rest.
+    """
+    cas_d = _cas_dir(cache_d)
+    if not cas_d.exists():
+        return
+
+    try:
+        # Collect all hashes referenced by surviving snapshots
+        referenced: set[str] = set()
+        for snap_path in surviving_snapshots:
+            try:
+                raw = gzip.decompress(snap_path.read_bytes())
+                env = json.loads(raw.decode("utf-8"))
+                if isinstance(env, dict) and "cas" in env:
+                    referenced.update(env["cas"].values())
+            except Exception:
+                pass  # unreadable snapshot — conservatively keep its blobs unknown
+
+        # Delete blobs not referenced by any surviving snapshot
+        for blob in cas_d.glob("*.gz"):
+            if blob.stem not in referenced:
+                _safe_unlink(blob)
+
+    except Exception:
+        pass  # CAS sweep failure is non-fatal
+
+
+# ---------------------------------------------------------------------------
+# Utilities
+# ---------------------------------------------------------------------------
+
+def _atomic_write(dest: Path, data: bytes) -> None:
+    """Write *data* to *dest* atomically via a sibling .tmp file + rename."""
+    tmp = dest.with_suffix(".tmp")
+    try:
+        tmp.write_bytes(data)
+        tmp.replace(dest)
+    except Exception:
+        _safe_unlink(tmp)
+        raise
+
+
+def _safe_unlink(path: Path) -> None:
+    try:
+        path.unlink(missing_ok=True)
+    except Exception:
+        pass

sourcecode/cli.py

@@ -1018,6 +1018,18 @@ def main(
         architecture = True  # agents need full architectural signal (M4)
         graph_modules = True  # IC-003: import graph needed for architecture confidence
 
+    # --compact implicitly enables lightweight analysis passes so that
+    # dependency_summary, env_summary and code_notes_summary are never null.
+    # architecture=True is also enabled so that architecture.confidence is
+    # consistent with --agent (which auto-enables architecture).  The
+    # ArchitectureAnalyzer is path-based and adds negligible latency.
+    # NOTE: must happen BEFORE cache key computation so key reflects effective flags.
+    if compact:
+        dependencies = True
+        env_map = True
+        code_notes = True
+        architecture = True
+
     # ── Two-layer cache ────────────────────────────────────────────────────────
     # L1 (core): (repo, commit, analysis_flags) → pre-computed view data dict
     #            key  = core-<git_sha>-<analysis_hash>.json.gz
@@ -1065,7 +1077,7 @@ def main(
                     f"dep={dependencies},gm={graph_modules},"
                     f"docs={docs},fm={full_metrics},sem={semantics},"
                     f"arch={architecture},gc={git_context},em={env_map},"
-                    f"cn={code_notes},mode={mode},"
+                    f"cn={code_notes},"
                     f"ex={_excl_key},depth={effective_depth}"
                 )
                 _core_h = _hashlib.sha256(_core_flags_str.encode()).hexdigest()[:8]
@@ -1073,7 +1085,7 @@ def main(
 
                 # ── View flags: output presentation only (no re-analysis needed) ──
                 _view_flags_str = (
-                    f"c={compact},ag={agent},fmt={format},full={full},"
+                    f"c={compact},ag={agent},mode={mode},fmt={format},full={full},"
                     f"co={changed_only},tree={tree},nt={no_tree},"
                     f"rb={rank_by},sym={symbol},ep={entrypoints_only},"
                     f"nr={no_redact},gd={graph_detail},dd={docs_depth},"
@@ -1235,17 +1247,6 @@ def main(
                 err=True,
             )
 
-    # --compact implicitly enables lightweight analysis passes so that
-    # dependency_summary, env_summary and code_notes_summary are never null.
-    # architecture=True is also enabled so that architecture.confidence is
-    # consistent with --agent (which auto-enables architecture).  The
-    # ArchitectureAnalyzer is path-based and adds negligible latency.
-    if compact:
-        dependencies = True
-        env_map = True
-        code_notes = True
-        architecture = True
-
     dependency_analyzer = DependencyAnalyzer() if dependencies else None
     graph_analyzer = GraphAnalyzer() if graph_modules else None
     parsed_graph_edges = (
@@ -2024,30 +2025,51 @@ def main(
     # L2 (view): stores the exact rendered string for this flag combination.
     #
     # GC runs after L2 write to evict old commits and orphaned blobs/views.
+    # Writes happen in a background daemon thread so cold-run latency is not
+    # penalised by gzip encoding + disk I/O.  atexit join ensures writes
+    # complete on clean exit without blocking the user-visible response.
     if not no_cache and _core_key and not _pipeline_error:
-        try:
-            from sourcecode.serializer import core_view as _core_view_fn
-            _core_dict_write = _core_view_fn(sm)
-            _written_core_hash = _cache_mod.write_core(target, _core_key, _core_dict_write)
-
-            # Compute view key using the just-written core hash
-            if _written_core_hash:
-                if not _view_key:
-                    # _view_key not set (L1 was also a miss); compute it now
-                    _wvh = _hashlib.sha256(_view_flags_str.encode()).hexdigest()[:8]
-                    _view_key = f"{_written_core_hash}-{_wvh}"
-                _cache_mod.write_view(
-                    target,
-                    _view_key,
-                    content,
-                    fmt=format,
-                    layers=_compute_analyzer_fingerprints(),
+        import atexit as _atexit
+        import threading as _threading
+
+        # Capture all closure state before handing off to thread
+        _bg_sm = sm
+        _bg_target = target
+        _bg_core_key = _core_key
+        _bg_view_key = _view_key
+        _bg_view_flags_str = _view_flags_str
+        _bg_content = content
+        _bg_format = format
+        _bg_hashlib = _hashlib
+        _bg_cache_mod = _cache_mod
+
+        def _write_cache_async() -> None:
+            try:
+                from sourcecode.serializer import core_view as _core_view_fn
+                _core_dict_write = _core_view_fn(_bg_sm)
+                _written_core_hash = _bg_cache_mod.write_core(
+                    _bg_target, _bg_core_key, _core_dict_write
                 )
-                # Trigger GC (evict old commits + orphaned views + CAS blobs)
-                from sourcecode.cache import cache_dir as _cdir, _gc as _run_gc
-                _run_gc(_cdir(target))
-        except Exception:
-            pass  # non-fatal: cache write failure
+                if _written_core_hash:
+                    _vk = _bg_view_key
+                    if not _vk:
+                        _wvh = _bg_hashlib.sha256(_bg_view_flags_str.encode()).hexdigest()[:8]
+                        _vk = f"{_written_core_hash}-{_wvh}"
+                    _bg_cache_mod.write_view(
+                        _bg_target,
+                        _vk,
+                        _bg_content,
+                        fmt=_bg_format,
+                        layers=_compute_analyzer_fingerprints(),
+                    )
+                    from sourcecode.cache import cache_dir as _cdir, _gc as _run_gc
+                    _run_gc(_cdir(_bg_target))
+            except Exception:
+                pass
+
+        _cache_write_thread = _threading.Thread(target=_write_cache_async, daemon=True)
+        _cache_write_thread.start()
+        _atexit.register(_cache_write_thread.join, 5.0)
 
     # Update RIS with aggregated snapshot data (non-fatal side-effect).
     if not no_cache and not _pipeline_error and _core_key:

{sourcecode-1.32.3.dist-info → sourcecode-1.32.4.dist-info}/METADATA

@@ -1,193 +1,7 @@
 Metadata-Version: 2.4
 Name: sourcecode
-Version: 1.32.3
+Version: 1.32.4
 Summary: Deterministic codebase context for AI coding agents
-License:                                  Apache License
-                                   Version 2.0, January 2004
-                                http://www.apache.org/licenses/
-        
-           TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-        
-           1. Definitions.
-        
-              "License" shall mean the terms and conditions for use, reproduction,
-              and distribution as defined by Sections 1 through 9 of this document.
-        
-              "Licensor" shall mean the copyright owner or entity authorized by
-              the copyright owner that is granting the License.
-        
-              "Legal Entity" shall mean the union of the acting entity and all
-              other entities that control, are controlled by, or are under common
-              control with that entity. For the purposes of this definition,
-              "control" means (i) the power, direct or indirect, to cause the
-              direction or management of such entity, whether by contract or
-              otherwise, or (ii) ownership of fifty percent (50%) or more of the
-              outstanding shares, or (iii) beneficial ownership of such entity.
-        
-              "You" (or "Your") shall mean an individual or Legal Entity
-              exercising permissions granted by this License.
-        
-              "Source" form shall mean the preferred form for making modifications,
-              including but not limited to software source code, documentation
-              source, and configuration files.
-        
-              "Object" form shall mean any form resulting from mechanical
-              transformation or translation of a Source form, including but
-              not limited to compiled object code, generated documentation,
-              and conversions to other formats.
-        
-              "Work" shall mean the work of authorship made available under
-              the License, as indicated by a copyright notice that is included in
-              or attached to the work (an example is provided in the Appendix below).
-        
-              "Derivative Works" shall mean any work, whether in Source or Object
-              form, that is based on (or derived from) the Work and for which the
-              editorial revisions, annotations, elaborations, or other transformations
-              represent, as a whole, an original work of authorship. For the purposes
-              of this License, Derivative Works shall not include works that remain
-              separable from, or merely link (or bind by name) to the interfaces of,
-              the Work and Derivative Works thereof.
-        
-              "Contribution" shall mean, as submitted to the Licensor for inclusion
-              in the Work by the copyright owner or by an individual or Legal Entity
-              authorized to submit on behalf of the copyright owner. For the purposes
-              of this definition, "submit" means any form of electronic, verbal, or
-              written communication sent to the Licensor or its representatives,
-              including but not limited to communication on electronic mailing lists,
-              source code control systems, and issue tracking systems that are managed
-              by, or on behalf of, the Licensor for the purpose of discussing and
-              improving the Work, but excluding communication that is conspicuously
-              marked or designated in writing by the copyright owner as "Not a
-              Contribution."
-        
-              "Contributor" shall mean Licensor and any Legal Entity on behalf of
-              whom a Contribution has been received by the Licensor and included
-              within the Work.
-        
-           2. Grant of Copyright License. Subject to the terms and conditions of
-              this License, each Contributor hereby grants to You a perpetual,
-              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-              copyright license to reproduce, prepare Derivative Works of,
-              publicly display, publicly perform, sublicense, and distribute the
-              Work and such Derivative Works in Source or Object form.
-        
-           3. Grant of Patent License. Subject to the terms and conditions of
-              this License, each Contributor hereby grants to You a perpetual,
-              worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-              (except as stated in this section) patent license to make, have made,
-              use, offer to sell, sell, import, and otherwise transfer the Work,
-              where such license applies only to those patent claims licensable
-              by such Contributor that are necessarily infringed by their
-              Contribution(s) alone or by the combination of their Contribution(s)
-              with the Work to which such Contribution(s) was submitted. If You
-              institute patent litigation against any entity (including a cross-claim
-              or counterclaim in a lawsuit) alleging that the Work or any Contributor
-              Contribution constitutes direct or contributory patent infringement,
-              then any patent rights granted to You under this License for that Work
-              shall terminate as of the date such litigation is filed.
-        
-           4. Redistribution. You may reproduce and distribute copies of the
-              Work or Derivative Works thereof in any medium, with or without
-              modifications, and in Source or Object form, provided that You
-              meet the following conditions:
-        
-              (a) You must give any other recipients of the Work or Derivative
-                  Works a copy of this License; and
-        
-              (b) You must cause any modified files to carry prominent notices
-                  stating that You changed the files; and
-        
-              (c) You must retain, in the Source form of any Derivative Works
-                  that You distribute, all copyright, patent, trademark, and
-                  attribution notices from the Source form of the Work,
-                  excluding those notices that do not pertain to any part of
-                  the Derivative Works; and
-        
-              (d) If the Work includes a "NOTICE" text file as part of its
-                  distribution, You must include a readable copy of the
-                  attribution notices contained within such NOTICE file, in
-                  at least one of the following places: within a NOTICE text
-                  file distributed as part of the Derivative Works; within
-                  the Source form or documentation, if provided along with the
-                  Derivative Works; or, within a display generated by the
-                  Derivative Works, if and wherever such third-party notices
-                  normally appear. The contents of the NOTICE file are for
-                  informational purposes only and do not modify the License.
-                  You may add Your own attribution notices within Derivative
-                  Works that You distribute, alongside or in addition to the
-                  NOTICE text from the Work, provided that such additional
-                  attribution notices cannot be construed as modifying the License.
-        
-              You may add Your own license statement for Your modifications and
-              may provide additional grant of rights to use, copy, modify, merge,
-              publish, distribute, sublicense, and/or sell copies of the
-              Derivative Works, as separate terms and conditions for their use,
-              reproduction, and distribution, or alongside or as supplement to
-              any license terms for such Derivative Works as a whole, provided
-              Your use, reproduction, and distribution of the Work otherwise
-              complies with the conditions stated in this License.
-        
-           5. Submission of Contributions. Unless You explicitly state otherwise,
-              any Contribution intentionally submitted for inclusion in the Work
-              by You to the Licensor shall be under the terms and conditions of
-              this License, without any additional terms or conditions.
-              Notwithstanding the above, nothing herein shall supersede or modify
-              the terms of any separate license agreement you may have executed
-              with Licensor regarding such Contributions.
-        
-           6. Trademarks. This License does not grant permission to use the trade
-              names, trademarks, service marks, or product names of the Licensor,
-              except as required for reasonable and customary use in describing the
-              origin of the Work and reproducing the content of the NOTICE file.
-        
-           7. Disclaimer of Warranty. Unless required by applicable law or
-              agreed to in writing, Licensor provides the Work (and each
-              Contributor provides its Contributions) on an "AS IS" BASIS,
-              WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-              implied, including, without limitation, any warranties or conditions
-              of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-              PARTICULAR PURPOSE. You are solely responsible for determining the
-              appropriateness of using or reproducing the Work and assume any
-              risks associated with Your exercise of permissions under this License.
-        
-           8. Limitation of Liability. In no event and under no legal theory,
-              whether in tort (including negligence), contract, or otherwise,
-              unless required by applicable law (such as deliberate and grossly
-              negligent acts) or agreed to in writing, shall any Contributor be
-              liable to You for damages, including any direct, indirect, special,
-              incidental, or exemplary damages of any character arising as a
-              result of this License or out of the use or inability to use the
-              Work (including but not limited to damages for loss of goodwill,
-              work stoppage, computer failure or malfunction, or all other
-              commercial damages or losses), even if such Contributor has been
-              advised of the possibility of such damages.
-        
-           9. Accepting Warranty or Liability. While redistributing the Work or
-              Derivative Works thereof, You may choose to offer, and charge a fee
-              for, acceptance of support, warranty, indemnity, or other liability
-              obligations and/or rights consistent with this License. However, in
-              accepting such obligations, You may offer such obligations only on
-              Your own behalf and on Your sole responsibility, not on behalf of
-              any other Contributor, and only if You agree to indemnify, defend,
-              and hold each Contributor harmless for any liability incurred by,
-              or claims asserted against, such Contributor by reason of your
-              accepting any warranty or additional liability.
-        
-           END OF TERMS AND CONDITIONS
-        
-           Copyright 2024 sourcecode contributors
-        
-           Licensed under the Apache License, Version 2.0 (the "License");
-           you may not use this file except in compliance with the License.
-           You may obtain a copy of the License at
-        
-               http://www.apache.org/licenses/LICENSE-2.0
-        
-           Unless required by applicable law or agreed to in writing, software
-           distributed under the License is distributed on an "AS IS" BASIS,
-           WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-           See the License for the specific language governing permissions and
-           limitations under the License.
 License-File: LICENSE
 Keywords: agents,ai,codebase,context,developer-tools,llm
 Classifier: Development Status :: 4 - Beta

{sourcecode-1.32.3.dist-info → sourcecode-1.32.4.dist-info}/RECORD

@@ -1,12 +1,13 @@
-sourcecode/__init__.py,sha256=5Ey4P8Jp1XkENrolOFwJQ6v_ucSixtebokTZVV3MgA8,103
+sourcecode/__init__.py,sha256=ekW8VutI9sqMXBEN-MSRy8p8fHOhat9jl5sCtrKrygc,103
 sourcecode/adaptive_scanner.py,sha256=XffluXKzJUXrMtjEiAOnSNPZnztdIcts17T9ouHeID0,10521
 sourcecode/architecture_analyzer.py,sha256=qh749a7ykPtGmQI1MR9y6j8TtL_jBdVYFx9YRsLqOMw,44121
 sourcecode/architecture_summary.py,sha256=z34_6v7cSwy98cof2UVciGho7SCrZ93tiqMmq5WNzRQ,20405
 sourcecode/ast_extractor.py,sha256=_btmeOJIe3t-NicF94D5ZAesa2YIJ0_QNExGnbHxGFE,50578
-sourcecode/cache.py,sha256=pBrPdpPrOgpXHHQO670U3aUfVf5N3A3obsTKgiZtN4I,23030
+sourcecode/cache.py,sha256=dvXt8HsU-SyO0a0UXY1n-wt6F2ozGv9VnKR0XydjxCY,27502
+sourcecode/cache.tmp_new,sha256=-IvV7CojiZjqeKMln1m-lqI0QVA2uFGWmYir4XRFOUk,27970
 sourcecode/canonical_ir.py,sha256=_HM3AUmKSdna9u4dCoU6rpgSA6HdF8gzOKZykIUCNGY,23277
 sourcecode/classifier.py,sha256=2lYoSH3vOTkXZYPU7Go2WIet1-IuNzTWVhc-ULnXtgw,8024
-sourcecode/cli.py,sha256=l3PJ9pK6JQ_JUxYSD3xnpvCIvR9kvOvbEEvHvqfij9A,165743
+sourcecode/cli.py,sha256=RdJ1F_sjmqTJ6zcv3eY2Tokg9H5dJe6zSuK3ownUGcA,166617
 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
@@ -79,8 +80,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.3.dist-info/METADATA,sha256=joMm6IGlPuAM0S0Sv9P_P5KORZ6Dletqfhv3GMQByO0,31100
-sourcecode-1.32.3.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
-sourcecode-1.32.3.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
-sourcecode-1.32.3.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
-sourcecode-1.32.3.dist-info/RECORD,,
+sourcecode-1.32.4.dist-info/METADATA,sha256=SJ09ABP688xA3bbWRuseGyJyVK-mYQmR7CgodrIjmDE,19120
+sourcecode-1.32.4.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sourcecode-1.32.4.dist-info/entry_points.txt,sha256=ex3F9rmbXeyDIoFQHtkEqTsKSaJow8F0LrVu8XfIktQ,57
+sourcecode-1.32.4.dist-info/licenses/LICENSE,sha256=7DdHrU9Z_3e7dSvq4ISijZNjnuHo5NIHNiHDouMQ9JU,10491
+sourcecode-1.32.4.dist-info/RECORD,,