verifaied 0.1.0.dev28__tar.gz → 0.1.0.dev29__tar.gz

verifaied-0.1.0.dev29/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kyle Richards
+
+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.

verifaied-0.1.0.dev28/README.md → verifaied-0.1.0.dev29/PKG-INFO

@@ -1,6 +1,56 @@
+Metadata-Version: 2.4
+Name: verifaied
+Version: 0.1.0.dev29
+Summary: Find what's untested in your Python code — locally, no account required
+Project-URL: Homepage, https://pypi.org/project/verifaied/
+Author: Kyle Richards
+License: MIT License
+        
+        Copyright (c) 2026 Kyle Richards
+        
+        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.
+License-File: LICENSE
+Keywords: agents,ai,coverage,llm,pytest,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: rich>=13.7.0
+Requires-Dist: typer>=0.12.0
+Description-Content-Type: text/markdown
+
 # verifaied
 
-CLI for uploading local pytest coverage to verifAIed so an LLM (or you) can see what's untested without waiting for CI.
+Find what's untested in your Python code, so you (or your coding agent) can fix
+it without waiting for CI.
+
+Two verbs:
+
+- **`verifaied check`** — runs entirely on your machine. No account, no API
+  token, no network call. Tells you which functions are untested or only
+  partially covered, and can hand you a ready-to-paste prompt for each one.
+- **`verifaied upload`** — syncs the same coverage to the [verifAIed](https://verifaied.app)
+  app, which adds history, branch diffing against CI, a web UI, and AI-written
+  test prompts. Needs a free account.
 
 ## Install
 
@@ -9,12 +59,57 @@ uv tool install verifaied        # or
 pipx install verifaied
 ```
 
-## Configure
+## `verifaied check` — local, no account
+
+```bash
+pytest --cov --cov-branch --cov-report=json
+verifaied check
+```
+
+```
+  12 covered  3 partial  2 untested   (17 functions)
+
+   function        file                   missing
+●  apply_topup     app/billing.py:41      42-47
+●  refund          app/billing.py:60      61-68
+◐  _resolve_plan   app/plans.py:12        18
+```
+
+Nothing leaves your machine — the whole analysis is a local AST pass over the
+source `coverage.json` already points at.
 
-Set the API token (mint one from the verifAIed app). The CLI ships
-pointing at the hosted verifAIed API (`https://api.verifaied.app`) by
-default; point it elsewhere via `VERIFAIED_API_URL` if you're running
-the backend locally or self-hosting:
+Add `--prompt` to get a concrete, ready-to-paste instruction for each one,
+generated from the function's signature and its uncovered lines (no LLM, no
+cost, unlimited):
+
+```bash
+verifaied check --prompt
+```
+
+```
+Write a pytest test for `apply_topup` in `app/billing.py`.
+
+This function is currently **untested** — no line of it executes under the
+existing suite.
+
+What to do:
+- Call `apply_topup(user_id, amount)`.
+- Assert on the **return value** — compare it to the exact expected value.
+- Cover the lines that never execute: **42-47**.
+- It raises `ValueError` — cover that path with `pytest.raises(ValueError)`.
+```
+
+Useful flags: `--limit N` (how many to list, `0` for all), `--root <path>` (the
+directory the coverage paths are relative to — pytest's rootdir), and
+`--fail-under <pct>`, which exits `3` when too few functions are fully covered,
+so `check` works as a CI gate.
+
+## `verifaied upload` — sync to the app
+
+Mint an API token from the verifAIed app (Settings → Tokens; a free account is
+enough). The CLI ships pointing at the hosted API (`https://api.verifaied.app`);
+point it elsewhere via `VERIFAIED_API_URL` if you're running the backend locally
+or self-hosting:
 
 ```bash
 export VERIFAIED_API_TOKEN=vr_live_...
@@ -22,8 +117,6 @@ export VERIFAIED_API_TOKEN=vr_live_...
 export VERIFAIED_API_URL=http://localhost:8000   # local dev
 ```
 
-## Use
-
 From inside any git repo you've connected to verifAIed:
 
 ```bash
@@ -76,7 +169,7 @@ expand **Recently deleted** under the branches grid, and use
 to the uploaded source — the per-card **Delete** is a soft-delete that
 keeps the data around for accidental-deletion recovery.
 
-### Flags
+### `upload` flags
 
 - `--repo / -r <UUID|owner/name>` — repository to upload to. If omitted,
   the CLI auto-detects from the GitHub `origin` remote.

verifaied-0.1.0.dev28/PKG-INFO → verifaied-0.1.0.dev29/README.md

@@ -1,24 +1,16 @@
-Metadata-Version: 2.4
-Name: verifaied
-Version: 0.1.0.dev28
-Summary: Upload local pytest coverage to verifAIed for instant feedback
-Project-URL: Homepage, https://pypi.org/project/verifaied/
-Author: Kyle Richards
-License: MIT
-Keywords: ai,coverage,llm,pytest,testing
-Classifier: Development Status :: 3 - Alpha
-Classifier: Environment :: Console
-Classifier: Intended Audience :: Developers
-Classifier: Topic :: Software Development :: Testing
-Requires-Python: >=3.10
-Requires-Dist: httpx>=0.27.0
-Requires-Dist: rich>=13.7.0
-Requires-Dist: typer>=0.12.0
-Description-Content-Type: text/markdown
-
 # verifaied
 
-CLI for uploading local pytest coverage to verifAIed so an LLM (or you) can see what's untested without waiting for CI.
+Find what's untested in your Python code, so you (or your coding agent) can fix
+it without waiting for CI.
+
+Two verbs:
+
+- **`verifaied check`** — runs entirely on your machine. No account, no API
+  token, no network call. Tells you which functions are untested or only
+  partially covered, and can hand you a ready-to-paste prompt for each one.
+- **`verifaied upload`** — syncs the same coverage to the [verifAIed](https://verifaied.app)
+  app, which adds history, branch diffing against CI, a web UI, and AI-written
+  test prompts. Needs a free account.
 
 ## Install
 
@@ -27,12 +19,57 @@ uv tool install verifaied        # or
 pipx install verifaied
 ```
 
-## Configure
+## `verifaied check` — local, no account
+
+```bash
+pytest --cov --cov-branch --cov-report=json
+verifaied check
+```
+
+```
+  12 covered  3 partial  2 untested   (17 functions)
+
+   function        file                   missing
+●  apply_topup     app/billing.py:41      42-47
+●  refund          app/billing.py:60      61-68
+◐  _resolve_plan   app/plans.py:12        18
+```
+
+Nothing leaves your machine — the whole analysis is a local AST pass over the
+source `coverage.json` already points at.
 
-Set the API token (mint one from the verifAIed app). The CLI ships
-pointing at the hosted verifAIed API (`https://api.verifaied.app`) by
-default; point it elsewhere via `VERIFAIED_API_URL` if you're running
-the backend locally or self-hosting:
+Add `--prompt` to get a concrete, ready-to-paste instruction for each one,
+generated from the function's signature and its uncovered lines (no LLM, no
+cost, unlimited):
+
+```bash
+verifaied check --prompt
+```
+
+```
+Write a pytest test for `apply_topup` in `app/billing.py`.
+
+This function is currently **untested** — no line of it executes under the
+existing suite.
+
+What to do:
+- Call `apply_topup(user_id, amount)`.
+- Assert on the **return value** — compare it to the exact expected value.
+- Cover the lines that never execute: **42-47**.
+- It raises `ValueError` — cover that path with `pytest.raises(ValueError)`.
+```
+
+Useful flags: `--limit N` (how many to list, `0` for all), `--root <path>` (the
+directory the coverage paths are relative to — pytest's rootdir), and
+`--fail-under <pct>`, which exits `3` when too few functions are fully covered,
+so `check` works as a CI gate.
+
+## `verifaied upload` — sync to the app
+
+Mint an API token from the verifAIed app (Settings → Tokens; a free account is
+enough). The CLI ships pointing at the hosted API (`https://api.verifaied.app`);
+point it elsewhere via `VERIFAIED_API_URL` if you're running the backend locally
+or self-hosting:
 
 ```bash
 export VERIFAIED_API_TOKEN=vr_live_...
@@ -40,8 +77,6 @@ export VERIFAIED_API_TOKEN=vr_live_...
 export VERIFAIED_API_URL=http://localhost:8000   # local dev
 ```
 
-## Use
-
 From inside any git repo you've connected to verifAIed:
 
 ```bash
@@ -94,7 +129,7 @@ expand **Recently deleted** under the branches grid, and use
 to the uploaded source — the per-card **Delete** is a soft-delete that
 keeps the data around for accidental-deletion recovery.
 
-### Flags
+### `upload` flags
 
 - `--repo / -r <UUID|owner/name>` — repository to upload to. If omitted,
   the CLI auto-detects from the GitHub `origin` remote.

{verifaied-0.1.0.dev28 → verifaied-0.1.0.dev29}/pyproject.toml

@@ -1,16 +1,17 @@
 [project]
 name = "verifaied"
-version = "0.1.0.dev28"
-description = "Upload local pytest coverage to verifAIed for instant feedback"
+version = "0.1.0.dev29"
+description = "Find what's untested in your Python code — locally, no account required"
 readme = "README.md"
 requires-python = ">=3.10"
-license = { text = "MIT" }
+license = { file = "LICENSE" }
 authors = [{ name = "Kyle Richards" }]
-keywords = ["pytest", "coverage", "testing", "ai", "llm"]
+keywords = ["pytest", "coverage", "testing", "ai", "llm", "agents"]
 classifiers = [
     "Development Status :: 3 - Alpha",
     "Environment :: Console",
     "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
     "Topic :: Software Development :: Testing",
 ]
 dependencies = [

verifaied-0.1.0.dev29/src/verifaied/analyzer.py

@@ -0,0 +1,208 @@
+"""Local, offline coverage analysis — the zero-account core.
+
+This is what makes ``verifaied check`` work with no API token, no
+network, and no account: everything needed to answer "what's untested in
+my code" is already on disk after a pytest run. The hosted service adds
+history, branch diffing against CI, the web UI, LLM prompts and team
+surfaces — none of which this module needs.
+
+It is a deliberate, self-contained reimplementation of the same AST +
+coverage join the backend does, using nothing but the standard library.
+Keeping it dependency-free (no SQLAlchemy, no FastAPI, no pydantic) is
+the point: this is the piece that can be read, trusted, and run by
+someone who has never heard of the hosted product.
+"""
+
+from __future__ import annotations
+
+import ast
+from dataclasses import dataclass, field
+from pathlib import Path
+
+# Coverage states, matching the hosted product's vocabulary so the CLI
+# and the web UI describe the same function the same way.
+UNTESTED = "untested"
+PARTIAL = "partial"
+COVERED = "covered"
+
+
+@dataclass(frozen=True)
+class FunctionResult:
+    """One function's coverage verdict."""
+
+    name: str
+    file_path: str
+    start_line: int
+    end_line: int
+    state: str
+    line_coverage_pct: float
+    missing_lines: list[int] = field(default_factory=list)
+    partial_branch_lines: list[int] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class CheckSummary:
+    """The whole run. ``files_missing`` names source files that coverage
+    referenced but we couldn't read — surfaced rather than swallowed, so
+    a wrong ``--root`` shows up as a loud "0 functions matched" instead of
+    a confident, empty, wrong answer."""
+
+    functions: list[FunctionResult]
+    files_missing: list[str] = field(default_factory=list)
+
+    @property
+    def untested(self) -> list[FunctionResult]:
+        return [f for f in self.functions if f.state == UNTESTED]
+
+    @property
+    def partial(self) -> list[FunctionResult]:
+        return [f for f in self.functions if f.state == PARTIAL]
+
+    @property
+    def covered(self) -> list[FunctionResult]:
+        return [f for f in self.functions if f.state == COVERED]
+
+
+@dataclass(frozen=True)
+class _Extracted:
+    name: str
+    start_line: int
+    end_line: int
+    def_line: int
+
+
+def _decorated_start(node: ast.FunctionDef | ast.AsyncFunctionDef) -> int:
+    if not node.decorator_list:
+        return node.lineno
+    return min(d.lineno for d in node.decorator_list)
+
+
+def extract_functions(source: str) -> list[_Extracted]:
+    """Every function/method/nested-def in the source, with dotted
+    qualified names (``Class.method``, ``outer.inner``).
+
+    The line range includes decorator lines, matching how the hosted
+    analyzer reports them — so ``@pytest.fixture`` above a ``def`` is part
+    of the function for display purposes. ``def_line`` is kept separately
+    because that's the line coverage attributes the signature to.
+    """
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return []
+
+    out: list[_Extracted] = []
+
+    def walk(body: list[ast.stmt], prefix: str) -> None:
+        for node in body:
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                qn = f"{prefix}{node.name}" if prefix else node.name
+                out.append(
+                    _Extracted(
+                        name=qn,
+                        start_line=_decorated_start(node),
+                        end_line=node.end_lineno or node.lineno,
+                        def_line=node.lineno,
+                    )
+                )
+                walk(node.body, f"{qn}.")
+            elif isinstance(node, ast.ClassDef):
+                cn = f"{prefix}{node.name}." if prefix else f"{node.name}."
+                walk(node.body, cn)
+
+    walk(tree.body, "")
+    return out
+
+
+def _state_for(executed: int, total: int, partial_branches: int) -> tuple[str, float]:
+    """Classify a function from its line counts.
+
+    Mirrors the hosted ``_metrics_from_coverage``: nothing executed →
+    untested; everything executed *and* no half-taken branch → covered;
+    anything else → partial. A function with no measurable statements
+    (an ``...`` stub, a pure overload) is reported covered rather than
+    untested — there is nothing there to test, and flagging it would be
+    noise that trains people to ignore the tool.
+    """
+    if total == 0:
+        return COVERED, 100.0
+    if executed == 0:
+        return UNTESTED, 0.0
+    pct = 100.0 * executed / total
+    if executed == total and partial_branches == 0:
+        return COVERED, 100.0
+    return PARTIAL, pct
+
+
+def _partial_branch_lines(file_cov: dict) -> set[int]:
+    """Lines where a branch was taken one way but not the other.
+
+    ``coverage.json`` reports these as ``missing_branches`` entries
+    ``[source_line, destination_line]``; the source line is the one the
+    user has to write another case for. Absent when pytest-cov ran
+    without ``--cov-branch``, which is fine — the result is simply no
+    partial-branch detail, not a crash.
+    """
+    out: set[int] = set()
+    for entry in file_cov.get("missing_branches") or []:
+        if isinstance(entry, list) and entry:
+            src = entry[0]
+            if isinstance(src, int) and src > 0:
+                out.add(src)
+    return out
+
+
+def analyze_coverage(
+    coverage_json: dict,
+    *,
+    root: Path,
+) -> CheckSummary:
+    """Join ``coverage.json`` against the source on disk.
+
+    ``coverage_json["files"]`` keys are paths relative to pytest's
+    rootdir; ``root`` is that rootdir. A file coverage mentions but we
+    cannot read (wrong ``--root``, file deleted since the run) is recorded
+    in ``files_missing`` rather than silently skipped.
+    """
+    files = coverage_json.get("files") or {}
+    results: list[FunctionResult] = []
+    missing: list[str] = []
+
+    for file_path, file_cov in sorted(files.items()):
+        source_path = root / file_path
+        try:
+            source = source_path.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            missing.append(file_path)
+            continue
+
+        executed = set(file_cov.get("executed_lines") or [])
+        missed = set(file_cov.get("missing_lines") or [])
+        partial_lines = _partial_branch_lines(file_cov)
+
+        for fn in extract_functions(source):
+            # Only lines coverage actually tracks count. Blank lines,
+            # comments and the decorator lines we folded into the range
+            # are not statements, so counting them would understate
+            # coverage for every decorated function.
+            span = range(fn.def_line, fn.end_line + 1)
+            fn_executed = {ln for ln in span if ln in executed}
+            fn_missed = {ln for ln in span if ln in missed}
+            total = len(fn_executed) + len(fn_missed)
+            fn_partial = sorted(ln for ln in span if ln in partial_lines)
+
+            state, pct = _state_for(len(fn_executed), total, len(fn_partial))
+            results.append(
+                FunctionResult(
+                    name=fn.name,
+                    file_path=file_path,
+                    start_line=fn.start_line,
+                    end_line=fn.end_line,
+                    state=state,
+                    line_coverage_pct=pct,
+                    missing_lines=sorted(fn_missed),
+                    partial_branch_lines=fn_partial,
+                )
+            )
+
+    return CheckSummary(functions=results, files_missing=missing)

{verifaied-0.1.0.dev28 → verifaied-0.1.0.dev29}/src/verifaied/cli.py

@@ -11,6 +11,7 @@ fail builds on missing coverage:
 
 from __future__ import annotations
 
+import json
 from pathlib import Path
 from uuid import UUID
 
@@ -19,6 +20,7 @@ from rich.console import Console
 from rich.table import Table
 
 from verifaied import __version__
+from verifaied.analyzer import CheckSummary, FunctionResult, analyze_coverage
 from verifaied.client import (
     ApiError,
     RepoNotFoundError,
@@ -33,12 +35,14 @@ from verifaied.config import (
     resolved_api_token,
     resolved_api_url,
 )
+from verifaied.prompts import build_prompt, format_line_ranges
 from verifaied.uploader import UploaderError, build_payload, detect_repo_slug
 
 app = typer.Typer(
     add_completion=False,
     no_args_is_help=True,
-    help="Upload local pytest coverage to verifAIed.",
+    help="Coverage feedback for AI-written tests. `check` runs locally; "
+    "`upload` syncs to the hosted app.",
 )
 
 console = Console()
@@ -176,6 +180,184 @@ def upload_command(
     _render(result, api_url=resolved_url, repo_id=repo_id)
 
 
+@app.command("check")
+def check_command(
+    coverage: Path | None = typer.Option(
+        None,
+        "--coverage",
+        help="Path to the pytest-cov json report (default: ./coverage.json).",
+    ),
+    root: Path | None = typer.Option(
+        None,
+        "--root",
+        help="Root the coverage paths are relative to (default: cwd).",
+    ),
+    prompt: bool = typer.Option(
+        False,
+        "--prompt",
+        help=(
+            "Print a ready-to-paste test prompt for each untested function "
+            "instead of the summary table."
+        ),
+    ),
+    limit: int = typer.Option(
+        10,
+        "--limit",
+        help="Max functions to list (or prompts to print). 0 for no limit.",
+    ),
+    fail_under: float | None = typer.Option(
+        None,
+        "--fail-under",
+        help=(
+            "Exit 3 if the percentage of fully-covered functions is below "
+            "this. For use as a CI gate."
+        ),
+    ),
+) -> None:
+    """What's untested in your code — **entirely local, no account needed**.
+
+    Reads ``coverage.json`` and your source, and tells you which functions
+    are untested or partially covered. Nothing leaves your machine: no API
+    token, no network call, no sign-up.
+
+    Run pytest with coverage first:
+
+        pytest --cov --cov-branch --cov-report=json
+
+    Then:
+
+        verifaied check
+        verifaied check --prompt      # ready-to-paste prompts for your LLM
+
+    ``verifaied upload`` is the hosted counterpart — it adds history,
+    branch diffing against CI, the web UI and AI-written prompts.
+    """
+    coverage_path = coverage or Path("coverage.json")
+    root_path = root or Path.cwd()
+
+    try:
+        raw = coverage_path.read_text(encoding="utf-8")
+    except OSError as e:
+        err_console.print(
+            f"[red]error[/red]: cannot read {coverage_path} — run "
+            f"`pytest --cov --cov-report=json` first"
+        )
+        raise typer.Exit(code=1) from e
+
+    try:
+        coverage_json = json.loads(raw)
+    except json.JSONDecodeError as e:
+        err_console.print(f"[red]error[/red]: {coverage_path} is not valid JSON: {e}")
+        raise typer.Exit(code=1) from e
+
+    summary = analyze_coverage(coverage_json, root=root_path)
+
+    if summary.files_missing:
+        # Loud, not silent: an unreadable file almost always means --root
+        # is wrong, and the alternative is confidently reporting "0
+        # untested functions" for a codebase we never actually read.
+        shown = ", ".join(summary.files_missing[:3])
+        more = (
+            f" (+{len(summary.files_missing) - 3} more)"
+            if len(summary.files_missing) > 3
+            else ""
+        )
+        err_console.print(
+            f"[yellow]warning[/yellow]: could not read {len(summary.files_missing)} "
+            f"file(s) referenced by coverage: {shown}{more}. "
+            f"Is --root correct? (using: {root_path})"
+        )
+
+    if not summary.functions:
+        console.print(
+            "No functions found in the coverage report. "
+            "Check that --root points at pytest's rootdir."
+        )
+        raise typer.Exit(code=1)
+
+    targets = summary.untested + summary.partial
+    capped = targets if limit == 0 else targets[:limit]
+
+    if prompt:
+        _render_prompts(capped, root=root_path)
+    else:
+        _render_check(summary, capped, limit=limit)
+
+    if fail_under is not None:
+        pct = 100.0 * len(summary.covered) / len(summary.functions)
+        if pct < fail_under:
+            err_console.print(
+                f"[red]FAIL[/red]: {pct:.1f}% of functions fully covered, "
+                f"below --fail-under {fail_under:.1f}%"
+            )
+            raise typer.Exit(code=3)
+
+
+def _render_check(
+    summary: CheckSummary, targets: list[FunctionResult], *, limit: int
+) -> None:
+    """Summary counts + a table of what to work on next."""
+    total = len(summary.functions)
+    console.print()
+    console.print(
+        f"[bold]{len(summary.covered)}[/bold] covered  "
+        f"[yellow]{len(summary.partial)}[/yellow] partial  "
+        f"[red]{len(summary.untested)}[/red] untested"
+        f"   ([bold]{total}[/bold] functions)"
+    )
+
+    if not targets:
+        console.print("\n[green]Everything is fully covered.[/green]")
+        return
+
+    table = Table(show_header=True, header_style="bold", box=None, pad_edge=False)
+    table.add_column("")
+    table.add_column("function")
+    table.add_column("file")
+    table.add_column("missing", justify="right")
+
+    for fn in targets:
+        marker = "[red]●[/red]" if fn.state == "untested" else "[yellow]◐[/yellow]"
+        missing = format_line_ranges(fn.missing_lines) or "—"
+        table.add_row(marker, fn.name, f"{fn.file_path}:{fn.start_line}", missing)
+
+    console.print()
+    console.print(table)
+
+    hidden = len(summary.untested) + len(summary.partial) - len(targets)
+    if hidden > 0:
+        console.print(f"\n[dim]… and {hidden} more (--limit 0 to show all)[/dim]")
+    console.print(
+        "\n[dim]`verifaied check --prompt` for ready-to-paste test prompts.[/dim]"
+    )
+
+
+def _render_prompts(targets: list[FunctionResult], *, root: Path) -> None:
+    """Print one deterministic prompt per function, separated so the whole
+    block can be piped straight into an LLM."""
+    if not targets:
+        console.print("[green]Everything is fully covered — nothing to prompt.[/green]")
+        return
+
+    # Read each source file once even when it holds several targets.
+    sources: dict[str, str] = {}
+    for fn in targets:
+        if fn.file_path in sources:
+            continue
+        try:
+            sources[fn.file_path] = (root / fn.file_path).read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            sources[fn.file_path] = ""
+
+    for i, fn in enumerate(targets):
+        if i:
+            console.print("\n" + "─" * 60 + "\n")
+        # print() not console.print() — Rich would interpret [brackets] in
+        # the prompt body as markup and eat them. The prompt is meant to be
+        # copy-pasted verbatim.
+        print(build_prompt(fn, sources[fn.file_path]))
+
+
 def _resolve_repo(*, repo_input: str | None, api_url: str, token: str) -> UUID:
     """Turn the user's --repo value (or nothing) into a concrete UUID.
 

verifaied-0.1.0.dev29/src/verifaied/prompts.py

@@ -0,0 +1,193 @@
+"""Deterministic, no-LLM test prompts — rendered locally from the AST.
+
+The offline twin of the hosted ``get_baseline_prompt``. Same idea: a
+coverage percentage tells you nothing to *do*, so turn the AST plus the
+missed lines into a concrete instruction ("call ``apply_topup(...)``,
+assert the returned balance, cover lines 940-946, assert the
+``ValueError`` path").
+
+No network, no account, no LLM, no cost. This is what makes
+``verifaied check`` useful on its own rather than an advert for the
+hosted product.
+"""
+
+from __future__ import annotations
+
+import ast
+
+from verifaied.analyzer import FunctionResult
+
+
+def _find_node(
+    tree: ast.AST, qualname: str, start_line: int
+) -> tuple[ast.FunctionDef | ast.AsyncFunctionDef, str | None] | None:
+    """Locate one function by ``(qualified name, decorated start line)``.
+
+    Both halves are needed. The name alone is ambiguous — ``Foo.bar`` is
+    either a method on class ``Foo`` or a closure inside function ``foo``,
+    and you cannot tell which by splitting on the dot. The line alone
+    isn't unique either. Together they are.
+    """
+    found: tuple[ast.FunctionDef | ast.AsyncFunctionDef, str | None] | None = None
+
+    def decorated_start(node: ast.FunctionDef | ast.AsyncFunctionDef) -> int:
+        if not node.decorator_list:
+            return node.lineno
+        return min(d.lineno for d in node.decorator_list)
+
+    def walk(body: list[ast.stmt], prefix: str, class_name: str | None) -> None:
+        nonlocal found
+        for node in body:
+            if found is not None:
+                return
+            if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+                qn = f"{prefix}{node.name}" if prefix else node.name
+                if qn == qualname and decorated_start(node) == start_line:
+                    found = (node, class_name)
+                    return
+                # A closure inside a method is not itself a method.
+                walk(node.body, f"{qn}.", None)
+            elif isinstance(node, ast.ClassDef):
+                cn = f"{prefix}{node.name}." if prefix else f"{node.name}."
+                walk(node.body, cn, node.name)
+
+    walk(getattr(tree, "body", []), "", None)
+    return found
+
+
+def _params(node: ast.FunctionDef | ast.AsyncFunctionDef) -> list[str]:
+    """Parameter names minus ``self``/``cls`` — the caller doesn't pass
+    those, so listing them in "what to pass" would be wrong."""
+    a = node.args
+    out = [x.arg for x in [*a.posonlyargs, *a.args] if x.arg not in ("self", "cls")]
+    if a.vararg:
+        out.append(f"*{a.vararg.arg}")
+    out.extend(x.arg for x in a.kwonlyargs)
+    if a.kwarg:
+        out.append(f"**{a.kwarg.arg}")
+    return out
+
+
+def _raises(node: ast.FunctionDef | ast.AsyncFunctionDef) -> list[str]:
+    """Exception type names raised directly in the body. Bare re-raises
+    carry no type and are skipped. De-duplicated, source order — so the
+    output is byte-stable across runs."""
+    names: list[str] = []
+    for child in ast.walk(node):
+        if not isinstance(child, ast.Raise) or child.exc is None:
+            continue
+        exc = child.exc
+        if isinstance(exc, ast.Call):
+            exc = exc.func
+        name = (
+            exc.id
+            if isinstance(exc, ast.Name)
+            else exc.attr
+            if isinstance(exc, ast.Attribute)
+            else None
+        )
+        if name and name not in names:
+            names.append(name)
+    return names
+
+
+def _returns_value(node: ast.FunctionDef | ast.AsyncFunctionDef) -> bool:
+    """Whether it returns something worth asserting on. A bare ``return``
+    doesn't count."""
+    return any(
+        isinstance(c, ast.Return) and c.value is not None for c in ast.walk(node)
+    )
+
+
+def format_line_ranges(lines: list[int]) -> str:
+    """``[1,2,3,7]`` → ``"1-3, 7"``. Eighty comma-separated integers is
+    not something a human reads; ranges are."""
+    if not lines:
+        return ""
+    ordered = sorted(set(lines))
+    parts: list[str] = []
+    start = prev = ordered[0]
+    for n in ordered[1:]:
+        if n == prev + 1:
+            prev = n
+            continue
+        parts.append(str(start) if start == prev else f"{start}-{prev}")
+        start = prev = n
+    parts.append(str(start) if start == prev else f"{start}-{prev}")
+    return ", ".join(parts)
+
+
+def build_prompt(fn: FunctionResult, source: str) -> str:
+    """Render the templated prompt for one function.
+
+    Pure and deterministic: same function at the same coverage always
+    produces the same bytes, so it can be diffed and cached. Degrades
+    gracefully — if the source no longer parses or the function has moved,
+    it still emits the coverage-derived instructions without the
+    signature detail rather than failing.
+    """
+    lines: list[str] = []
+    verb = "Write" if fn.state == "untested" else "Extend"
+    lines.append(f"{verb} pytest tests for `{fn.name}` in `{fn.file_path}`.")
+    lines.append("")
+    if fn.state == "untested":
+        lines.append(
+            "It is currently **untested** — not one line of it runs under the suite."
+        )
+    else:
+        lines.append(
+            f"It is **partially covered** ({fn.line_coverage_pct:.0f}% of lines)."
+        )
+
+    node_info = None
+    try:
+        node_info = _find_node(ast.parse(source), fn.name, fn.start_line)
+    except SyntaxError:
+        node_info = None
+
+    lines.append("")
+    lines.append("What to do:")
+
+    if node_info is not None:
+        node, class_name = node_info
+        sig_args = ast.unparse(node.args)
+        ret = f" -> {ast.unparse(node.returns)}" if node.returns else ""
+        kw = "async def" if isinstance(node, ast.AsyncFunctionDef) else "def"
+        lines.append(f"- Target: `{kw} {node.name}({sig_args}){ret}`")
+
+        if class_name:
+            lines.append(
+                f"- Construct a `{class_name}` and call `.{node.name}(...)` on it."
+            )
+        else:
+            lines.append(f"- Call `{node.name}({', '.join(_params(node))})`.")
+
+        if isinstance(node, ast.AsyncFunctionDef):
+            lines.append("- It's `async` — `await` it under `pytest.mark.asyncio`.")
+
+        if _returns_value(node):
+            lines.append(
+                "- Assert on the **return value** — compare it to the exact "
+                "expected value, not just that it is truthy."
+            )
+
+        raised = _raises(node)
+        if raised:
+            joined = ", ".join(f"`{r}`" for r in raised)
+            lines.append(
+                f"- It raises {joined} — cover that path with "
+                f"`pytest.raises({raised[0]})`."
+            )
+
+    missing = format_line_ranges(fn.missing_lines)
+    if missing:
+        lines.append(f"- Cover the lines that never execute: **{missing}**.")
+
+    partial = format_line_ranges(fn.partial_branch_lines)
+    if partial:
+        lines.append(
+            f"- Branches taken only one way, on lines **{partial}** — add the "
+            "other case."
+        )
+
+    return "\n".join(lines)

verifaied-0.1.0.dev29/tests/test_check.py

@@ -0,0 +1,316 @@
+"""Tests for `verifaied check` — the local, zero-account analysis.
+
+The defining property of this command is that it touches NOTHING outside
+the working directory: no token, no network, no account. `pytest-httpx`
+would fail the test if any HTTP request escaped, so the absence of a mock
+in these tests is itself the assertion.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+from typer.testing import CliRunner
+
+from verifaied.analyzer import analyze_coverage, extract_functions
+from verifaied.cli import app
+from verifaied.prompts import build_prompt, format_line_ranges
+
+runner = CliRunner()
+
+SOURCE = """\
+def covered(a):
+    return a + 1
+
+
+def untested(a, b):
+    if a > b:
+        raise ValueError("nope")
+    return a - b
+
+
+class Thing:
+    def method(self, x):
+        return x * 2
+"""
+
+
+def _write(tmp_path: Path, coverage: dict) -> Path:
+    (tmp_path / "pkg").mkdir(exist_ok=True)
+    (tmp_path / "pkg" / "m.py").write_text(SOURCE)
+    cov = tmp_path / "coverage.json"
+    cov.write_text(json.dumps(coverage))
+    return cov
+
+
+# `covered` = lines 1-2; `untested` = 5-8; `Thing.method` = 12-13.
+FULL = {
+    "files": {
+        "pkg/m.py": {
+            "executed_lines": [1, 2, 5, 12, 13],
+            "missing_lines": [6, 7, 8],
+            "missing_branches": [[6, 8]],
+        }
+    }
+}
+
+
+def test_analyze_classifies_each_function(tmp_path: Path):
+    _write(tmp_path, FULL)
+    summary = analyze_coverage(FULL, root=tmp_path)
+
+    by_name = {f.name: f for f in summary.functions}
+    assert by_name["covered"].state == "covered"
+    assert by_name["Thing.method"].state == "covered"
+
+    untested = by_name["untested"]
+    # The `def` line executes at import time, so this is partial, not
+    # untested — and its missing lines are exactly the body.
+    assert untested.state == "partial"
+    assert untested.missing_lines == [6, 7, 8]
+    assert untested.partial_branch_lines == [6]
+
+
+def test_analyze_reports_a_function_with_no_executed_lines_as_untested(
+    tmp_path: Path,
+):
+    coverage = {
+        "files": {
+            "pkg/m.py": {
+                "executed_lines": [1, 2],
+                "missing_lines": [5, 6, 7, 8, 12, 13],
+            }
+        }
+    }
+    _write(tmp_path, coverage)
+    summary = analyze_coverage(coverage, root=tmp_path)
+    by_name = {f.name: f for f in summary.functions}
+
+    assert by_name["untested"].state == "untested"
+    assert by_name["untested"].line_coverage_pct == 0.0
+    assert by_name["Thing.method"].state == "untested"
+
+
+def test_analyze_records_unreadable_files_instead_of_silently_skipping(
+    tmp_path: Path,
+):
+    """A wrong --root must surface loudly. Silently reporting "0 untested
+    functions" for a codebase we never read would be a confidently wrong
+    answer — the worst possible failure for this tool."""
+    coverage = {"files": {"nope/gone.py": {"executed_lines": [1]}}}
+    summary = analyze_coverage(coverage, root=tmp_path)
+
+    assert summary.files_missing == ["nope/gone.py"]
+    assert summary.functions == []
+
+
+def test_extract_functions_qualifies_methods_and_closures():
+    src = "class A:\n    def m(self):\n        def inner():\n            pass\n"
+    names = [f.name for f in extract_functions(src)]
+    assert names == ["A.m", "A.m.inner"]
+
+
+def test_extract_functions_on_broken_source_returns_empty():
+    assert extract_functions("def (:\n") == []
+
+
+def test_format_line_ranges_collapses_runs():
+    assert format_line_ranges([1, 2, 3, 7]) == "1-3, 7"
+    assert format_line_ranges([]) == ""
+
+
+def test_build_prompt_names_the_call_lines_and_raise(tmp_path: Path):
+    _write(tmp_path, FULL)
+    summary = analyze_coverage(FULL, root=tmp_path)
+    fn = next(f for f in summary.functions if f.name == "untested")
+
+    prompt = build_prompt(fn, SOURCE)
+
+    assert "`untested` in `pkg/m.py`" in prompt
+    assert "Call `untested(a, b)`" in prompt
+    assert "**6-8**" in prompt
+    assert "pytest.raises(ValueError)" in prompt
+    assert "Assert on the **return value**" in prompt
+
+
+def test_build_prompt_for_a_method_says_construct_the_class(tmp_path: Path):
+    coverage = {"files": {"pkg/m.py": {"executed_lines": [12], "missing_lines": [13]}}}
+    _write(tmp_path, coverage)
+    summary = analyze_coverage(coverage, root=tmp_path)
+    fn = next(f for f in summary.functions if f.name == "Thing.method")
+
+    prompt = build_prompt(fn, SOURCE)
+
+    assert "Construct a `Thing` and call `.method(...)` on it." in prompt
+
+
+def test_build_prompt_degrades_when_source_does_not_parse(tmp_path: Path):
+    _write(tmp_path, FULL)
+    summary = analyze_coverage(FULL, root=tmp_path)
+    fn = next(f for f in summary.functions if f.name == "untested")
+
+    prompt = build_prompt(fn, "def broken(:\n")
+
+    # Still actionable on the coverage facts even with no AST.
+    assert "**6-8**" in prompt
+    assert "Target:" not in prompt
+
+
+# ---- the command ----
+
+
+def test_check_runs_with_no_token_and_no_network(tmp_path: Path):
+    """The whole point: no VERIFAIED_API_TOKEN, no API URL, no HTTP mock.
+    If the command tried to reach the network, pytest-httpx would raise."""
+    _write(tmp_path, FULL)
+
+    result = runner.invoke(
+        app,
+        [
+            "check",
+            "--coverage",
+            str(tmp_path / "coverage.json"),
+            "--root",
+            str(tmp_path),
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert "covered" in result.output
+    assert "untested" in result.output
+
+
+def test_check_prompt_mode_prints_a_pasteable_prompt(tmp_path: Path):
+    _write(tmp_path, FULL)
+
+    result = runner.invoke(
+        app,
+        [
+            "check",
+            "--coverage",
+            str(tmp_path / "coverage.json"),
+            "--root",
+            str(tmp_path),
+            "--prompt",
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert "pytest.raises(ValueError)" in result.output
+
+
+def test_check_fail_under_exits_3_when_below_threshold(tmp_path: Path):
+    """The CI gate. Exit 3 is distinct from 1 (usage) and 2 (API) so a
+    pipeline can tell "coverage too low" from "the tool broke"."""
+    _write(tmp_path, FULL)
+
+    result = runner.invoke(
+        app,
+        [
+            "check",
+            "--coverage",
+            str(tmp_path / "coverage.json"),
+            "--root",
+            str(tmp_path),
+            "--fail-under",
+            "100",
+        ],
+    )
+
+    assert result.exit_code == 3
+    assert "FAIL" in result.output
+
+
+def test_check_fail_under_passes_when_at_threshold(tmp_path: Path):
+    coverage = {
+        "files": {
+            "pkg/m.py": {
+                "executed_lines": [1, 2, 5, 6, 7, 8, 12, 13],
+                "missing_lines": [],
+            }
+        }
+    }
+    _write(tmp_path, coverage)
+
+    result = runner.invoke(
+        app,
+        [
+            "check",
+            "--coverage",
+            str(tmp_path / "coverage.json"),
+            "--root",
+            str(tmp_path),
+            "--fail-under",
+            "100",
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert "Everything is fully covered" in result.output
+
+
+def test_check_errors_when_coverage_file_is_missing(tmp_path: Path):
+    result = runner.invoke(app, ["check", "--coverage", str(tmp_path / "nope.json")])
+    assert result.exit_code == 1
+    assert "cannot read" in result.output
+
+
+def test_check_errors_on_invalid_json(tmp_path: Path):
+    bad = tmp_path / "coverage.json"
+    bad.write_text("{not json")
+    result = runner.invoke(app, ["check", "--coverage", str(bad)])
+    assert result.exit_code == 1
+    assert "not valid JSON" in result.output
+
+
+def test_check_errors_when_no_functions_matched(tmp_path: Path):
+    """An empty result almost always means --root is wrong. Exit non-zero
+    and say so rather than printing a cheerful, meaningless zero."""
+    cov = tmp_path / "coverage.json"
+    cov.write_text(json.dumps({"files": {}}))
+
+    result = runner.invoke(app, ["check", "--coverage", str(cov)])
+
+    assert result.exit_code == 1
+    assert "No functions found" in result.output
+
+
+def test_check_warns_when_a_source_file_cannot_be_read(tmp_path: Path):
+    cov = tmp_path / "coverage.json"
+    cov.write_text(json.dumps({"files": {"nope/gone.py": {"executed_lines": [1]}}}))
+
+    result = runner.invoke(
+        app, ["check", "--coverage", str(cov), "--root", str(tmp_path)]
+    )
+
+    assert "could not read" in result.output
+    assert "--root" in result.output
+
+
+def test_check_limit_caps_the_listing(tmp_path: Path):
+    coverage = {
+        "files": {
+            "pkg/m.py": {
+                "executed_lines": [1],
+                "missing_lines": [2, 5, 6, 7, 8, 12, 13],
+            }
+        }
+    }
+    _write(tmp_path, coverage)
+
+    result = runner.invoke(
+        app,
+        [
+            "check",
+            "--coverage",
+            str(tmp_path / "coverage.json"),
+            "--root",
+            str(tmp_path),
+            "--limit",
+            "1",
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    assert "and 2 more" in result.output

verifaied-0.1.0.dev29/tests/test_prompt_parity.py

@@ -0,0 +1,91 @@
+"""Parity guard: the CLI must describe a function the same way the backend does.
+
+The CLI reimplements the deterministic prompt (`verifaied/prompts.py`) rather
+than importing the backend — that independence is the whole point of the
+zero-account wedge. The cost is that two implementations of one product promise
+can drift silently, and a user who gets one instruction from `verifaied check`
+and a different one from the web UI for the same function has been told the
+product is inconsistent.
+
+This reads the SAME fixture as
+`backend/tests/logic/test_deterministic_prompt_parity.py` and asserts the same
+substantive claims: the call line, the uncovered-line ranges, the
+`pytest.raises` target, the class-construction instruction. Change one
+generator and this fails until you change the other.
+
+Skips (rather than fails) if the backend tree isn't present — the CLI is meant
+to be extractable into its own repo, and this guard must not be what blocks that.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from verifaied.analyzer import analyze_coverage
+from verifaied.prompts import build_prompt
+
+FIXTURE = (
+    Path(__file__).resolve().parents[2]
+    / "backend"
+    / "tests"
+    / "fixtures"
+    / "parity_sample.py"
+)
+
+pytestmark = pytest.mark.skipif(
+    not FIXTURE.exists(),
+    reason="backend tree not present — CLI is standalone here",
+)
+
+
+def _summary(tmp_path: Path, executed: list[int], missing: list[int], partial=None):
+    """Run the CLI analyzer over the shared fixture with synthetic coverage."""
+    (tmp_path / "billing.py").write_text(FIXTURE.read_text())
+    coverage = {
+        "files": {
+            "billing.py": {
+                "executed_lines": executed,
+                "missing_lines": missing,
+                "missing_branches": [[p, p + 2] for p in (partial or [])],
+            }
+        }
+    }
+    return analyze_coverage(coverage, root=tmp_path)
+
+
+def _line_of(marker: str) -> int:
+    for i, line in enumerate(FIXTURE.read_text().splitlines(), 1):
+        if marker in line:
+            return i
+    raise AssertionError(f"{marker!r} not in the parity fixture")
+
+
+def test_cli_prompt_for_the_parity_fixture_function(tmp_path: Path):
+    """Mirrors ``test_backend_prompt_for_the_parity_fixture_function``."""
+    def_line = _line_of("def apply_topup")
+    body = [def_line + 1, def_line + 2, def_line + 3, def_line + 4]
+    summary = _summary(
+        tmp_path, executed=[def_line], missing=body, partial=[def_line + 1]
+    )
+    fn = next(f for f in summary.functions if f.name == "apply_topup")
+
+    prompt = build_prompt(fn, FIXTURE.read_text())
+
+    assert "`apply_topup` in `billing.py`" in prompt
+    assert "Call `apply_topup(user_id, amount)`" in prompt
+    assert "pytest.raises(ValueError)" in prompt
+    assert "Assert on the **return value**" in prompt
+    assert f"**{def_line + 1}-{def_line + 4}**" in prompt
+
+
+def test_cli_prompt_for_the_parity_fixture_method(tmp_path: Path):
+    """Mirrors ``test_backend_prompt_for_the_parity_fixture_method``."""
+    def_line = _line_of("def credit")
+    summary = _summary(tmp_path, executed=[def_line], missing=[def_line + 1])
+    fn = next(f for f in summary.functions if f.name == "Ledger.credit")
+
+    prompt = build_prompt(fn, FIXTURE.read_text())
+
+    assert "Construct a `Ledger` and call `.credit(...)` on it." in prompt