graphite-code 0.3.0__py3-none-any.whl

graphite/routing/zai_edit.py

@@ -0,0 +1,113 @@
+"""Bridge a z.ai plain-text whole-file edit response into the shared apply payload.
+
+z.ai's native executor returns a bare plain-text message (no JSON envelope), so
+the model emits each edited file verbatim between path-qualified markers and a
+completion sentinel. This parser converts that into the exact payload
+``apply_whole_file_edit`` consumes. It performs structural parsing plus a
+defense-in-depth scope-set check only; ``apply_whole_file_edit`` remains the
+sole authority on path safety and byte caps. Every non-conformance raises
+``AdapterError("response_contract_invalid")``.
+
+Preamble and interstitial prose (e.g. "Here are the files:") are tolerated by
+design — non-marker lines outside blocks are skipped and the live smoke relies
+on this. Two accepted, documented consequences: (1) a content line byte-identical
+to its own path-qualified end marker truncates at that line (line boundaries
+follow ``str.splitlines`` — any Unicode line terminator, not only ``\\n`` —
+though content bytes are always sliced verbatim from the raw message, so
+extraction stays byte-exact); (2) prose containing a begin-marker-shaped line
+yields a phantom block, which surfaces as a scope-set mismatch (rejected, not
+applied). Path-qualified markers plus first-matching-end parsing make both
+improbable.
+"""
+from __future__ import annotations
+
+import re
+
+from .claude_executor import AdapterError
+from .edit_apply import EDIT_RESULT_MARKER
+
+EDIT_BEGIN_TEMPLATE = "===GRAPHITE BEGIN FILE {path}==="
+EDIT_END_TEMPLATE = "===GRAPHITE END FILE {path}==="
+
+# Trailing spaces/tabs and a CR are tolerated on marker lines (models append
+# them constantly); a content line must still start with the exact marker
+# prefix to match, so this stays false-positive-safe.
+_BEGIN_RE = re.compile(r"^===GRAPHITE BEGIN FILE (?P<path>.+?)===[ \t]*\r?$")
+_END_RE = re.compile(r"^===GRAPHITE END FILE (?P<path>.+?)===[ \t]*\r?$")
+
+
+def _fail() -> AdapterError:
+    return AdapterError("response_contract_invalid")
+
+
+def parse_whole_file_edit_text(message: str, *, edit_scope: tuple[str, ...]) -> dict:
+    """Parse a plain-text multi-file edit response into an apply payload.
+
+    Returns ``{"files": [{"path","content"}, …], "result": EDIT_RESULT_MARKER}``
+    with files ordered to match ``edit_scope``. Raises
+    ``AdapterError("response_contract_invalid")`` on any non-conformance.
+    """
+    if not isinstance(message, str) or not message:
+        raise _fail()
+    if (
+        not isinstance(edit_scope, tuple)
+        or not edit_scope
+        or not all(isinstance(path, str) for path in edit_scope)
+        or len(set(edit_scope)) != len(edit_scope)
+    ):
+        raise _fail()
+
+    lines = message.splitlines(keepends=True)
+    starts: list[int] = []
+    offset = 0
+    for line in lines:
+        starts.append(offset)
+        offset += len(line)
+    total = offset
+
+    files: list[dict[str, str]] = []
+    seen: set[str] = set()
+    covered: list[tuple[int, int]] = []
+    idx = 0
+    n = len(lines)
+    while idx < n:
+        begin = _BEGIN_RE.match(lines[idx].rstrip("\n"))
+        if begin is None:
+            idx += 1
+            continue
+        path = begin.group("path")
+        content_start = starts[idx] + len(lines[idx])
+        jdx = idx + 1
+        end_idx: int | None = None
+        while jdx < n:
+            stripped = lines[jdx].rstrip("\n")
+            end = _END_RE.match(stripped)
+            if end is not None and end.group("path") == path:
+                end_idx = jdx
+                break
+            if _BEGIN_RE.match(stripped) is not None:
+                break  # a new begin before our end -> malformed block
+            jdx += 1
+        if end_idx is None:
+            raise _fail()
+        if path in seen:
+            raise _fail()
+        seen.add(path)
+        files.append({"path": path, "content": message[content_start:starts[end_idx]]})
+        covered.append((starts[idx], starts[end_idx] + len(lines[end_idx])))
+        idx = end_idx + 1
+
+    if not files or seen != set(edit_scope):
+        raise _fail()
+
+    residual: list[str] = []
+    cursor = 0
+    for block_start, block_end in covered:
+        residual.append(message[cursor:block_start])
+        cursor = block_end
+    residual.append(message[cursor:total])
+    if EDIT_RESULT_MARKER not in "".join(residual):
+        raise _fail()
+
+    ordered = sorted(files, key=lambda item: edit_scope.index(item["path"]))
+    return {"files": ordered, "result": EDIT_RESULT_MARKER}

graphite/routing/zai_executor.py

@@ -0,0 +1,191 @@
+"""Isolated hardened adapter for one bounded z.ai chat completion (plain text)."""
+from __future__ import annotations
+
+import hashlib
+import json
+import math
+from collections.abc import Callable
+from dataclasses import dataclass, field
+
+from .claude_executor import AdapterError
+from .lifecycle import LifecycleProviderId
+from .probe_runner import (
+    MAX_INFERENCE_REQUEST_BYTES,
+    MAX_INFERENCE_RESPONSE_BYTES,
+    MAX_INFERENCE_TIMEOUT_SECONDS,
+    HttpProbeEndpoint,
+    HttpProbeResult,
+    ProbeEndpointPurpose,
+    ProviderProbeError,
+    run_http_probe,
+)
+from .zai_probe import ZAI_HOST, ZaiPricing, zai_cost_microunits
+
+MAX_TOKEN_COUNT = 10_000_000
+MAX_COST_MICROUNITS = 1_000_000_000
+
+HttpProbe = Callable[..., HttpProbeResult]
+
+_EXECUTION_TRANSPORT_CODES = {
+    "probe_response_limit": "response_limit",
+    "probe_timeout": "timeout",
+    "probe_http_status": "http_status",
+    "probe_redirect_rejected": "http_status",
+}
+
+
+@dataclass(frozen=True, slots=True)
+class ZaiExecutionResult:
+    """Sanitized outcome of one bounded z.ai plain-text execution."""
+
+    effective_model: str
+    message: str = field(repr=False)
+    input_tokens: int
+    output_tokens: int
+    cost_microunits: int
+    duration_seconds: float
+    request_sha256: str
+    response_sha256: str
+
+
+def _model_name(value: object) -> str:
+    if (
+        not isinstance(value, str)
+        or not value
+        or len(value) > 128
+        or any(character.isspace() for character in value)
+    ):
+        raise AdapterError("request_invalid")
+    return value
+
+
+def _token(value: object) -> int:
+    if isinstance(value, bool) or not isinstance(value, int) or not 0 <= value <= MAX_TOKEN_COUNT:
+        raise AdapterError("protocol")
+    return value
+
+
+def execute_zai(
+    *,
+    api_key: str,
+    prompt: bytes,
+    requested_model: str,
+    expected_effective_model: str,
+    pricing: ZaiPricing,
+    max_output_tokens: int,
+    max_cost_microunits: int,
+    timeout_seconds: float,
+    transport: HttpProbe = run_http_probe,
+) -> ZaiExecutionResult:
+    """Perform exactly one bounded z.ai chat completion returning plain text; no retries."""
+    if not isinstance(api_key, str) or not api_key:
+        raise AdapterError("auth_required")
+    if len(api_key) > 4096 or any(character in api_key for character in "\r\n\x00"):
+        raise AdapterError("request_invalid")
+    if (
+        not isinstance(prompt, bytes)
+        or not prompt
+        or len(prompt) > MAX_INFERENCE_REQUEST_BYTES
+    ):
+        raise AdapterError("request_invalid")
+    try:
+        prompt_text = prompt.decode("utf-8")
+    except UnicodeDecodeError:
+        raise AdapterError("request_invalid") from None
+    requested = _model_name(requested_model)
+    expected = _model_name(expected_effective_model)
+    if not isinstance(pricing, ZaiPricing):
+        raise AdapterError("request_invalid")
+    for value, maximum in (
+        (max_output_tokens, MAX_TOKEN_COUNT),
+        (max_cost_microunits, MAX_COST_MICROUNITS),
+    ):
+        if isinstance(value, bool) or not isinstance(value, int) or not 1 <= value <= maximum:
+            raise AdapterError("request_invalid")
+    if (
+        isinstance(timeout_seconds, bool)
+        or not isinstance(timeout_seconds, (int, float))
+        or not math.isfinite(timeout_seconds)
+        or not 0.1 <= timeout_seconds <= MAX_INFERENCE_TIMEOUT_SECONDS
+    ):
+        raise AdapterError("request_invalid")
+    payload = {
+        "max_tokens": max_output_tokens,
+        "messages": [{"content": prompt_text, "role": "user"}],
+        "model": requested,
+        "stream": False,
+        "temperature": 0,
+        # glm-5.2 is a reasoning model; with thinking on it consumes the entire
+        # output budget on reasoning_tokens and returns empty content
+        # (finish_reason=length), so the bounded plain-text answer is never
+        # emitted. Disable thinking so the exact response is produced
+        # deterministically within the token budget (z.ai honors this).
+        "thinking": {"type": "disabled"},
+    }
+    body = json.dumps(payload, sort_keys=True, separators=(",", ":")).encode()
+    if len(body) > MAX_INFERENCE_REQUEST_BYTES:
+        raise AdapterError("request_invalid")
+    endpoint = HttpProbeEndpoint(
+        LifecycleProviderId.ZAI,
+        "https",
+        ZAI_HOST,
+        443,
+        ProbeEndpointPurpose.ZAI_CHAT_COMPLETIONS,
+    )
+    try:
+        result = transport(
+            endpoint=endpoint,
+            timeout_seconds=timeout_seconds,
+            request_body=body,
+            authorization=f"Bearer {api_key}",
+            max_response_bytes=MAX_INFERENCE_RESPONSE_BYTES,
+        )
+    except ProviderProbeError as error:
+        raise AdapterError(
+            _EXECUTION_TRANSPORT_CODES.get(error.code, "unavailable")
+        ) from None
+    except Exception:
+        raise AdapterError("unavailable") from None
+    if not isinstance(result, HttpProbeResult):
+        raise AdapterError("unavailable")
+    try:
+        envelope = json.loads(result.body.decode("utf-8"))
+    except (UnicodeDecodeError, json.JSONDecodeError, RecursionError):
+        raise AdapterError("unavailable") from None
+    if not isinstance(envelope, dict):
+        raise AdapterError("protocol")
+    reported_model = envelope.get("model")
+    if not isinstance(reported_model, str) or not reported_model:
+        raise AdapterError("model_identity_unverified")
+    if reported_model != expected:
+        raise AdapterError("model_mismatch")
+    choices = envelope.get("choices")
+    if not isinstance(choices, list) or len(choices) != 1 or not isinstance(choices[0], dict):
+        raise AdapterError("protocol")
+    message = choices[0].get("message")
+    if not isinstance(message, dict):
+        raise AdapterError("protocol")
+    content = message.get("content")
+    if not isinstance(content, str):
+        raise AdapterError("protocol")
+    usage = envelope.get("usage")
+    if not isinstance(usage, dict):
+        raise AdapterError("protocol")
+    input_tokens = _token(usage.get("prompt_tokens"))
+    output_tokens = _token(usage.get("completion_tokens"))
+    try:
+        cost = zai_cost_microunits(pricing, input_tokens=input_tokens, output_tokens=output_tokens)
+    except ProviderProbeError:
+        raise AdapterError("protocol") from None
+    if cost > max_cost_microunits:
+        raise AdapterError("cost_ceiling_exceeded")
+    return ZaiExecutionResult(
+        expected,
+        content,
+        input_tokens,
+        output_tokens,
+        cost,
+        result.duration_seconds,
+        hashlib.sha256(body).hexdigest(),
+        hashlib.sha256(result.body).hexdigest(),
+    )

graphite/routing/zai_probe.py

@@ -0,0 +1,126 @@
+"""Local (no-network) z.ai identity + operator-pinned pricing for governed verification."""
+from __future__ import annotations
+
+import hashlib
+import json
+import re
+from dataclasses import dataclass
+from decimal import Decimal, InvalidOperation
+
+from .contracts import CliIdentity, ProviderId
+from .lifecycle import (
+    LifecycleProviderId,
+    ProviderCompatibilityPolicy,
+    ProviderRuntimeIdentity,
+    RuntimeKind,
+)
+from .probe_runner import ProviderProbeError
+
+ZAI_HOST = "api.z.ai"
+ZAI_CANONICAL_ENDPOINT = "https://api.z.ai/api/paas/v4"
+ZAI_MODEL = "glm-5.2"
+ZAI_API_CONTRACT_VERSION = "1.0.0"
+ZAI_ADAPTER_PROTOCOL_VERSION = "1.0.0"
+ZAI_CAPABILITIES = ("remote_inference",)
+# z.ai model ids are single-segment (no vendor/model slash, unlike OpenRouter).
+_ZAI_MODEL_ID = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$")
+_PRICE = re.compile(r"^(0|[0-9]{1,10}(\.[0-9]{1,18})?|\.[0-9]{1,18})$")
+
+# Compatibility policy for lifecycle observe(): promotes a DISCOVERED z.ai
+# runtime identity to VERIFICATION_REQUIRED once it matches this shape.
+# No `_OPENROUTER_POLICY` (or any other per-provider policy constant)
+# exists elsewhere in this codebase to clone; policies are otherwise built
+# ad hoc at each call site. This constant is the zai-owned analog of where
+# such a policy would live for OpenRouter (openrouter_probe.py).
+_ZAI_POLICY = ProviderCompatibilityPolicy(
+    provider=LifecycleProviderId.ZAI,
+    runtime_kind=RuntimeKind.REMOTE_HTTPS,
+    policy_version="1.0.0",
+    minimum_version="1.0.0",
+    maximum_version_exclusive="2.0.0",
+    required_capabilities=ZAI_CAPABILITIES,
+)
+
+
+def _digest(value: object) -> str:
+    return hashlib.sha256(
+        json.dumps(value, sort_keys=True, separators=(",", ":")).encode()
+    ).hexdigest()
+
+
+@dataclass(frozen=True, slots=True)
+class ZaiPricing:
+    """Operator-pinned per-token USD prices as exact decimal strings."""
+
+    prompt: str
+    completion: str
+
+    def __post_init__(self) -> None:
+        for value in (self.prompt, self.completion):
+            if not isinstance(value, str) or len(value) > 64 or _PRICE.fullmatch(value) is None:
+                raise ProviderProbeError("probe_protocol_invalid")
+            try:
+                parsed = Decimal(value)
+            except InvalidOperation:
+                raise ProviderProbeError("probe_protocol_invalid") from None
+            if not Decimal(0) <= parsed <= Decimal(1):
+                raise ProviderProbeError("probe_protocol_invalid")
+
+    @property
+    def digest(self) -> str:
+        return _digest({"completion": self.completion, "prompt": self.prompt})
+
+
+def zai_cost_microunits(pricing: ZaiPricing, *, input_tokens: int, output_tokens: int) -> int:
+    """Ceiling of the exact-decimal USD cost in microunits."""
+    if not isinstance(pricing, ZaiPricing):
+        raise ProviderProbeError("probe_request_invalid")
+    for value in (input_tokens, output_tokens):
+        if isinstance(value, bool) or not isinstance(value, int) or not 0 <= value <= 100_000_000:
+            raise ProviderProbeError("probe_request_invalid")
+    cost = (
+        Decimal(input_tokens) * Decimal(pricing.prompt)
+        + Decimal(output_tokens) * Decimal(pricing.completion)
+    ) * Decimal(1_000_000)
+    whole = int(cost)
+    return whole if cost == whole else whole + 1
+
+
+@dataclass(frozen=True, slots=True)
+class ZaiPreflight:
+    identity: CliIdentity
+    runtime: ProviderRuntimeIdentity
+    pricing: ZaiPricing
+
+
+def preflight_zai(*, model_id: str, observed_at: int, policy_version: str) -> ZaiPreflight:
+    """Construct the z.ai runtime + CLI identity and pinned pricing locally (no network)."""
+    if not isinstance(model_id, str) or _ZAI_MODEL_ID.fullmatch(model_id) is None:
+        raise ProviderProbeError("probe_request_invalid")
+    pricing = ZaiPricing(prompt="0.0000014", completion="0.0000044")
+    endpoint_digest = hashlib.sha256(ZAI_CANONICAL_ENDPOINT.encode("ascii")).hexdigest()
+    model_digest = _digest(model_id)
+    try:
+        runtime = ProviderRuntimeIdentity(
+            LifecycleProviderId.ZAI,
+            RuntimeKind.REMOTE_HTTPS,
+            ZAI_API_CONTRACT_VERSION,
+            endpoint_digest,
+            model_digest,
+            None,                       # routing_policy_digest forbidden for zai
+            ZAI_CAPABILITIES,
+            policy_version,
+            observed_at,
+        )
+    except ValueError:
+        raise ProviderProbeError("probe_request_invalid") from None
+    composite = _digest(
+        {"endpoint": endpoint_digest, "model": model_digest, "pricing": pricing.digest}
+    )
+    identity = CliIdentity(
+        ProviderId.ZAI,
+        composite,
+        ZAI_API_CONTRACT_VERSION,
+        ZAI_ADAPTER_PROTOCOL_VERSION,
+    )
+    return ZaiPreflight(identity, runtime, pricing)

graphite/savings.py

@@ -0,0 +1,84 @@
+"""Result-scaled counterfactual estimator for the savings display.
+
+The numbers are ESTIMATES of what equivalent manual exploration would have
+cost, scaled by what each graphite answer actually contained; they are never
+measurements. ``methodology()`` prints the formula and constants next to any
+report so the claim stays auditable.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Iterable
+
+
+@dataclass(frozen=True)
+class SavingsModel:
+    grep_tokens: int = 1000
+    grep_seconds: int = 20
+    read_seconds: int = 10
+    file_token_cap: int = 2000
+
+
+MODEL = SavingsModel()
+
+
+def _num(value: Any, cast: type) -> Any:
+    """Best-effort numeric coercion; schema-corrupt values count as zero."""
+    if isinstance(value, bool) or not isinstance(value, (int, float)):
+        return cast(0)
+    return cast(value)
+
+
+def estimate_entry(entry: dict[str, Any], model: SavingsModel = MODEL) -> dict[str, Any]:
+    files = entry.get("files") or []
+    count = len(files)
+    grep_rounds = 1 + count // 10
+    manual_tokens = grep_rounds * model.grep_tokens + sum(
+        min(_num(f.get("bytes", 0), int) // 4, model.file_token_cap) for f in files if isinstance(f, dict)
+    )
+    manual_seconds = float(grep_rounds * model.grep_seconds + count * model.read_seconds)
+    cost_tokens = _num(entry.get("output_bytes", 0), int) // 4
+    cost_seconds = _num(entry.get("wall_ms", 0), float) / 1000.0
+    return {
+        "tokens_saved": max(0, manual_tokens - cost_tokens),
+        "seconds_saved": max(0.0, manual_seconds - cost_seconds),
+    }
+
+
+def summarize(entries: Iterable[dict[str, Any]], model: SavingsModel = MODEL) -> dict[str, Any]:
+    total_tokens = 0
+    total_seconds = 0.0
+    count = 0
+    by_cmd: dict[str, dict[str, Any]] = {}
+    for entry in entries:
+        est = estimate_entry(entry, model)
+        cmd = str(entry.get("cmd", "unknown"))
+        bucket = by_cmd.setdefault(cmd, {"count": 0, "tokens_saved": 0, "seconds_saved": 0.0})
+        bucket["count"] += 1
+        bucket["tokens_saved"] += est["tokens_saved"]
+        bucket["seconds_saved"] += est["seconds_saved"]
+        total_tokens += est["tokens_saved"]
+        total_seconds += est["seconds_saved"]
+        count += 1
+    return {
+        "count": count,
+        "tokens_saved": total_tokens,
+        "seconds_saved": total_seconds,
+        "by_cmd": by_cmd,
+    }
+
+
+def methodology(model: SavingsModel = MODEL) -> str:
+    return (
+        "All figures are estimates of avoided manual exploration, never measurements. "
+        f"Model: an answer covering K files ~ (1 + K//10) grep rounds x {model.grep_tokens} tokens "
+        f"/ {model.grep_seconds}s each, plus per-file read of min(bytes/4, {model.file_token_cap}) tokens "
+        f"/ {model.read_seconds}s; minus graphite's actual cost (output bytes/4 tokens, measured wall time); "
+        "floored at zero."
+    )
+
+
+def format_compact(tokens: int, seconds: float) -> str:
+    token_text = f"~{tokens / 1000:.1f}k tokens" if tokens >= 1000 else f"~{tokens} tokens"
+    time_text = f"~{seconds / 60:.0f} min" if seconds >= 90 else f"~{seconds:.0f}s"
+    return f"{token_text} / {time_text}"

graphite/ts_bridge.py

@@ -0,0 +1,142 @@
+"""Optional TypeScript compiler bridge for accurate import/export resolution."""
+from __future__ import annotations
+
+import json
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path, PurePosixPath
+from typing import Iterable, Any
+
+from .config import Config
+
+_TS_LANGUAGES = {"javascript", "typescript", "tsx", "jsx"}
+
+
+@dataclass(frozen=True)
+class TypeScriptCompilerEdge:
+    source: str
+    target: str
+    specifier: str
+    syntax: str
+    relation: str
+    confidence: str
+    line: int | None = None
+
+
+@dataclass(frozen=True)
+class TypeScriptCompilerIndex:
+    available: bool
+    reason: str | None = None
+    typescript_version: str | None = None
+    config_path: str | None = None
+    import_map: dict[tuple[str, str], TypeScriptCompilerEdge] = field(default_factory=dict)
+    edges_by_file: dict[str, tuple[TypeScriptCompilerEdge, ...]] = field(default_factory=dict)
+
+    def resolve_import(self, rel_path: str, specifier: str) -> TypeScriptCompilerEdge | None:
+        return self.import_map.get((PurePosixPath(rel_path).as_posix(), specifier))
+
+    def supplemental_edges(self, rel_path: str) -> tuple[TypeScriptCompilerEdge, ...]:
+        return self.edges_by_file.get(PurePosixPath(rel_path).as_posix(), ())
+
+
+_DISABLED = {"0", "false", "off", "none", "disabled", "heuristic"}
+
+
+def build_typescript_index(root: Path, entries: Iterable[object], cfg: Config) -> TypeScriptCompilerIndex:
+    """Build a compiler-backed TS module-resolution index, falling back silently on failure."""
+    mode = cfg.typescript_resolver.strip().lower()
+    if mode in _DISABLED:
+        return TypeScriptCompilerIndex(available=False, reason="disabled")
+
+    rel_files = sorted(
+        PurePosixPath(entry.rel_path).as_posix()
+        for entry in entries
+        if getattr(entry, "language", None) in _TS_LANGUAGES
+    )
+    if not rel_files:
+        return TypeScriptCompilerIndex(available=False, reason="no_typescript_files")
+
+    script = Path(__file__).with_name("ts_resolver.mjs")
+    payload = json.dumps({"root": str(root), "files": rel_files, "symbolReferences": cfg.typescript_symbol_references}, ensure_ascii=False)
+    try:
+        completed = subprocess.run(
+            ["node", str(script)],
+            input=payload,
+            text=True,
+            # Node speaks UTF-8 in both directions, and the payload above is
+            # built with `ensure_ascii=False`, so it carries whatever non-ASCII
+            # appears in a repo's paths or identifiers. Without this the locale
+            # codec is used: on Windows that is cp1252, which cannot ENCODE the
+            # request and cannot DECODE node's reply. A decode failure there is
+            # silent -- it kills subprocess's reader thread and yields None.
+            encoding="utf-8",
+            errors="replace",
+            capture_output=True,
+            cwd=str(Path.cwd()),
+            timeout=cfg.typescript_resolver_timeout_seconds,
+            check=False,
+        )
+    except FileNotFoundError:
+        return TypeScriptCompilerIndex(available=False, reason="node_not_available")
+    except subprocess.TimeoutExpired:
+        return TypeScriptCompilerIndex(available=False, reason="timeout")
+    except Exception as exc:
+        return TypeScriptCompilerIndex(available=False, reason=f"bridge_error: {exc}")
+
+    if completed.returncode != 0:
+        detail = (completed.stderr or completed.stdout or "").strip()[:500]
+        return TypeScriptCompilerIndex(available=False, reason=f"node_exit_{completed.returncode}: {detail}")
+
+    try:
+        data = json.loads(completed.stdout)
+    except json.JSONDecodeError as exc:
+        return TypeScriptCompilerIndex(available=False, reason=f"invalid_json: {exc}")
+
+    if not data.get("ok"):
+        return TypeScriptCompilerIndex(available=False, reason=str(data.get("reason") or "unavailable"))
+
+    import_map: dict[tuple[str, str], TypeScriptCompilerEdge] = {}
+    edges_by_file: dict[str, list[TypeScriptCompilerEdge]] = {}
+    for raw in data.get("edges", []):
+        edge = _edge_from_raw(raw)
+        if edge is None:
+            continue
+        if edge.syntax == "import":
+            import_map[(edge.source, edge.specifier)] = edge
+        else:
+            edges_by_file.setdefault(edge.source, []).append(edge)
+
+    return TypeScriptCompilerIndex(
+        available=True,
+        typescript_version=data.get("typescriptVersion"),
+        config_path=data.get("configPath"),
+        import_map=import_map,
+        edges_by_file={k: tuple(v) for k, v in edges_by_file.items()},
+    )
+
+
+def _edge_from_raw(raw: dict[str, Any]) -> TypeScriptCompilerEdge | None:
+    try:
+        source = PurePosixPath(str(raw["source"])).as_posix()
+        target = PurePosixPath(str(raw["target"])).as_posix()
+        specifier = str(raw["specifier"])
+        syntax = str(raw["syntax"])
+        relation = str(raw["relation"])
+        confidence = str(raw["confidence"])
+        line_raw = raw.get("line")
+        line = int(line_raw) if line_raw is not None else None
+    except (KeyError, TypeError, ValueError):
+        return None
+    if not source or not target or source == target:
+        return None
+    return TypeScriptCompilerEdge(
+        source=source,
+        target=target,
+        specifier=specifier,
+        syntax=syntax,
+        relation=relation,
+        confidence=confidence,
+        line=line,
+    )
+
+