verifaied 0.0.1__tar.gz

verifaied-0.0.1/.gitignore

@@ -0,0 +1,52 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+.venv/
+venv/
+env/
+*.egg-info/
+dist/
+build/
+
+# Node
+node_modules/
+frontend/dist/
+frontend/coverage/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Environment
+**/.env
+**/.env.*
+
+# Docker
+pgdata/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Coverage
+.coverage
+coverage.json
+htmlcov/
+
+# Keys
+*.pem
+
+TODO.txt
+
+# Terraform
+**/.terraform/
+*.tfstate
+*.tfstate.backup
+# Auto-loaded tfvars files hold env-specific secrets/IPs (e.g. allowlist.auto.tfvars).
+# Plain terraform.tfvars is checked in — keep it free of sensitive values.
+*.auto.tfvars

verifaied-0.0.1/PKG-INFO

@@ -0,0 +1,65 @@
+Metadata-Version: 2.4
+Name: verifaied
+Version: 0.0.1
+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.
+
+## Install
+
+```bash
+uv tool install verifaied        # or
+pipx install verifaied
+```
+
+## Configure
+
+Set the API token (mint one from the verifAIed app) and, for self-hosted
+or local backends, the API URL:
+
+```bash
+export VERIFAIED_API_TOKEN=vr_live_...
+export VERIFAIED_API_URL=http://localhost:8000   # default
+```
+
+## Use
+
+After a pytest run that emits `coverage.json`:
+
+```bash
+pytest --cov --cov-report=json --junitxml=junit.xml
+verifaied upload --repo <repository-id>
+```
+
+The CLI reads `coverage.json`, pulls the source for every file it
+references from your working tree, and posts everything to
+`/repositories/<id>/local-coverage`. The response prints a summary of
+untested / partial / failing functions so you (or your LLM) can fix
+them on the next iteration.
+
+### Flags
+
+- `--repo / -r <UUID>` — repository id (required)
+- `--branch / -b <name>` — branch to attach the upload to (default:
+  `git branch --show-current`, then `local`)
+- `--coverage <path>` — path to coverage.json (default: `./coverage.json`)
+- `--junit <path>` — optional JUnit XML for failing-test detail
+- `--commit-sha <sha>` — commit sha for display (default: `git rev-parse HEAD`)
+- `--root <path>` — root the coverage paths are relative to (default: cwd)
+- `--api-url <url>` — backend base URL (overrides `VERIFAIED_API_URL`)
+- `--token <token>` — API token (overrides `VERIFAIED_API_TOKEN`)

verifaied-0.0.1/README.md

@@ -0,0 +1,47 @@
+# verifaied
+
+CLI for uploading local pytest coverage to verifAIed so an LLM (or you) can see what's untested without waiting for CI.
+
+## Install
+
+```bash
+uv tool install verifaied        # or
+pipx install verifaied
+```
+
+## Configure
+
+Set the API token (mint one from the verifAIed app) and, for self-hosted
+or local backends, the API URL:
+
+```bash
+export VERIFAIED_API_TOKEN=vr_live_...
+export VERIFAIED_API_URL=http://localhost:8000   # default
+```
+
+## Use
+
+After a pytest run that emits `coverage.json`:
+
+```bash
+pytest --cov --cov-report=json --junitxml=junit.xml
+verifaied upload --repo <repository-id>
+```
+
+The CLI reads `coverage.json`, pulls the source for every file it
+references from your working tree, and posts everything to
+`/repositories/<id>/local-coverage`. The response prints a summary of
+untested / partial / failing functions so you (or your LLM) can fix
+them on the next iteration.
+
+### Flags
+
+- `--repo / -r <UUID>` — repository id (required)
+- `--branch / -b <name>` — branch to attach the upload to (default:
+  `git branch --show-current`, then `local`)
+- `--coverage <path>` — path to coverage.json (default: `./coverage.json`)
+- `--junit <path>` — optional JUnit XML for failing-test detail
+- `--commit-sha <sha>` — commit sha for display (default: `git rev-parse HEAD`)
+- `--root <path>` — root the coverage paths are relative to (default: cwd)
+- `--api-url <url>` — backend base URL (overrides `VERIFAIED_API_URL`)
+- `--token <token>` — API token (overrides `VERIFAIED_API_TOKEN`)

verifaied-0.0.1/pyproject.toml

@@ -0,0 +1,52 @@
+[project]
+name = "verifaied"
+version = "0.0.1"
+description = "Upload local pytest coverage to verifAIed for instant feedback"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Kyle Richards" }]
+keywords = ["pytest", "coverage", "testing", "ai", "llm"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Topic :: Software Development :: Testing",
+]
+dependencies = [
+    "httpx>=0.27.0",
+    "typer>=0.12.0",
+    "rich>=13.7.0",
+]
+
+[project.scripts]
+verifaied = "verifaied.cli:app"
+
+[project.urls]
+Homepage = "https://pypi.org/project/verifaied/"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/verifaied"]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-httpx>=0.30.0",
+    "ruff>=0.8.0",
+]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B", "UP"]
+# Typer's idiomatic API is `def cmd(arg: T = typer.Option(...))`. Ruff's
+# B008 flags any function-call default, which would force us to wrap
+# every option — overwhelming the actual signal. Disable for the file
+# that uses Typer's surface; keep B008 enabled everywhere else.
+[tool.ruff.lint.per-file-ignores]
+"src/verifaied/cli.py" = ["B008"]

verifaied-0.0.1/src/verifaied/__init__.py

@@ -0,0 +1,3 @@
+"""verifAIed CLI: upload local pytest coverage for instant feedback."""
+
+__version__ = "0.0.1"

verifaied-0.0.1/src/verifaied/__main__.py

@@ -0,0 +1,4 @@
+from verifaied.cli import app
+
+if __name__ == "__main__":
+    app()

verifaied-0.0.1/src/verifaied/cli.py

@@ -0,0 +1,189 @@
+"""Typer entry point: `verifaied upload`.
+
+The CLI surface is intentionally tiny — one verb, all options also
+available as env vars. Exit codes are meaningful so CI pipelines can
+fail builds on missing coverage:
+
+  0  success
+  1  usage / config / preflight error (missing files, bad json, no token)
+  2  HTTP/API error (auth, 404, 413, network)
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from uuid import UUID
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from verifaied import __version__
+from verifaied.client import ApiError, UploadResult, upload
+from verifaied.config import (
+    DEFAULT_API_URL,
+    ENV_API_TOKEN,
+    ENV_API_URL,
+    resolved_api_token,
+    resolved_api_url,
+)
+from verifaied.uploader import UploaderError, build_payload
+
+app = typer.Typer(
+    add_completion=False,
+    no_args_is_help=True,
+    help="Upload local pytest coverage to verifAIed.",
+)
+
+console = Console()
+err_console = Console(stderr=True)
+
+
+def _version_callback(value: bool) -> None:
+    if value:
+        console.print(f"verifaied {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        False,
+        "--version",
+        callback=_version_callback,
+        is_eager=True,
+        help="Show the CLI version and exit.",
+    ),
+) -> None:
+    """verifAIed — instant coverage feedback for AI-written tests."""
+
+
+@app.command("upload")
+def upload_command(
+    repo: UUID = typer.Option(
+        ...,
+        "--repo",
+        "-r",
+        help="Repository id (UUID) from the verifAIed dashboard.",
+    ),
+    branch: str | None = typer.Option(
+        None,
+        "--branch",
+        "-b",
+        help="Branch name. Defaults to `git branch --show-current`.",
+    ),
+    coverage: Path | None = typer.Option(
+        None,
+        "--coverage",
+        help="Path to the pytest-cov json report (default: ./coverage.json).",
+    ),
+    junit: Path | None = typer.Option(
+        None,
+        "--junit",
+        help="Optional JUnit XML for failing-test detail.",
+    ),
+    commit_sha: str | None = typer.Option(
+        None,
+        "--commit-sha",
+        help="Commit sha for display. Defaults to `git rev-parse HEAD`.",
+    ),
+    root: Path | None = typer.Option(
+        None,
+        "--root",
+        help="Root the coverage paths are relative to (default: cwd).",
+    ),
+    api_url: str | None = typer.Option(
+        None,
+        "--api-url",
+        help=f"Backend base URL. Defaults to ${ENV_API_URL} or {DEFAULT_API_URL}.",
+    ),
+    token: str | None = typer.Option(
+        None,
+        "--token",
+        help=f"API token (vr_live_...). Defaults to ${ENV_API_TOKEN}.",
+    ),
+) -> None:
+    """Read coverage.json + working-tree source, POST to verifAIed."""
+    resolved_url = resolved_api_url(api_url)
+    resolved_token = resolved_api_token(token)
+    if not resolved_token:
+        err_console.print(
+            f"[red]error[/red]: no API token (set ${ENV_API_TOKEN} or pass --token)"
+        )
+        raise typer.Exit(code=1)
+
+    coverage_path = coverage or Path("coverage.json")
+    root_path = root or Path.cwd()
+
+    try:
+        payload = build_payload(
+            coverage_path=coverage_path,
+            root=root_path,
+            branch=branch,
+            commit_sha=commit_sha,
+            junit_path=junit,
+        )
+    except UploaderError as e:
+        err_console.print(f"[red]error[/red]: {e}")
+        raise typer.Exit(code=1) from e
+
+    try:
+        result = upload(
+            api_url=resolved_url,
+            token=resolved_token,
+            repo_id=repo,
+            payload=payload,
+        )
+    except ApiError as e:
+        err_console.print(f"[red]error[/red]: {e.message}")
+        raise typer.Exit(code=2) from e
+
+    _render(result, api_url=resolved_url, repo_id=repo)
+
+
+def _render(result: UploadResult, *, api_url: str, repo_id: UUID) -> None:
+    """Print a compact, scannable summary. Designed for LLM tail-reads
+    too: the counts come first so the model sees the deltas without
+    scrolling past a function list."""
+    table = Table(show_header=False, box=None, padding=(0, 1))
+    table.add_row("branch", result.branch)
+    table.add_row("files received", str(result.files_received))
+    table.add_row("functions matched", str(result.functions_matched))
+    table.add_row("untested", str(len(result.untested)))
+    table.add_row("partial", str(len(result.partial)))
+    table.add_row("failing tests", str(len(result.failing_tests)))
+    console.print(table)
+
+    if result.functions_matched == 0:
+        err_console.print(
+            "[yellow]warning[/yellow]: 0 functions matched — your `files` keys "
+            "likely don't match the paths in coverage.json. Try --root."
+        )
+
+    _print_function_list("untested", result.untested)
+    _print_function_list("partial", result.partial)
+
+    if result.failing_tests:
+        console.print("\n[bold]failing tests[/bold]")
+        for t in result.failing_tests[:10]:
+            node = t.get("node_id") or t.get("name") or "?"
+            console.print(f"  - {node}")
+        if len(result.failing_tests) > 10:
+            console.print(f"  ... and {len(result.failing_tests) - 10} more")
+
+    console.print(
+        f"\n[dim]→ {api_url.rstrip('/')}/repos/{repo_id}"
+        f"/branches/{result.branch}?analysisId={result.analysis_id}[/dim]"
+    )
+
+
+def _print_function_list(label: str, fns: list[dict]) -> None:
+    if not fns:
+        return
+    console.print(f"\n[bold]{label}[/bold]")
+    for fn in fns[:10]:
+        path = fn.get("file_path", "?")
+        name = fn.get("name", "?")
+        console.print(f"  - {path}::{name}")
+    if len(fns) > 10:
+        console.print(f"  ... and {len(fns) - 10} more")

verifaied-0.0.1/src/verifaied/client.py

@@ -0,0 +1,103 @@
+"""Thin httpx wrapper around POST /repositories/{id}/local-coverage.
+
+Kept separate from ``uploader.py`` so the file-walking logic can be
+unit-tested without spinning a fake HTTP server, and so the HTTP layer
+can be swapped if/when we add a streaming variant for huge uploads.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+from uuid import UUID
+
+import httpx
+
+from verifaied.uploader import Payload
+
+
+class ApiError(Exception):
+    """Raised for any non-2xx response. The CLI maps this to an exit
+    code + a friendly message; the raw status + detail are surfaced so
+    the user can tell 401 (token) from 404 (wrong repo) from 413 (too
+    big) without reading a stack trace."""
+
+    def __init__(self, status_code: int, message: str) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+        self.message = message
+
+
+@dataclass(frozen=True)
+class UploadResult:
+    analysis_id: str
+    branch: str
+    files_received: int
+    functions_matched: int
+    untested: list[dict[str, Any]]
+    partial: list[dict[str, Any]]
+    failing_tests: list[dict[str, Any]]
+    message: str
+    summary: dict[str, Any]
+
+
+def upload(
+    *,
+    api_url: str,
+    token: str,
+    repo_id: UUID,
+    payload: Payload,
+    timeout: float = 60.0,
+) -> UploadResult:
+    """POST the payload and return the parsed response.
+
+    Times out at 60s by default — the synchronous endpoint persists rows
+    and re-runs the analyzer inline, so very large repos may push past
+    the default httpx 5s. Callers can override for CI use.
+    """
+    body = {
+        "branch": payload.branch,
+        "commit_sha": payload.commit_sha,
+        "files": payload.files,
+        "coverage_json": payload.coverage_json,
+    }
+    if payload.junit_xml is not None:
+        body["junit_xml"] = payload.junit_xml
+
+    url = f"{api_url.rstrip('/')}/repositories/{repo_id}/local-coverage"
+    headers = {"Authorization": f"Bearer {token}"}
+
+    try:
+        response = httpx.post(url, json=body, headers=headers, timeout=timeout)
+    except httpx.HTTPError as e:
+        raise ApiError(0, f"could not reach {url}: {e}") from e
+
+    if response.status_code >= 400:
+        raise ApiError(response.status_code, _detail(response))
+
+    data = response.json()
+    return UploadResult(
+        analysis_id=data["analysis_id"],
+        branch=data["branch"],
+        files_received=data["files_received"],
+        functions_matched=data["functions_matched"],
+        untested=data.get("untested") or [],
+        partial=data.get("partial") or [],
+        failing_tests=data.get("failing_tests") or [],
+        message=data.get("message") or "",
+        summary=data.get("summary") or {},
+    )
+
+
+def _detail(response: httpx.Response) -> str:
+    """Pull a human-readable error message out of the response. Falls
+    back to status reason if the body isn't JSON or doesn't carry a
+    ``detail`` field."""
+    try:
+        body = response.json()
+    except ValueError:
+        return f"{response.status_code} {response.reason_phrase}".strip()
+    detail = body.get("detail") if isinstance(body, dict) else None
+    if isinstance(detail, str) and detail:
+        return detail
+    return f"{response.status_code} {response.reason_phrase}".strip()

verifaied-0.0.1/src/verifaied/config.py

@@ -0,0 +1,25 @@
+"""Env-var defaults for the CLI.
+
+Kept thin on purpose — every option is also a CLI flag, so this module
+exists only to centralize the env-var *names* and the dev-friendly
+``http://localhost:8000`` default. No filesystem config files (yet); we
+follow the 12-factor convention so the CLI behaves the same in shell,
+pre-commit hooks, and CI.
+"""
+
+from __future__ import annotations
+
+import os
+
+ENV_API_URL = "VERIFAIED_API_URL"
+ENV_API_TOKEN = "VERIFAIED_API_TOKEN"
+
+DEFAULT_API_URL = "http://localhost:8000"
+
+
+def resolved_api_url(override: str | None) -> str:
+    return override or os.environ.get(ENV_API_URL) or DEFAULT_API_URL
+
+
+def resolved_api_token(override: str | None) -> str | None:
+    return override or os.environ.get(ENV_API_TOKEN)

verifaied-0.0.1/src/verifaied/uploader.py

@@ -0,0 +1,135 @@
+"""Build the local-coverage POST payload from a pytest-cov json file.
+
+The single risky thing in the CLI is the file-path round-trip: the
+``files`` dict in the request must use the same string keys as the
+``coverage.json`` records, otherwise the backend's AST analyzer can't
+match function definitions to coverage rows and ``functions_matched``
+comes back as zero. We resolve every path *relative to the same root*
+the user gave us, and bail loudly if any source can't be read.
+"""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+
+class UploaderError(Exception):
+    """Raised for any pre-flight problem (missing file, malformed json,
+    git failure). The CLI catches this and prints a friendly message
+    rather than a stack trace."""
+
+
+@dataclass(frozen=True)
+class Payload:
+    branch: str
+    commit_sha: str | None
+    files: dict[str, str]
+    coverage_json: dict[str, Any]
+    junit_xml: str | None
+
+
+def load_coverage_json(path: Path) -> dict[str, Any]:
+    if not path.exists():
+        raise UploaderError(
+            f"coverage file not found: {path}. Run pytest with "
+            "`--cov --cov-report=json` first."
+        )
+    try:
+        data = json.loads(path.read_text())
+    except json.JSONDecodeError as e:
+        raise UploaderError(f"could not parse {path}: {e}") from e
+    if not isinstance(data, dict) or "files" not in data:
+        raise UploaderError(
+            f"{path} doesn't look like a pytest-cov json report "
+            "(missing top-level 'files' key)."
+        )
+    return data
+
+
+def load_files_referenced_by(coverage: dict[str, Any], root: Path) -> dict[str, str]:
+    """Read each source file the coverage json references.
+
+    Keys are returned **unchanged** from the coverage json so the upload
+    payload matches the backend's expectations exactly. Values are the
+    file contents read from ``<root>/<key>``.
+    """
+    files_block = coverage.get("files") or {}
+    if not isinstance(files_block, dict) or not files_block:
+        raise UploaderError("coverage json has no 'files' entries — nothing to upload.")
+    out: dict[str, str] = {}
+    missing: list[str] = []
+    for rel_path in files_block.keys():
+        source_path = root / rel_path
+        if not source_path.is_file():
+            missing.append(rel_path)
+            continue
+        out[rel_path] = source_path.read_text()
+    if missing:
+        joined = "\n  ".join(missing)
+        raise UploaderError(
+            "could not read source for the following files referenced by "
+            f"coverage.json (looking under {root}):\n  {joined}\n"
+            "Set --root to the directory pytest was run from."
+        )
+    return out
+
+
+def load_junit(path: Path | None) -> str | None:
+    if path is None:
+        return None
+    if not path.exists():
+        raise UploaderError(f"JUnit file not found: {path}")
+    return path.read_text()
+
+
+def detect_branch() -> str:
+    """`git branch --show-current`, or the literal ``"local"`` if we're
+    outside a git repo or on a detached HEAD. The backend treats this as
+    a plain string; users on detached HEAD can pass --branch explicitly."""
+    out = _git("branch", "--show-current")
+    return out or "local"
+
+
+def detect_commit_sha() -> str | None:
+    """Short-circuits to None outside a git repo so the upload still
+    succeeds — the backend treats commit_sha as optional and uses its
+    own content hash for cache keying."""
+    return _git("rev-parse", "HEAD") or None
+
+
+def _git(*args: str) -> str:
+    try:
+        result = subprocess.run(
+            ["git", *args],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+    except FileNotFoundError:
+        return ""
+    if result.returncode != 0:
+        return ""
+    return result.stdout.strip()
+
+
+def build_payload(
+    *,
+    coverage_path: Path,
+    root: Path,
+    branch: str | None,
+    commit_sha: str | None,
+    junit_path: Path | None,
+) -> Payload:
+    coverage_json = load_coverage_json(coverage_path)
+    files = load_files_referenced_by(coverage_json, root)
+    return Payload(
+        branch=branch or detect_branch(),
+        commit_sha=commit_sha or detect_commit_sha(),
+        files=files,
+        coverage_json=coverage_json,
+        junit_xml=load_junit(junit_path),
+    )