diffcontext 0.5.1__py3-none-any.whl

diffcontext/verify/sufficiency.py

@@ -0,0 +1,324 @@
+"""
+sufficiency.py — Structural sufficiency analysis of a compiled context.
+
+The question this module answers: "given this compiled context package,
+how likely is it that an LLM reading it has everything it needs to reason
+about the change correctly?"
+
+HONESTY CONTRACT (read this before trusting the score):
+
+  The score is a STRUCTURAL PROXY, not a guarantee. True sufficiency is
+  defined relative to a stochastic model and cannot be proven statically.
+  What CAN be measured statically is the set of known predictors of
+  insufficiency:
+
+    1. Direct-neighbor closure — a caller/callee of a changed symbol that
+       is NOT in context is the single strongest structural predictor of
+       a wrong or hallucinated patch.
+    2. High-score retention — symbols the ranker itself scored as relevant
+       but the token budget cut. The ranker is telling us the context is
+       incomplete by its own standard.
+    3. Local graph confidence — unresolved edges out of the changed
+       symbols mean the graph may be blind to real dependencies (dynamic
+       dispatch, externals, broken files).
+    4. Parse holes — files with SyntaxErrors are invisible to the graph.
+
+  The score only becomes CALIBRATED CONFIDENCE after `diffcontext verify
+  --cases/--from-history --calibrate` maps score buckets to empirically
+  observed recall on your repo. Until then treat it as a ranked warning
+  system, not a probability.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Set
+
+from ..models import RepositoryIndex, ImpactResult, ContextPackage
+
+# A symbol the ranker scored at/above this is "relevant by the ranker's
+# own standard" — dropping it is evidence of insufficiency. 50 sits between
+# the direct-neighbor base scores (85-90) and the expanded-dep floor (30).
+HIGH_SCORE_THRESHOLD = 50.0
+
+# Component weights. Direct closure dominates because a missing direct
+# neighbor is the failure mode observed most often in retrieval evals
+# (see benchmarks/EVAL_V2_REPORT.md).
+W_CLOSURE   = 0.45
+W_RETENTION = 0.30
+W_CONFIDENCE = 0.15
+W_PARSE     = 0.10
+
+VERDICT_SUFFICIENT_MIN = 80.0
+VERDICT_DEGRADED_MIN   = 55.0
+
+# Evidence saturation: how many observations a component needs before it is
+# fully trusted. A component computed from zero observations (no direct
+# neighbors, no ranked-relevant symbols, no outgoing edges) says NOTHING —
+# the old formula scored it as a perfect 1.0, which is why sparse-graph
+# repos (TypeScript especially) reported a constant 100. With no evidence
+# the score now shrinks toward the maximum-uncertainty midpoint (50), and
+# the report says so instead of feigning confidence.
+EVIDENCE_SAT_CLOSURE    = 3     # direct neighbors
+EVIDENCE_SAT_RETENTION  = 3     # ranker-relevant symbols
+EVIDENCE_SAT_CONFIDENCE = 3     # outgoing edges from changed symbols
+LOW_EVIDENCE_MAX        = 0.4   # below this, emit a low-evidence finding
+MIDPOINT                = 50.0  # "don't know" score
+
+
+@dataclass
+class SufficiencyFinding:
+    """One concrete, actionable deficiency in the compiled context."""
+    severity: str          # "critical" | "warning" | "info"
+    kind: str              # machine-readable slug, e.g. "missing-direct-neighbor"
+    message: str           # human/LLM-readable, includes remediation
+    symbols: List[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict:
+        return {
+            "severity": self.severity,
+            "kind": self.kind,
+            "message": self.message,
+            "symbols": self.symbols,
+        }
+
+
+@dataclass
+class SufficiencyReport:
+    """Structural sufficiency verdict for one compiled context package."""
+    score: float                     # 0-100 structural proxy (see module docstring)
+    verdict: str                     # SUFFICIENT | DEGRADED | INSUFFICIENT
+    direct_closure: float            # fraction of direct neighbors in context
+    high_score_retention: float      # fraction of ranker-relevant symbols kept
+    local_graph_confidence: float    # resolved fraction of edges out of changed symbols
+    parse_health: float              # 1.0 = no broken files
+    findings: List[SufficiencyFinding] = field(default_factory=list)
+    missing_direct: List[str] = field(default_factory=list)
+    dropped_high_score: List[str] = field(default_factory=list)
+    calibrated: bool = False         # True only when produced by a calibration run
+    evidence: float = 1.0            # [0,1] how much observation backs the score
+    score_legacy: float = 0.0        # pre-evidence-shrinkage formula (A/B measure)
+
+    def to_dict(self) -> dict:
+        return {
+            "score": round(self.score, 1),
+            "verdict": self.verdict,
+            "components": {
+                "direct_closure": round(self.direct_closure, 3),
+                "high_score_retention": round(self.high_score_retention, 3),
+                "local_graph_confidence": round(self.local_graph_confidence, 3),
+                "parse_health": round(self.parse_health, 3),
+            },
+            "missing_direct": self.missing_direct,
+            "dropped_high_score": self.dropped_high_score,
+            "findings": [f.to_dict() for f in self.findings],
+            "calibrated": self.calibrated,
+            "evidence": round(self.evidence, 3),
+            "score_legacy": round(self.score_legacy, 1),
+        }
+
+    def render(self) -> str:
+        """Human-readable report block."""
+        mark = {"SUFFICIENT": "✓", "DEGRADED": "⚠", "INSUFFICIENT": "✗"}[self.verdict]
+        lines = [
+            "=== DIFFCONTEXT SUFFICIENCY REPORT ===",
+            f"Verdict : {mark} {self.verdict}  (structural score: {self.score:.0f}/100)",
+            f"  direct-neighbor closure : {self.direct_closure * 100:.0f}%"
+            f"  ({len(self.missing_direct)} missing)",
+            f"  high-score retention    : {self.high_score_retention * 100:.0f}%"
+            f"  ({len(self.dropped_high_score)} relevant symbols cut by budget)",
+            f"  local graph confidence  : {self.local_graph_confidence * 100:.0f}%",
+            f"  parse health            : {self.parse_health * 100:.0f}%",
+            f"  evidence behind score   : {self.evidence * 100:.0f}%",
+        ]
+        if self.findings:
+            lines.append("")
+            lines.append("FINDINGS:")
+            for f in self.findings:
+                icon = {"critical": "✗", "warning": "⚠", "info": "·"}[f.severity]
+                lines.append(f"  {icon} [{f.kind}] {f.message}")
+                for s in f.symbols[:8]:
+                    lines.append(f"      - {s}")
+                if len(f.symbols) > 8:
+                    lines.append(f"      ... and {len(f.symbols) - 8} more")
+        lines.append("")
+        if not self.calibrated:
+            lines.append(
+                "NOTE: this score is a structural proxy, not a probability. Run\n"
+                "`diffcontext verify --from-history 30 --calibrate` to map scores\n"
+                "to measured recall on this repo's own history."
+            )
+        lines.append("=== END SUFFICIENCY REPORT ===")
+        return "\n".join(lines)
+
+
+def analyze_sufficiency(
+    index: RepositoryIndex,
+    impact: ImpactResult,
+    package: ContextPackage,
+    high_score_threshold: float = HIGH_SCORE_THRESHOLD,
+) -> SufficiencyReport:
+    """
+    Compute the structural sufficiency of a compiled context package.
+
+    Deterministic and offline: uses only the index, the impact scores, and
+    what the selector actually kept — no LLM call.
+    """
+    changed = list(impact.changed)
+    changed_set = set(changed)
+    selected_set: Set[str] = {item.symbol_id for item in package.items}
+    # package.items is empty when compile ran without a graph; fall back to
+    # treating changed as selected so the report degrades gracefully.
+    if not selected_set:
+        selected_set = set(changed)
+
+    reverse = index.reverse_graph
+    findings: List[SufficiencyFinding] = []
+
+    # ── 1. Direct-neighbor closure ────────────────────────────────────────
+    direct_neighbors: Set[str] = set()
+    for sym in changed:
+        for callee in index.graph.get(sym, []):
+            if callee in index.symbols and callee not in changed_set:
+                direct_neighbors.add(callee)
+        for caller in reverse.get(sym, set()):
+            if caller in index.symbols and caller not in changed_set:
+                direct_neighbors.add(caller)
+
+    if direct_neighbors:
+        present = direct_neighbors & selected_set
+        direct_closure = len(present) / len(direct_neighbors)
+    else:
+        direct_closure = 1.0
+    missing_direct = sorted(
+        direct_neighbors - selected_set,
+        key=lambda s: -impact.scores.get(s, 0.0),
+    )
+
+    if missing_direct:
+        findings.append(SufficiencyFinding(
+            severity="critical" if direct_closure < 0.7 else "warning",
+            kind="missing-direct-neighbor",
+            message=(
+                f"{len(missing_direct)} direct caller(s)/callee(s) of the changed "
+                f"symbols are NOT in context. An LLM cannot see how these interact "
+                f"with the change. Remediation: raise --max-tokens or --top-k, or "
+                f"pass them explicitly via --changed."
+            ),
+            symbols=missing_direct,
+        ))
+
+    # ── 2. High-score retention ───────────────────────────────────────────
+    relevant = {
+        s for s, sc in impact.scores.items()
+        if sc >= high_score_threshold and s not in changed_set and s in index.symbols
+    }
+    if relevant:
+        kept = relevant & selected_set
+        retention = len(kept) / len(relevant)
+    else:
+        retention = 1.0
+    dropped_high = sorted(
+        relevant - selected_set,
+        key=lambda s: -impact.scores.get(s, 0.0),
+    )
+
+    if dropped_high:
+        findings.append(SufficiencyFinding(
+            severity="critical" if retention < 0.5 else "warning",
+            kind="high-score-dropped",
+            message=(
+                f"{len(dropped_high)} symbol(s) the ranker scored ≥{high_score_threshold:.0f} "
+                f"were cut by the token budget — the ranker itself considers this "
+                f"context incomplete. Remediation: raise --max-tokens."
+            ),
+            symbols=dropped_high,
+        ))
+
+    # ── 3. Local graph confidence (edges out of changed symbols) ─────────
+    local_total = 0
+    local_resolved = 0
+    for sym in changed:
+        for dep in index.graph.get(sym, []):
+            local_total += 1
+            if dep in index.symbols:
+                local_resolved += 1
+    local_confidence = (local_resolved / local_total) if local_total else 1.0
+
+    if local_confidence < 0.7 and local_total >= 3:
+        findings.append(SufficiencyFinding(
+            severity="warning",
+            kind="unresolved-local-edges",
+            message=(
+                f"Only {local_confidence * 100:.0f}% of calls made by the changed "
+                f"symbols resolve to known code (externals, dynamic dispatch, or "
+                f"broken files). The graph may be blind to real dependencies here."
+            ),
+        ))
+
+    # ── 4. Parse health ───────────────────────────────────────────────────
+    broken = list(package.skipped_files or index.broken_files)
+    parse_health = max(0.0, 1.0 - 0.2 * len(broken))
+    if broken:
+        findings.append(SufficiencyFinding(
+            severity="warning",
+            kind="parse-holes",
+            message=(
+                f"{len(broken)} file(s) failed to parse; the graph has holes there "
+                f"and this report cannot see dependencies through them."
+            ),
+            symbols=broken,
+        ))
+
+    # ── Composite score + verdict ─────────────────────────────────────────
+    raw = (
+        W_CLOSURE * direct_closure
+        + W_RETENTION * retention
+        + W_CONFIDENCE * local_confidence
+        + W_PARSE * parse_health
+    )
+    score_legacy = 100.0 * raw
+
+    # Evidence-aware shrinkage: a component backed by zero observations must
+    # not count as a perfect 1.0. Each component's trust saturates after a
+    # few observations; the composite shrinks toward the maximum-uncertainty
+    # midpoint in proportion to the missing evidence. With rich evidence
+    # (any well-connected Python symbol) this reduces to the legacy formula.
+    evidence = (
+        W_CLOSURE * min(1.0, len(direct_neighbors) / EVIDENCE_SAT_CLOSURE)
+        + W_RETENTION * min(1.0, len(relevant) / EVIDENCE_SAT_RETENTION)
+        + W_CONFIDENCE * min(1.0, local_total / EVIDENCE_SAT_CONFIDENCE)
+        + W_PARSE * 1.0
+    )
+    score = evidence * score_legacy + (1.0 - evidence) * MIDPOINT
+
+    if evidence < LOW_EVIDENCE_MAX:
+        findings.append(SufficiencyFinding(
+            severity="warning",
+            kind="low-evidence",
+            message=(
+                f"Only {evidence * 100:.0f}% of the signals this score is built "
+                f"from have any observations behind them (sparse or blind graph "
+                f"around the changed symbols). The score is shrunk toward 50 "
+                f"('unknown') accordingly — do not read it as confidence."
+            ),
+        ))
+
+    if score >= VERDICT_SUFFICIENT_MIN:
+        verdict = "SUFFICIENT"
+    elif score >= VERDICT_DEGRADED_MIN:
+        verdict = "DEGRADED"
+    else:
+        verdict = "INSUFFICIENT"
+
+    return SufficiencyReport(
+        score=score,
+        verdict=verdict,
+        direct_closure=direct_closure,
+        high_score_retention=retention,
+        local_graph_confidence=local_confidence,
+        parse_health=parse_health,
+        findings=findings,
+        missing_direct=missing_direct,
+        dropped_high_score=dropped_high,
+        evidence=evidence,
+        score_legacy=score_legacy,
+    )

diffcontext-0.5.1.dist-info/METADATA

@@ -0,0 +1,219 @@
+Metadata-Version: 2.4
+Name: diffcontext
+Version: 0.5.1
+Summary: Static-analysis-powered repository context compiler for LLMs
+Author-email: Trakshan Mishra <trakshanmishra477@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/trakshan-mishra/diffcontext
+Project-URL: Changelog, https://github.com/trakshan-mishra/diffcontext/blob/main/CHANGELOG.md
+Keywords: llm,context,static-analysis,call-graph,retrieval,code-search
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: ruff>=0.4; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Provides-Extra: typescript
+Requires-Dist: tree-sitter>=0.21; extra == "typescript"
+Requires-Dist: tree-sitter-typescript>=0.21; extra == "typescript"
+Requires-Dist: tree-sitter-javascript>=0.21; extra == "typescript"
+Dynamic: license-file
+
+# DiffContext
+
+**Show an AI coding assistant only the code that matters for the change it is
+making.**
+
+[![Python 3.9+](https://img.shields.io/badge/python-3.9+-blue)](https://www.python.org)
+[![CI](https://img.shields.io/github/actions/workflow/status/trakshan-mishra/Diffcontext/test.yml?branch=main)](https://github.com/trakshan-mishra/Diffcontext/actions)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+
+DiffContext is a **context compiler for LLM coding agents**. Give it a Python
+repository and a change — a git diff, a branch, or a single function name —
+and it returns the small set of functions the model actually needs to make
+that change safely: the callers that will break, the subclasses that override
+it, the tests that cover it. It fits them to whatever token budget you have,
+and it tells the model what it had to leave out.
+
+It is built for people wiring LLMs into real codebases — agent loops, PR
+review bots, CI checks — anywhere you have to decide what goes in the prompt
+and the repository is far too large to send.
+
+## The problem
+
+Ask an assistant to change one function in a 50,000-line project and you have
+three bad options: paste the whole repository (it does not fit, and models get
+worse in very large contexts), paste just that one function (the model breaks
+three callers it never saw), or grep for the name (grep cannot find the
+subclass that overrides it, or the handler that receives it through
+`functools.partial` — we measured grep's recall *plateauing* no matter how
+much budget you give it).
+
+DiffContext is the fourth option. Parse the repository once into a real
+dependency graph, then for any change select the few functions that actually
+matter and pack them into the smallest useful prompt.
+
+```
+git change ──► changed functions ──► hybrid retrieval ──► token budget ──► LLM-ready context
+                                      graph ∪ BM25 ∪ file      top-k + tokens
+```
+
+## Does it make the model better?
+
+Yes — measured end to end, not by proxy. On 128 ContextBench Python tasks
+judged by each repository's own test suite (no LLM-as-judge), **context
+roughly quadruples pass@1: 5.5% → 25.8%**, exact McNemar p < 0.0001.
+
+Two qualifiers, both in [`benchmarks/contextbench/RESULTS.md`](benchmarks/contextbench/RESULTS.md)
+§6: **(a)** the seed functions given to every arm are **oracle** — extracted
+from the gold patch — so this measures *"given correct localization, does
+context quality matter?"*, not end-to-end issue solving (localization is
+handed to every arm for free); **(b)** 121 of the 128 effective tasks are
+django, so this is largely a django result.
+
+The honest companion: the three context variants (default / gap / depboost)
+are statistically **indistinguishable** from each other, p = 0.36–0.81. The
+win is context versus no context — not this selector versus that one. Full
+results: [`benchmarks/contextbench/RESULTS.md`](benchmarks/contextbench/RESULTS.md).
+
+## Install
+
+```bash
+pip install diffcontext
+```
+
+Zero runtime dependencies, Python 3.9+.
+
+From source for development:
+
+```bash
+git clone https://github.com/trakshan-mishra/Diffcontext.git
+cd Diffcontext && pip install -e .
+```
+
+## Quick start
+
+```bash
+diffcontext index /path/to/project              # cold: seconds; warm: ~0.02s
+diffcontext compile --ref HEAD~1 --max-tokens 8000
+diffcontext verify --from-history 20 --calibrate
+```
+
+More commands: [USAGE.md](USAGE.md). Production recipes: [docs/USE_CASES.md](docs/USE_CASES.md).
+
+## What this is not
+
+- **Not a code generator.** It selects and packs context; the model writes
+  the code.
+- **Not precision-first.** It casts a wide net — mean precision is under 0.1
+  at the default top-k. Use `--cutoff gap` if you pay per token.
+- **Not multi-language yet.** Python is fully supported. TypeScript/JS (ESM)
+  is a working prototype; CommonJS is a measured failure mode.
+- **Not a replacement for reading the code.** Static analysis has blind spots,
+  itemized below and in [docs/BENCHMARKS.md](docs/BENCHMARKS.md).
+
+## Retrieval quality (measured, not claimed)
+
+Ground truth is mined from git history — *a developer changed these functions
+together in one commit; shown one, does the tool find the others?* Measured on
+**701 real commits across 9 Python repositories**, and re-run as a CI gate on
+every push so quality cannot silently regress.
+
+Per-commit hit / recall of real co-change partners, hybrid retrieval:
+
+| | django | click | flask | httpx | pydantic | black* | requests* |
+|---|---|---|---|---|---|---|---|
+| Hit | 0.894 | 0.889 | 0.863 | 0.935 | 0.758 | 0.897 | 0.953 |
+| Recall | 0.774 | 0.750 | 0.694 | 0.772 | 0.536 | 0.712 | 0.762 |
+
+\* validation repos, never used for tuning. Full table across all 9 repos:
+[benchmarks/README.md](benchmarks/README.md).
+
+Head-to-head vs grep at identical token budgets, grep **plateaus** at
+0.215 recall past 4k tokens while DiffContext reaches 0.576 at 8k
+(2.7×). The honest flip side: mean precision is under 0.1 at the default
+top-k — most retrieved symbols are supporting context, not the exact
+co-change set. `--cutoff gap` cuts at the largest score drop for ~4×
+precision at ~30% recall cost (co-change benchmark; 2.2× / ~14% on
+ContextBench).
+
+## I audited my own benchmark, and three of my claims lost
+
+A 2026-07 pass attacked the *evaluation* instead of the tool. Three published
+numbers did not survive:
+
+- **Calibration** — the only citable number (r=0.274, n≈25) was measured on a
+  polluted index. Re-measured clean at n=1,080 the legacy score gets
+  **r=0.016 (p=0.60)**: no relationship at all. Fixed by shrinking toward
+  "don't know" → **r=0.287 (p=0.0001)** — a ranking signal, not a probability.
+- **Blend weights** — the shipped [0.5, 0.35, 0.15] failed leave-one-repo-out;
+  every fold picked a less graph-heavy blend. Now [0.3, 0.5, 0.2].
+- **Dense baseline** — a TF-IDF stand-in had overstated dense retrieval (0.664,
+  beating BM25 5/5). The real MiniLM encoder scores 0.597 and beats BM25 only
+  2/5. Two prior conclusions corrected on the record.
+
+Full write-up: [docs/auditing-my-own-benchmark.md](docs/auditing-my-own-benchmark.md)
+· raw pass: [benchmarks/RIGOR_REPORT_2026-07.md](benchmarks/RIGOR_REPORT_2026-07.md).
+
+**Don't trust our benchmarks — run yours (2 minutes):**
+`diffcontext verify --from-history 20 --calibrate` mines test cases from
+*your* repo's git history and grades retrieval against them — and prints
+**NULL RESULT** rather than a decorative number when the tool doesn't fit
+your repo. Finding that out *is* the feature.
+
+## Use as a library
+
+```python
+from diffcontext.pipeline import index_repository, analyze_impact, compile
+
+idx = index_repository("/path/to/repo")
+impact = analyze_impact(idx, ["./src/auth.py:validate_jwt"])
+ctx = compile(idx, impact, max_tokens=8000, top_k=20)
+print(ctx.text)  # paste-ready, meta-header discloses what was dropped
+```
+
+Incremental API (`idx.update([...])`), structured output, pluggable tokenizer:
+[docs/ARCHITECTURE.md](docs/ARCHITECTURE.md).
+
+## Language support
+
+| Language | Status | Retrieval quality |
+|---|---|---|
+| Python | **Full** | Benchmarked: 701 commits, 5 repos + 4 validation repos |
+| TypeScript / JS (ESM) | **Prototype** | Mean recall **0–68% depending on code style** |
+| JavaScript (CommonJS) | **Unsupported** | Measured **0.0%** on express — do not use |
+
+## Known limitations (measured, not guessed)
+
+Static analysis has a ceiling: thematic siblings with no call between them,
+cross-subsystem conceptual links (all methods score **0/20**), and dynamic
+dispatch are measured blind spots — itemized in
+[docs/BENCHMARKS.md](docs/BENCHMARKS.md). When in doubt:
+`grep -rn "function_name(" --include="*.py" .` before fully trusting
+"no callers found."
+
+## More
+
+- [docs/ARCHITECTURE.md](docs/ARCHITECTURE.md) — pipeline, module map, agent API
+- [docs/BENCHMARKS.md](docs/BENCHMARKS.md) — all numbers, downstream pass@1, limitations
+- [docs/ROADMAP.md](docs/ROADMAP.md) — prioritized plan with measured motivations
+- [diffcontext-service/](diffcontext-service/) — FastAPI service + web UI
+- [observability/](observability/) — retrieval pipeline tracing
+- [CONTRIBUTING.md](CONTRIBUTING.md) — setup, CI gates, adapter development
+
+## License
+
+MIT

diffcontext-0.5.1.dist-info/RECORD

@@ -0,0 +1,40 @@
+diffcontext/__init__.py,sha256=TBiQX-1JarTlc_h8xqgiDBsiKHd5EN7jG3naly9esCo,7493
+diffcontext/_warn_once.py,sha256=DwIDMdIC5JisSCTfpENPAS4YM8DuJremevB5kzR9jfs,3762
+diffcontext/cache.py,sha256=LbUVYQHNsgSbrEvNjxa99unF0U_uCHLYfdMrbV4Tr1c,8351
+diffcontext/graph_builder.py,sha256=deYDWEK6IhQKaRoGZtTXTWENYa3o41IIwD6H_PuG77o,42236
+diffcontext/history.py,sha256=_DAxy2vQuMiMX-yxq_vl4hhmV3RZaOLptWgEp7kbwew,6615
+diffcontext/lexical.py,sha256=xhcj5tIRUucg7E0T2949C8fuEGVvjnYKuWXqX0-o0rY,4100
+diffcontext/models.py,sha256=nH6OAGWUTMehajMgnG1E_iNmHeKj-pNmIYQKMF-A4Q4,7044
+diffcontext/parser.py,sha256=DA8zCpxuDxWG0lRu8XCedIrWOEzRfllZ5TPFtD2Ngzw,6329
+diffcontext/pipeline.py,sha256=aP7yYvszvSzMVw-uyF5kps4FkawFRCGXtayiTll3FWQ,37272
+diffcontext/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+diffcontext/resolver.py,sha256=_4v7YoH_kxDNBGyJ1daeC_v_3YYwwKEZ-3bY5zP8aVw,11319
+diffcontext/scanner.py,sha256=Qu0fjZWOdydicNYGksTLFFAzwnGt0NuBw-HJddR0eY4,5541
+diffcontext/symbols.py,sha256=HtOGqJ48I4RXmmnDK9Uwr9LLmeihq-VPxpOKfsg84mc,8895
+diffcontext/cli/__init__.py,sha256=uP3IoVMy69WzDRhei46jFP-DFdD3W0EXtmjQ9Nj6aF4,26813
+diffcontext/context/__init__.py,sha256=cWSKXCao1HWbTwyX3WnnpSb7FfrL_zl-f7sfEOeUsUw,64
+diffcontext/context/compiler.py,sha256=4HWA9nRJzTOyt-CDkLLteWmYEKDrS9wbb_xBgH9pC1o,24988
+diffcontext/context/selector.py,sha256=CvLu4TYJ1vGJDGSDcMcdavp1Iox-Pq3Ap2GfqWwv4Fw,11574
+diffcontext/diff/__init__.py,sha256=AT2Atp_APdhnshlF2uHYIKiyAcN36w09hS05dl7bGB4,67
+diffcontext/diff/git_diff.py,sha256=YDjNw-o8CL7D55_u1yZ2TdLd75EUZiHQIvu45Y5iVhs,10237
+diffcontext/diff/state_manager.py,sha256=Tl-893RiPmb3WzX5gtDuXYhNYmmHld-fSHhVmeW2lkE,2304
+diffcontext/impact/__init__.py,sha256=NlhMPGsKlPsVY6t3Ik2hCypIRmBBrlnEJrxKWgNoGBY,62
+diffcontext/impact/blast_radius.py,sha256=Dviaq3l2tR59P9RjFUra2qUkyPGneSVL_DjSGSjvULw,1781
+diffcontext/impact/scoring.py,sha256=u081fwuvSOg2uReVKXd23mdw66Dw1necTsMqDLz5kKA,10040
+diffcontext/impact/traversal.py,sha256=B4f1UjupdJgq47qST4Krlf90Zl2LTZVyS1r5zItoDCc,1648
+diffcontext/impact/visualizer.py,sha256=CPCY5JJl3ZwbNVO_A9qUorJlttRspeDQ6Cz602227Jk,12632
+diffcontext/languages/__init__.py,sha256=I9aXwC9lkCa4NDOVOdKNMhKJ_I6e9jP95yNzPkWMybc,3020
+diffcontext/languages/typescript.py,sha256=P71HVdzFrhxJklj0xgydMNo0HLWP2TMkuxMdLrrcbkU,39976
+diffcontext/rerank/__init__.py,sha256=P818PefX7P7UWabroAIAW07ibSkScUdcA50yAWDVTo0,810
+diffcontext/rerank/features.py,sha256=1Kz7NCZmSHBQxV6BWuVbvKeX-W8DgmYdSybDn_r0aK4,14726
+diffcontext/rerank/model.py,sha256=WcnUJKD-OSSo8caDhT40R7JczgDPqlTNKUEnyEiEnx4,6565
+diffcontext/verify/__init__.py,sha256=2TGQeAOF3IieAVDAT6IPp6gEeg_CHA_uYI0Na_-luMc,1664
+diffcontext/verify/cases.py,sha256=PvdSrYcECjr0vAOvS_ZLAFm8jQ0JFEMR8PUc00CkN94,24522
+diffcontext/verify/history.py,sha256=g2W3DPovYjFVaZvLPbuYSa43EVn3aXJgBVkXv6VMCwY,14852
+diffcontext/verify/sufficiency.py,sha256=lQ0nVuZRd3iiYfkjtW8HdF8ECoD1iofrNEq2k5R-NmM,14153
+diffcontext-0.5.1.dist-info/licenses/LICENSE,sha256=_6YT37Ksw40AmI_jRpAsRpfZ9m-zE940ErvuLnfnZM0,1072
+diffcontext-0.5.1.dist-info/METADATA,sha256=G-JjkjT9Qik-0CBF2FYS6RhG8KmCfgghKVJrBYF4lO4,9794
+diffcontext-0.5.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+diffcontext-0.5.1.dist-info/entry_points.txt,sha256=_9tDdWZI_mhDdZlcTPSkI_3rBjFCPSPQ_qUpi3Bd5gA,57
+diffcontext-0.5.1.dist-info/top_level.txt,sha256=jn0jr84NeYGXynu1gEbY6LcZMleqlbPpFLkD3UFujKw,12
+diffcontext-0.5.1.dist-info/RECORD,,

diffcontext-0.5.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

diffcontext-0.5.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+diffcontext = diffcontext.cli:cli_main

diffcontext-0.5.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Trakshan Mishra
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

diffcontext-0.5.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+diffcontext