git-repokit 0.9.10__py3-none-any.whl

repokit/__main__.py

@@ -0,0 +1,12 @@
+#!/usr/bin/env python3
+"""
+RepoKit: Repository Template Generator
+
+Main entry point for the package.
+"""
+
+import sys
+from .cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

repokit/__version__.py

@@ -0,0 +1,4 @@
+"""Version information for RepoKit."""
+
+__version__ = "0.9.10"
+__version_info__ = tuple(int(part) for part in __version__.split("."))

repokit/_vendor/ailib/__init__.py

@@ -0,0 +1 @@
+"""AI analysis pipeline for wtf-windows diagnostic tools."""

repokit/_vendor/ailib/analyzer.py

@@ -0,0 +1,177 @@
+"""Shared AI analysis pipeline for wtf-windows diagnostic tools.
+
+Orchestrates prompt building, backend invocation, and response parsing.
+Each tool supplies its own domain-specific functions:
+
+    from wtf_windows.lib.ai.analyzer import analyze
+
+    result = analyze(
+        results=investigation_data,
+        fingerprint_fn=my_stable_fields,    # tool-specific cache fingerprint
+        prompt_path=Path("prompts/diagnose.md"),
+        cache_dir=Path.home() / ".wtf-locked" / "cache",
+        tool_name="locked",
+    )
+
+The analyzer handles caching, backend dispatch, and response parsing.
+Tools handle what makes their events semantically unique.
+"""
+
+import hashlib
+import json
+import re
+import sys
+import time
+from pathlib import Path
+from typing import Any, Callable, Dict, List, Optional, Tuple
+
+from .backend import build as _build
+from .cache import run as _run
+from .parsers import sections as _sections
+from .types import Request as _Request, Spec as _Spec
+
+
+# The three names the ORIGINAL front door knew, as specs over the object
+# model. This is the shim's table, not a registry: a consumer that wants
+# its own names keeps them on its own side and builds specs itself. The argv
+# is what the original backends ran; the prompt-only directory is the
+# original default.
+#
+# COMPAT(remove-after: wtf locked migrates to build/run)
+_COMPAT_PRESETS = {
+    "claude": _Spec("cli", name="claude",
+                    command=("claude", "--output-format", "text", "-p", "-"),
+                    env_unset=("CLAUDECODE", "CLAUDE_CODE_ENTRYPOINT"),
+                    candidates=("~/.local/bin/claude.exe", "~/.local/bin/claude"), on_prem=False),
+    "codex": _Spec("cli", name="codex",
+                   command=("codex", "exec", "--skip-git-repo-check", "-"),
+                   candidates=("%APPDATA%/npm/codex.cmd",
+                               "%LOCALAPPDATA%/Microsoft/WinGet/Links/codex.cmd"), on_prem=False),
+    "prompt-only": _Spec("prompt-file", name="prompt-only",
+                         endpoint=str(Path.home() / ".wtf-windows" / "ai")),
+}
+
+def check_available(backend_name="claude"):
+    """Whether one of the original three backends is ready, by name.
+
+    A thin wrapper: the answer is `build(spec).probe().ok` for the spec the
+    name maps to. A consumer on the object model asks its backend directly.
+
+    COMPAT(remove-after: wtf locked migrates to build/run)
+    """
+    spec = _COMPAT_PRESETS.get(backend_name)
+    if spec is None:
+        return False
+    return _build(spec).probe().ok
+
+
+def build_prompt(results, prompt_path, clean_fn=None):
+    """Build the AI analysis prompt from investigation results.
+
+    Args:
+        results: dict from the tool's investigation
+        prompt_path: Path to the tool's prompt template (.md file)
+        clean_fn: Optional function to clean results before embedding in prompt
+                  (e.g., removing large raw_output fields to save tokens)
+
+    Returns:
+        str: The complete prompt text
+    """
+    template = prompt_path.read_text(encoding="utf-8")
+
+    evidence = clean_fn(results) if clean_fn else results
+    evidence_json = json.dumps(evidence, indent=2, default=str)
+
+    # Replace template placeholders
+    prompt = template.replace("{evidence_json}", evidence_json)
+
+    # Optional dump section (for tools that include crash dump analysis)
+    dump_section = ""
+    raw_output = (results.get("dump_analysis") or {}).get("raw_output")
+    if raw_output:
+        lines = raw_output.splitlines()
+        if len(lines) > 200:
+            raw_output = "\n".join(lines[-200:])
+            raw_output = f"[...truncated to last 200 lines...]\n{raw_output}"
+        dump_section = (
+            "\n## Crash Dump Analysis (kd.exe !analyze -v output)\n\n"
+            f"```\n{raw_output}\n```\n"
+        )
+    prompt = prompt.replace("{dump_section}", dump_section)
+
+    return prompt
+
+
+def analyze(
+    results,
+    fingerprint_fn,
+    prompt_path,
+    cache_dir,
+    tool_name,
+    backend_name="claude",
+    clean_fn=None,
+    response_sections=None,
+    verbose=False,
+    timeout=120,
+    refresh=False,
+):
+    """Run AI analysis on investigation results.
+
+    Args:
+        results: dict from the tool's investigation
+        fingerprint_fn: Callable[[dict], dict] -- extracts stable fields for
+            cache key. Each tool defines what makes its events unique.
+        prompt_path: Path to the tool's prompt template
+        cache_dir: Path to the tool's cache directory
+        tool_name: Tool identifier (included in cache key)
+        backend_name: which AI backend to use (claude, codex, prompt-only)
+        clean_fn: Optional callable to clean results before prompt building
+        response_sections: Optional list of (key, regex_label) for parsing.
+            Defaults to What Happened / Why / What To Do / Confidence.
+        verbose: stream output in real-time
+        timeout: seconds before timing out
+        refresh: bypass cache (re-run analysis)
+
+    Returns:
+        dict with keys:
+            success: bool
+            raw_response: str
+            sections: dict (parsed sections)
+            error: str or None
+            cached: bool (if from cache)
+            cached_at: float (if from cache)
+
+    This is the ORIGINAL front door, kept with its signature and its result
+    shape for the one live caller that still uses it (wtf-windows'
+    `wtf locked --ai`, tools/core/locked/locked.py). It is a thin wrapper:
+    the prompt comes from `build_prompt`, the backend from the three-name
+    table above, the answer from `cache.run` over `backend.build`, the
+    sections from `parsers.sections`. No logic of its own. The migration is
+    one call: `run(build(spec), Request(prompt), cache_dir=..., ...)`.
+
+    COMPAT(remove-after: wtf locked migrates to build/run)
+    """
+    spec = _COMPAT_PRESETS.get(backend_name)
+    if spec is None:
+        return {"success": False, "raw_response": "", "sections": {},
+                "error": f"Unknown AI backend: {backend_name!r}. Available: {', '.join(_COMPAT_PRESETS)}"}
+    backend = _build(spec)
+    ready = backend.probe()
+    if not ready.ok:
+        return {"success": False, "raw_response": "", "sections": {},
+                "error": f"AI backend '{backend_name}' is not available ({ready.reason})"}
+    prompt = build_prompt(results, prompt_path, clean_fn)
+    req = _Request(prompt=prompt, timeout=timeout, stream_to=sys.stdout if verbose else None)
+    resp = _run(backend, req, cache_dir=Path(cache_dir), fingerprint_extra=fingerprint_fn(results),
+                refresh=refresh, tool=tool_name)
+    if resp.status == "deferred":
+        return {"success": False, "raw_response": "", "sections": {},
+                "error": f"Prompt saved to: {resp.artifact}"}
+    if not resp.ok:
+        return {"success": False, "raw_response": resp.error, "sections": {}, "error": resp.error}
+    result = {"success": True, "raw_response": resp.text,
+              "sections": _sections(resp.text, response_sections), "error": None}
+    if resp.cached:
+        result["cached"] = True
+        result["cached_at"] = resp.cached_at
+    return result

repokit/_vendor/ailib/backend.py

@@ -0,0 +1,95 @@
+"""The AI object: a `Spec` bound to a `Transport`.
+
+A backend holds its spec and delegates to a transport. It keeps no module
+state, so two backends built from two specs can live in one process -- for
+a caller that asks several models in one run, or one that lives longer than
+a single call -- and neither can leak into the other.
+
+Transports are registered by name. The three shipped here are lazily
+imported the first time a backend is built; a consumer (or a test) may
+register its own with `register_transport`.
+"""
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+from .types import Readiness, Request, Response, Spec
+
+
+@runtime_checkable
+class Transport(Protocol):
+    """One per WAY OF REACHING a model. Stateless: everything comes from the
+    spec it is handed, so the same transport object serves every backend
+    built over it."""
+
+    def probe(self, spec: Spec) -> Readiness: ...
+    def invoke(self, spec: Spec, req: Request) -> Response: ...
+    def capabilities(self, spec: Spec) -> frozenset[str]: ...
+
+
+_TRANSPORTS: dict[str, Transport] = {}
+_BUILTIN = ("cli", "openai_compat", "prompt-file")
+
+
+def register_transport(name: str, transport: Transport | None) -> None:
+    """Add a transport under `name`, or remove it with None."""
+    if transport is None:
+        _TRANSPORTS.pop(name, None)
+    else:
+        _TRANSPORTS[name] = transport
+
+
+def _ensure_builtins() -> None:
+    if all(n in _TRANSPORTS for n in _BUILTIN):
+        return
+    from .transports import cli, openai_compat, prompt_file
+    _TRANSPORTS.setdefault("cli", cli.SubprocessCli())
+    # "openai_compat": the OpenAI-compatible wire format every local and
+    # hosted server speaks (LM Studio, Ollama, OpenRouter, OpenAI itself).
+    # Named for the protocol, not the company, so a preset called "openai"
+    # (the hosted API) is one of several riding it and never read as the
+    # transport itself.
+    _TRANSPORTS.setdefault("openai_compat", openai_compat.OpenAICompatible())
+    _TRANSPORTS.setdefault("prompt-file", prompt_file.PromptFile())
+
+
+def transport_names() -> list[str]:
+    _ensure_builtins()
+    return sorted(_TRANSPORTS)
+
+
+def transport_for(name: str) -> Transport:
+    _ensure_builtins()
+    try:
+        return _TRANSPORTS[name]
+    except KeyError:
+        raise ValueError(f"unknown transport {name!r} -- one of: {', '.join(sorted(_TRANSPORTS))}") from None
+
+
+class Backend:
+    """The object a caller talks to. Build one with `build(spec)`."""
+
+    def __init__(self, spec: Spec):
+        self.spec = spec
+        self._transport = transport_for(spec.transport)
+
+    @property
+    def identity(self) -> str:
+        return self.spec.identity()
+
+    @property
+    def capabilities(self) -> frozenset[str]:
+        return frozenset(self._transport.capabilities(self.spec))
+
+    def probe(self) -> Readiness:
+        return self._transport.probe(self.spec)
+
+    def invoke(self, req: Request) -> Response:
+        return self._transport.invoke(self.spec, req)
+
+    def __repr__(self) -> str:
+        return f"Backend({self.spec.name or self.spec.transport}: {self.identity})"
+
+
+def build(spec: Spec) -> Backend:
+    return Backend(spec)

repokit/_vendor/ailib/cache.py

@@ -0,0 +1,97 @@
+"""`run()` -- ask a backend through a cache.
+
+The key is the backend's own identity plus the request's fingerprint plus
+whatever facts the caller adds (a merge tool adds the three sides and its
+rules; a diagnostic tool adds the event's stable fields), so the caller
+never learns which backend facts matter for which transport. A hit
+reproduces the response the backend gave, marked cached. Nothing is written
+for a deferred or failed answer. A refresh skips the read and still writes.
+
+A write also sweeps entries older than the TTL from the cache directory
+under ANY file name: an entry that is never looked up again would otherwise
+never expire.
+"""
+from __future__ import annotations
+
+import hashlib
+import json
+import time
+from pathlib import Path
+from typing import Any
+
+from .backend import Backend
+from .types import Request, Response
+
+CACHE_TTL_SECONDS = 24 * 60 * 60
+
+
+def _now() -> float:            # a seam for tests
+    return time.time()
+
+
+def cache_key(backend: Backend, req: Request, extra: dict[str, Any] | None, tool: str) -> str:
+    payload = json.dumps({"identity": backend.identity, "request": req.fingerprint(),
+                          "extra": extra or {}, "tool": tool}, sort_keys=True, default=str)
+    return hashlib.sha256(payload.encode("utf-8")).hexdigest()[:16]
+
+
+def _path(cache_dir: Path, tool: str, backend: Backend, key: str) -> Path:
+    return Path(cache_dir) / f"{tool}_{backend.spec.name or backend.spec.transport}_{key}.json"
+
+
+def _read(path: Path) -> dict | None:
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+        if _now() - float(data.get("cached_at", 0)) > CACHE_TTL_SECONDS:
+            return None
+        resp = data.get("response")
+        if not isinstance(resp, dict) or not resp.get("text"):
+            return None
+        resp["cached_at"] = float(data["cached_at"])
+        return resp
+    except (OSError, ValueError, TypeError, KeyError):
+        return None
+
+
+def _write(path: Path, backend: Backend, resp: Response) -> None:
+    try:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        body = {"cached_at": _now(), "identity": backend.identity,
+                "response": {"text": resp.text, "model_used": resp.model_used,
+                             "honoured": list(resp.honoured), "elapsed": resp.elapsed}}
+        path.write_text(json.dumps(body, indent=1, default=str), encoding="utf-8")
+    except OSError:
+        pass                                             # a cache miss next time; not fatal
+
+
+def _sweep(cache_dir: Path) -> None:
+    cutoff = _now() - CACHE_TTL_SECONDS
+    try:
+        for p in Path(cache_dir).glob("*.json"):
+            try:
+                if float(json.loads(p.read_text(encoding="utf-8")).get("cached_at", 0)) < cutoff:
+                    p.unlink()
+            except (OSError, ValueError, TypeError, AttributeError):
+                continue
+    except OSError:
+        pass
+
+
+def run(backend: Backend, req: Request, *, cache_dir: Path | str,
+        fingerprint_extra: dict[str, Any] | None = None, refresh: bool = False,
+        tool: str = "ai") -> Response:
+    """Ask `backend` for `req`, through the cache under `cache_dir`."""
+    cache_dir = Path(cache_dir)
+    key = cache_key(backend, req, fingerprint_extra, tool)
+    path = _path(cache_dir, tool, backend, key)
+    if not refresh:
+        hit = _read(path)
+        if hit:
+            return Response("answered", text=hit["text"], model_used=hit.get("model_used", ""),
+                            honoured=tuple(hit.get("honoured", ())), elapsed=float(hit.get("elapsed", 0)),
+                            cached=True, cached_at=hit["cached_at"], key=key)
+    resp = backend.invoke(req).with_(key=key)
+    if resp.status == "answered":
+        _write(path, backend, resp)
+        _sweep(cache_dir)
+    return resp

repokit/_vendor/ailib/parsers.py

@@ -0,0 +1,52 @@
+"""Readers a caller chooses from. The library never interprets an answer; it
+offers two ways to read one and the caller picks the one its prompt asked
+for. A merge tool wants one fenced JSON object; a diagnostic tool wants
+labelled prose sections. Neither shape is this library's.
+"""
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+_FENCE = re.compile(r"```json\s*\n(.*?)\n\s*```", re.DOTALL)
+
+#: The labelled-prose shape the original diagnostic tools ask for.
+DEFAULT_SECTIONS: list[tuple[str, str]] = [
+    ("what_happened", r"What Happened:"),
+    ("why", r"Why:"),
+    ("what_to_do", r"What To Do:"),
+    ("confidence", r"Confidence:"),
+]
+
+
+def json_block(text: str) -> Any | None:
+    """The LAST fenced ```json block in `text`, parsed; None when there is
+    none or it does not parse. The last one, because a model that thinks
+    aloud tends to draft and then answer."""
+    blocks = _FENCE.findall(text or "")
+    if not blocks:
+        return None
+    try:
+        return json.loads(blocks[-1])
+    except ValueError:
+        return None
+
+
+def sections(text: str, labels: list[tuple[str, str]] | None = None) -> dict[str, str]:
+    """Split labelled prose into a dict by the caller's labels -- each a
+    (key, regex) pair, in the order they appear. When nothing matches, the
+    whole text comes back under "raw", so a caller always has something to
+    show."""
+    labels = labels or DEFAULT_SECTIONS
+    out: dict[str, str] = {}
+    for i, (key, pattern) in enumerate(labels):
+        rest = [p for _, p in labels[i + 1:]]
+        regex = (rf"{pattern}\s*(.*?)(?=(?:{'|'.join(rest)})|\Z)" if rest
+                 else rf"{pattern}\s*(.*)")
+        m = re.search(regex, text or "", re.DOTALL)
+        if m:
+            out[key] = m.group(1).strip()
+    if not out:
+        out["raw"] = (text or "").strip()
+    return out

repokit/_vendor/ailib/transports/__init__.py

@@ -0,0 +1,16 @@
+"""One transport per WAY OF REACHING a model.
+
+`cli`         -- an executable, argv from a template, the prompt on stdin
+                 (claude, codex, and any CLI-shaped agent)
+`openai`      -- an OpenAI-compatible HTTP server: LM Studio and Ollama on
+                 this machine, OpenAI, OpenRouter and the rest over the wire;
+                 local versus remote is the endpoint and whether a credential
+                 is named
+`prompt-file` -- not a model: writes the request where a person can carry it,
+                 and answers "deferred"
+
+Transports are stateless. Everything comes from the `Spec` they are handed,
+so one transport object serves every backend built over it and two backends
+cannot leak into each other. The protocol they implement is
+`backend.Transport`; they are registered in `backend._TRANSPORTS` by name.
+"""