tycho-cli 0.0.1__py3-none-any.whl

tycho/model.py

@@ -0,0 +1,147 @@
+"""Immutable data carriers + enums for the verifier. No I/O."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from enum import StrEnum
+from pathlib import Path
+
+
+class Verdict(StrEnum):
+    """The run-level answer Tycho renders."""
+
+    VERIFIED = "VERIFIED"
+    FAILED = "FAILED"
+    STALE = "STALE"
+    UNSUPPORTED = "UNSUPPORTED"
+    INDETERMINATE = "INDETERMINATE"
+
+
+class CheckStatus(StrEnum):
+    """The per-check outcome. Reduces to a Verdict in verify.verdict_of."""
+
+    PASS = "PASS"
+    FAIL = "FAIL"
+    STALE = "STALE"
+    UNSUPPORTED = "UNSUPPORTED"
+    INDETERMINATE = "INDETERMINATE"
+
+
+@dataclass(frozen=True)
+class CheckResult:
+    """One check's outcome plus the human-readable evidence for it."""
+
+    name: str
+    status: CheckStatus
+    evidence: str
+
+
+@dataclass(frozen=True)
+class Event:
+    """One normalized tool invocation from the harness transcript.
+
+    `ts` is the completion time (result timestamp, falling back to invocation).
+    `is_error` is the harness's failure signal (Bash: non-zero exit or denied);
+    None means no result was captured. `result` holds the structured
+    toolUseResult (Bash: stdout/stderr; Edit/Write: filePath/originalFile/…),
+    or {} when absent or non-structured.
+    """
+
+    ts: float
+    tool: str
+    input: dict = field(default_factory=dict)
+    is_error: bool | None = None
+    result: dict = field(default_factory=dict)
+
+
+@dataclass(frozen=True)
+class Message:
+    """One assistant natural-language message (the agent's prose, not a tool call).
+
+    Carried so `tool_call_provenance` can check the agent's *claims* ("I created the
+    ticket", "I searched the web") against the tool `Event`s that actually happened.
+    Only assistant text is modeled — user prose and tool payloads live elsewhere.
+    """
+
+    ts: float
+    text: str
+
+
+@dataclass(frozen=True)
+class FileEdit:
+    """A file the agent created or edited this session.
+
+    `original` is the file's full content *before* the edit (None for a new
+    file) — enough for the AST checks without touching git.
+    """
+
+    path: str
+    ts: float
+    original: str | None
+    kind: str  # "create" | "edit"
+
+
+@dataclass(frozen=True)
+class FileState:
+    """Working-tree state of one file, read once in gather() so checks stay pure.
+
+    `current_text` is the on-disk content — the "after" side for the AST checks.
+    """
+
+    path: str
+    exists: bool
+    mtime: float | None
+    current_text: str | None
+
+
+@dataclass(frozen=True)
+class GitSnapshot:
+    """Repo state read once in gather()."""
+
+    is_repo: bool
+    head_sha: str | None
+    changed_paths: tuple[str, ...]
+
+
+@dataclass(frozen=True)
+class Session:
+    """The gathered input snapshot the pure checks run against.
+
+    Carries *both* scopes, because the checks genuinely need both (TYCHO-17):
+    "did this turn's edits land?" is a question about `turn_edits`, while "is a
+    source stale against the last green run?" is a question about the whole
+    session — a file edited three turns ago and never retested really is stale.
+    So `turn_start` narrows a *view*; it never narrows `edits`/`events`.
+    """
+
+    events: tuple[Event, ...]
+    edits: tuple[FileEdit, ...]
+    repo: Path
+    config: "Config"  # noqa: F821 — forward ref to tycho.config.Config, avoids import cycle
+    files: Mapping[str, FileState] = field(default_factory=dict)
+    git: GitSnapshot = field(default_factory=lambda: GitSnapshot(False, None, ()))
+    has_tests: bool = True
+    # Assistant prose, for tool_call_provenance. Empty for harnesses whose reader doesn't
+    # supply it (the check then degrades to UNSUPPORTED there, never a false verdict).
+    messages: tuple[Message, ...] = ()
+    # Epoch at which the turn under review began. 0.0 means "the whole transcript is
+    # the turn" — the honest default for `tycho verify` (a manual whole-session audit)
+    # and for harnesses whose readers already hand us a single turn (Codex) or that
+    # don't timestamp events at all (Cursor).
+    turn_start: float = 0.0
+
+    @property
+    def turn_edits(self) -> tuple[FileEdit, ...]:
+        """The edits made by the turn under review (all of them when turn_start is 0.0)."""
+        return tuple(fe for fe in self.edits if fe.ts >= self.turn_start)
+
+    @property
+    def turn_events(self) -> tuple[Event, ...]:
+        """The events of the turn under review (all of them when turn_start is 0.0)."""
+        return tuple(e for e in self.events if e.ts >= self.turn_start)
+
+    @property
+    def turn_messages(self) -> tuple[Message, ...]:
+        """The assistant prose of the turn under review (all when turn_start is 0.0)."""
+        return tuple(m for m in self.messages if m.ts >= self.turn_start)

tycho/opencode.py

@@ -0,0 +1,154 @@
+"""Read OpenCode sessions straight from its SQLite store (``opencode.db``).
+
+OpenCode persists every session in ``~/.local/share/opencode/opencode.db``
+(tables ``session`` / ``message`` / ``part``). Earlier Tycho shelled out to
+``opencode export <id>`` and captured stdout — but that command truncates at a
+fixed 128 KB whenever its stdout is a pipe (a Bun non-blocking-write quirk), so
+every non-trivial session came back as invalid JSON and the verdict was
+silently dropped.
+
+Reading the DB directly is both correct and *standard*: it's the same "read the
+harness's own on-disk store" shape the Claude/Cursor/Codex adapters already use.
+We reconstruct the exact ``{info, messages:[{parts:[…]}]}`` JSON that
+``events.parse_opencode`` already consumes, so normalization is unchanged and the
+OpenCode transcript flows through the identical ``parse → gather → checks``
+pipeline as every other harness.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sqlite3
+import tempfile
+from pathlib import Path
+
+
+def db_path() -> Path:
+    """Location of OpenCode's SQLite store.
+
+    ``TYCHO_OPENCODE_HOME`` (the dir holding ``opencode.db``) wins, then
+    OpenCode's own ``XDG_DATA_HOME``, then the ``~/.local/share`` default. Same
+    override chain as every other harness (``harness.home``) — spelled out here
+    because OpenCode's root is an XDG data dir, not a ``~/.<name>`` dotdir.
+    """
+    override = os.environ.get("TYCHO_OPENCODE_HOME")
+    if override:
+        return Path(override).expanduser() / "opencode.db"
+    data_home = os.environ.get("XDG_DATA_HOME") or str(Path.home() / ".local" / "share")
+    return Path(data_home) / "opencode" / "opencode.db"
+
+
+def _connect(db: Path) -> sqlite3.Connection:
+    """Open the DB read-only — never write to the agent's live store."""
+    conn = sqlite3.connect(f"file:{db}?mode=ro", uri=True, timeout=5)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def latest_session(cwd: Path, db: Path | None = None) -> str | None:
+    """Id of the most-recently-updated session rooted at ``cwd`` (or None).
+
+    This gives OpenCode the same on-disk discovery every other harness has:
+    ``tycho verify`` can find the newest session for a directory with no help
+    from the harness.
+    """
+    db = db or db_path()
+    if not db.is_file():
+        return None
+    try:
+        with _connect(db) as conn:
+            row = conn.execute(
+                "SELECT id FROM session WHERE directory = ? ORDER BY time_updated DESC LIMIT 1",
+                (str(cwd),),
+            ).fetchone()
+    except sqlite3.Error:
+        return None
+    return row["id"] if row else None
+
+
+def _json_object(raw: object) -> dict | None:
+    """Parse a DB ``data`` column into a dict, or None if it isn't one (external data)."""
+    try:
+        value = json.loads(raw)  # type: ignore[arg-type]
+    except (json.JSONDecodeError, TypeError):
+        return None
+    return value if isinstance(value, dict) else None
+
+
+def session_json(session_id: str, cwd: Path, db: Path | None = None) -> dict | None:
+    """Reconstruct one session's export-shaped JSON from the DB (tool parts only).
+
+    Each ``part.data`` row is already the same object ``opencode export`` nests
+    under ``messages[].parts[]`` — carrying ``state.time`` and
+    ``state.metadata.exit`` — so freshness/provenance/command_execution keep
+    working. We drop non-tool parts (text/reasoning/step); ``parse_opencode``
+    ignores them anyway.
+
+    One message in, one message out — parts grouped by ``part.message_id``. This used
+    to flatten every part into a single synthesized ``{"role": "assistant"}`` message
+    and never read the ``message`` table at all, which discarded the user messages
+    entirely. That is why OpenCode had no derivable turn boundary (TYCHO-21): the data
+    was in the DB the whole time, Tycho dropped it before the reader ever saw it. A user
+    message carries no tool parts, so it lands here with ``parts: []`` — kept, because
+    its timestamp is exactly what ``events.turn_start_opencode`` anchors on.
+
+    ``info`` keeps only ``role`` and ``time`` from ``message.data``, not the whole blob:
+    a user message's ``data`` also carries ``summary.diffs`` (full patches) and nothing
+    downstream reads them — no reason to copy that through a temp file on every Stop.
+    """
+    db = db or db_path()
+    if not db.is_file():
+        return None
+    try:
+        with _connect(db) as conn:
+            info = conn.execute(
+                "SELECT id, directory, version FROM session WHERE id = ?", (session_id,)
+            ).fetchone()
+            messages = conn.execute(
+                "SELECT id, data FROM message WHERE session_id = ? ORDER BY time_created ASC",
+                (session_id,),
+            ).fetchall()
+            rows = conn.execute(
+                "SELECT message_id, data FROM part WHERE session_id = ? ORDER BY time_created ASC",
+                (session_id,),
+            ).fetchall()
+    except sqlite3.Error:
+        return None
+
+    parts_by_message: dict[str, list[dict]] = {}
+    for row in rows:
+        part = _json_object(row["data"])
+        if part is not None and part.get("type") == "tool":
+            parts_by_message.setdefault(row["message_id"], []).append(part)
+
+    return {
+        "info": {
+            "id": session_id,
+            "directory": info["directory"] if info else str(cwd),
+            "version": info["version"] if info else "",
+        },
+        "messages": [
+            {
+                "info": {k: v for k, v in data.items() if k in ("role", "time")},
+                "parts": parts_by_message.get(row["id"], []),
+            }
+            for row in messages
+            if (data := _json_object(row["data"])) is not None
+        ],
+    }
+
+
+def materialize(session_id: str, cwd: Path, db: Path | None = None) -> Path | None:
+    """Write a session's reconstructed JSON to a temp file; return its path.
+
+    The caller hands this path to the standard engine (and unlinks it after),
+    so OpenCode reuses ``events.parse_opencode`` with zero special-casing.
+    """
+    data = session_json(session_id, cwd, db)
+    if data is None:
+        return None
+    fd, name = tempfile.mkstemp(suffix=".json", prefix="tycho-opencode-")
+    with os.fdopen(fd, "w", encoding="utf-8") as fh:
+        json.dump(data, fh)
+    return Path(name)

tycho/report.py

@@ -0,0 +1,29 @@
+"""Render a verdict + its check results as the terminal block."""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+
+from .model import CheckResult, CheckStatus, Verdict
+
+_MARK = {
+    CheckStatus.PASS: "✓",
+    CheckStatus.FAIL: "✗",
+    CheckStatus.STALE: "✗",
+    CheckStatus.UNSUPPORTED: "•",
+    CheckStatus.INDETERMINATE: "?",
+}
+
+
+def render(verdict: Verdict, results: Sequence[CheckResult], claim: str | None = None) -> str:
+    """One header line + one line per check (mark, name, evidence).
+
+    ``claim`` (from ``tycho verify --claim``) is echoed verbatim above the verdict so
+    the human can compare what was *said* against what was *proven*. Tycho does not
+    parse or semantically match the claim — structured claim matching is a Pro concern.
+    """
+    lines = [f"🔍 Tycho: {verdict}"]
+    if claim:
+        lines.insert(0, f'   claim: "{claim}"')
+    lines.extend(f"  {_MARK[r.status]} {r.name} — {r.evidence}" for r in results)
+    return "\n".join(lines)

tycho/runlog.py

@@ -0,0 +1,54 @@
+"""Read a test runner's own verdict out of its terminal output. Stdlib `re`, no I/O.
+
+The exit code is the contract Tycho prefers: universal, unambiguous, and impossible for a
+runner to get wrong. This module is the fallback for when that contract isn't available —
+the shell masked the status (`pytest; echo done`), or the harness never recorded one. In
+those cases the runner's own summary line is the best remaining evidence, and it *is*
+evidence: the runner reporting on itself, not us inferring from silence.
+
+Kept out of `checks.py` (which owns *which commands are runners*) and out of `events.py`
+(which owns *what a harness transcript looks like*) because both need this and neither
+should import the other. Codex has read its exit status out of this text since the adapter
+landed; this is that knowledge, in one place, for every caller.
+
+Failure is checked before success on purpose: a red summary names both ("1 failed, 76
+passed in 1.07s"), so asking "did anything fail?" first is the only order that can't read
+a red run as green.
+
+**`.pytest_cache` looks like a better source than this and is not — don't reach for it.**
+It is the obvious idea (filesystem truth, immune to truncation and to harnesses that keep
+no output), and it is wrong: `v/cache/lastfailed` is not a record of the last run. pytest
+seeds it from the previous value and only *removes* an entry when that test runs and
+passes, so an entry for a test that was deselected, renamed, or deleted persists forever.
+Measured on this repo: `lastfailed` named a test that no longer exists, and survived a
+fully green 316-test run untouched — the file isn't even rewritten when nothing changed,
+so its mtime can't date the run either. A check trusting it would report FAILED on a green
+repo, which is the one failure this program must never have.
+"""
+
+from __future__ import annotations
+
+import re
+
+# "1 failed", "3 errors", "=== ERRORS ===". The [1-9] guard matters: a runner that prints
+# "0 failed" is reporting success, and a bare `\d+` would read it as the exact opposite.
+_FAILURE = re.compile(r"\b[1-9]\d* (?:failed|errors?)\b|=+ ERRORS =+")
+
+# "77 passed in 0.79s" — the count and the duration together. Requiring the duration is
+# what keeps a stray "5 passed" in someone's prose from counting as a run that happened.
+_SUCCESS = re.compile(r"\b\d+ passed\b.*?\bin \d+(?:\.\d+)?s\b", re.DOTALL)
+
+
+def outcome(text: str) -> bool | None:
+    """True = the runner reported failures, False = it reported success, None = can't tell.
+
+    None is the common case and the honest one: no recognized summary means no verdict,
+    never an assumed pass. Mirrors `Event.is_error` so callers can treat the two alike.
+    """
+    if not text:
+        return None
+    if _FAILURE.search(text):
+        return True
+    if _SUCCESS.search(text):
+        return False
+    return None