jev-cli 0.4.1__py3-none-any.whl

jev_cli/__init__.py

@@ -0,0 +1,288 @@
+#!/usr/bin/env python3
+"""Small, dependency-free CLI for TypeSafe Jev."""
+
+from __future__ import annotations
+
+import argparse
+import getpass
+import json
+import os
+import shutil
+import sys
+import tempfile
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+API_URL = "https://api.typesafe.ai/v1/systemone"
+CREDENTIALS_FILE = Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config")) / "jev-cli" / "credentials.json"
+BUNDLED_SKILLS = Path(__file__).with_name("bundled_skills")
+INSTALL_MARKER = ".jev-cli-managed"
+
+
+class CliError(Exception):
+    def __init__(self, message: str, exit_code: int = 2) -> None:
+        super().__init__(message)
+        self.exit_code = exit_code
+
+
+def api_key() -> str:
+    if value := os.environ.get("TYPESAFE_API_KEY"):
+        return value
+    try:
+        data = json.loads(CREDENTIALS_FILE.read_text())
+        value = data["api_key"]
+    except (OSError, json.JSONDecodeError, KeyError, TypeError) as exc:
+        raise CliError(
+            "TypeSafe API key is not stored; run: jev auth set",
+            3,
+        ) from exc
+    if not isinstance(value, str) or not value:
+        raise CliError("stored TypeSafe API key is empty", 3)
+    return value
+
+
+def set_api_key() -> None:
+    value = getpass.getpass("TypeSafe API key: ").strip() if sys.stdin.isatty() else sys.stdin.read().strip()
+    if not value:
+        raise CliError("API key is empty")
+    CREDENTIALS_FILE.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    try:
+        fd, temporary = tempfile.mkstemp(dir=CREDENTIALS_FILE.parent)
+        with os.fdopen(fd, "w") as file:
+            json.dump({"api_key": value}, file)
+            file.write("\n")
+        os.chmod(temporary, 0o600)
+        os.replace(temporary, CREDENTIALS_FILE)
+    except OSError as exc:
+        raise CliError("could not write the Jev credential store", 3) from exc
+
+
+def install_skills(
+    *, global_install: bool, claude: bool, cwd: Path | None = None, home: Path | None = None
+) -> dict[str, Any]:
+    base = (home or Path.home()) if global_install else (cwd or Path.cwd())
+    flavor = ".claude" if claude else ".agents"
+    destination_root = base / flavor / "skills"
+    installed: list[str] = []
+    paths: list[str] = []
+    for source in sorted(BUNDLED_SKILLS.iterdir()):
+        if not source.is_dir() or not (source / "SKILL.md").is_file():
+            continue
+        destination = destination_root / source.name
+        if destination.exists() and not (destination / INSTALL_MARKER).is_file():
+            raise CliError(f"refusing to overwrite unmanaged skill: {destination}")
+        destination_root.mkdir(parents=True, exist_ok=True)
+        staged = Path(tempfile.mkdtemp(prefix=f".{source.name}-", dir=destination_root))
+        try:
+            shutil.copytree(source, staged, dirs_exist_ok=True)
+            (staged / INSTALL_MARKER).write_text("managed by jev install-skills\n")
+            if destination.exists():
+                shutil.rmtree(destination)
+            staged.replace(destination)
+        except OSError as exc:
+            shutil.rmtree(staged, ignore_errors=True)
+            raise CliError(f"could not install skill: {exc}") from exc
+        installed.append(source.name)
+        paths.append(str(destination))
+    return {
+        "ok": True,
+        "scope": "global" if global_install else "local",
+        "flavor": "claude" if claude else "agents",
+        "destination": str(destination_root),
+        "installed": installed,
+        "paths": paths,
+    }
+
+
+def read_text(value: str | None) -> str:
+    if value is None or value == "-":
+        if sys.stdin.isatty():
+            raise CliError("state is required as an argument, @file, or stdin")
+        return sys.stdin.read()
+    if value.startswith("@"):
+        try:
+            return Path(value[1:]).read_text()
+        except OSError as exc:
+            raise CliError(f"cannot read state file: {exc}") from exc
+    return value
+
+
+def state_value(value: str | None, force_json: bool) -> Any:
+    text = read_text(value)
+    if force_json:
+        try:
+            return json.loads(text)
+        except json.JSONDecodeError as exc:
+            raise CliError(f"invalid JSON state: {exc}") from exc
+    return text
+
+
+def split_pair(value: str) -> tuple[str, str]:
+    key, separator, description = value.partition("=")
+    if not separator or not key or not description:
+        raise argparse.ArgumentTypeError("expected KEY=DESCRIPTION")
+    return key, description
+
+
+def load_request(path: str) -> dict[str, Any]:
+    text = read_text("-" if path == "-" else f"@{path}")
+    try:
+        payload = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise CliError(f"invalid request JSON: {exc}") from exc
+    if not isinstance(payload, dict) or "state" not in payload or "questions" not in payload:
+        raise CliError("request must be an object containing state and questions")
+    return payload
+
+
+def call(payload: dict[str, Any], endpoint: str) -> dict[str, Any]:
+    request = urllib.request.Request(
+        endpoint,
+        data=json.dumps(payload, ensure_ascii=False).encode(),
+        headers={
+            "Authorization": f"Bearer {api_key()}",
+            "Content-Type": "application/json",
+            "User-Agent": "jev-cli/0.4.1",
+        },
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(request, timeout=60) as response:
+            result = json.load(response)
+    except urllib.error.HTTPError as exc:
+        body = exc.read().decode(errors="replace")
+        try:
+            detail = json.loads(body)
+        except json.JSONDecodeError:
+            detail = body
+        code = 3 if exc.code in (401, 403) else 4 if exc.code in (429, 500, 502, 503, 504) else 1
+        raise CliError(f"API HTTP {exc.code}: {json.dumps(detail, ensure_ascii=False)}", code) from exc
+    except (urllib.error.URLError, TimeoutError) as exc:
+        raise CliError(f"API connection failed: {exc}", 4) from exc
+    if not isinstance(result, dict):
+        raise CliError("API returned a non-object response", 1)
+    return result
+
+
+def common_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("--model", default="jev-latest", help="model name (default: jev-latest)")
+    parser.add_argument("--json-state", action="store_true", help="parse state as JSON")
+    parser.add_argument("--pretty", action="store_true", help="pretty-print JSON")
+    parser.add_argument("--value", action="store_true", help="print only the primary answer value")
+    parser.add_argument("--endpoint", default=os.environ.get("TYPESAFE_API_URL", API_URL), help=argparse.SUPPRESS)
+    return parser
+
+
+def parser() -> argparse.ArgumentParser:
+    root = argparse.ArgumentParser(
+        prog="jev",
+        description="Evaluate text or JSON with TypeSafe Jev. Uses its own local credential store.",
+    )
+    root.add_argument("--version", action="version", version="jev 0.4.1")
+    sub = root.add_subparsers(dest="command", required=True)
+    common = common_parser()
+
+    auth = sub.add_parser("auth", help="manage the API key in the Jev credential store")
+    auth_sub = auth.add_subparsers(dest="auth_command", required=True)
+    auth_sub.add_parser("set", help="store an API key from a hidden prompt or stdin")
+    auth_sub.add_parser("status", help="check whether an API key is stored")
+    auth_sub.add_parser("test", help="connect to Jev and verify the API key")
+
+    skills = sub.add_parser("install-skills", help="install bundled agent skills")
+    skills.add_argument("-g", "--global", dest="global_install", action="store_true", help="install in the user home")
+    skills.add_argument("--claude", action="store_true", help="install for Claude instead of .agents")
+
+    noul = sub.add_parser("noul", parents=[common], help="answer one yes/no question with a probability")
+    noul.add_argument("-q", "--question", required=True, help="question to answer")
+    noul.add_argument("-s", "--state", help="text, @file, or - for stdin (default: stdin)")
+
+    choice = sub.add_parser("choice", parents=[common], help="choose one option")
+    choice.add_argument("-q", "--question", required=True, help="question to answer")
+    choice.add_argument("-s", "--state", help="text, @file, or - for stdin (default: stdin)")
+    choice.add_argument("-o", "--option", action="append", type=split_pair, required=True, metavar="KEY=DESCRIPTION")
+
+    score = sub.add_parser("score", parents=[common], help="score against ordered levels")
+    score.add_argument("-q", "--question", required=True, help="question to answer")
+    score.add_argument("-s", "--state", help="text, @file, or - for stdin (default: stdin)")
+    score.add_argument("-l", "--level", action="append", required=True, metavar="DESCRIPTION")
+
+    run = sub.add_parser("run", parents=[common], help="send a complete request JSON for batched questions")
+    run.add_argument("request", help="JSON file or - for stdin")
+    return root
+
+
+def request_for(args: argparse.Namespace) -> tuple[dict[str, Any], str | None]:
+    if args.command == "run":
+        payload = load_request(args.request)
+        payload.setdefault("model", args.model)
+        return payload, None
+
+    question: dict[str, Any] = {"type": args.command, "instructions": args.question}
+    if args.command == "choice":
+        question["criteria"] = dict(args.option)
+    elif args.command == "score":
+        question["criteria"] = args.level
+    payload = {
+        "state": state_value(args.state, args.json_state),
+        "model": args.model,
+        "questions": {"answer": question},
+    }
+    return payload, args.command
+
+
+def primary_value(result: dict[str, Any], kind: str | None) -> Any:
+    if kind is None:
+        raise CliError("--value is available only for noul, choice, and score")
+    answer = result["answers"]["answer"]
+    return answer[{"noul": "noul", "choice": "choice", "score": "score"}[kind]]
+
+
+def main() -> int:
+    try:
+        args = parser().parse_args()
+        if args.command == "auth":
+            if args.auth_command == "set":
+                set_api_key()
+                print(json.dumps({"ok": True, "stored": True, "store": str(CREDENTIALS_FILE)}))
+            elif args.auth_command == "test":
+                result = call(
+                    {
+                        "state": "authentication test",
+                        "model": "jev-latest",
+                        "questions": {
+                            "answer": {
+                                "type": "noul",
+                                "instructions": "Is this an authentication test?",
+                            }
+                        },
+                    },
+                    API_URL,
+                )
+                print(json.dumps({"ok": True, "valid": True, "model": result.get("model")}))
+            else:
+                api_key()
+                print(json.dumps({"ok": True, "stored": True, "store": str(CREDENTIALS_FILE)}))
+            return 0
+        if args.command == "install-skills":
+            print(json.dumps(install_skills(global_install=args.global_install, claude=args.claude)))
+            return 0
+        payload, kind = request_for(args)
+        result = call(payload, args.endpoint)
+        if args.value:
+            print(primary_value(result, kind))
+        else:
+            print(json.dumps(result, ensure_ascii=False, indent=2 if args.pretty else None))
+        return 0
+    except CliError as exc:
+        print(json.dumps({"ok": False, "error": str(exc)}, ensure_ascii=False), file=sys.stderr)
+        return exc.exit_code
+    except (KeyError, TypeError) as exc:
+        print(json.dumps({"ok": False, "error": f"unexpected API response: {exc}"}), file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

jev_cli/bundled_skills/jev-cli/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: jev-cli
+description: Use when classifying or scoring state with the `jev` CLI.
+version: 0.1.0
+author: tumf
+license: MIT
+metadata:
+  hermes:
+    tags: [jev, cli, classification, scoring]
+    related_skills: []
+---
+
+# jev-cli
+
+## Overview
+
+Use the `jev` command to ask TypeSafe Jev typed questions about text or JSON state. Prefer this skill when a task needs a compact machine-readable probability, one choice from explicit criteria, an ordered score, or several typed answers in one request.
+
+The package and repository are named `jev-cli`; the installed command is `jev`.
+
+Install this bundled skill with `jev install-skills`. Add `--global` for the user-wide target and `--claude` for Claude skill directories.
+
+## Workflow
+
+1. Confirm the command is installed with `jev --version`. If it is missing, install from the repository root with `make install`. Completion: `jev --version` exits successfully.
+2. Confirm key availability with `jev auth status`, then use `jev auth test` when API validity must be verified. If absent or invalid, ask the user to configure a TypeSafe API key; never print, infer, or commit it. Completion: the selected command returns `ok: true`.
+3. Choose the narrowest question type:
+   - `noul` for a yes/no probability.
+   - `choice` for one key from explicit options.
+   - `score` for an ordered numeric level.
+   - `run` for a complete request object or multiple questions.
+4. Send only the state needed for the judgment. TypeSafe receives the submitted state and questions, so do not send secrets or private data without explicit authorization.
+5. Use default JSON output for automation. Use `--value` only when a scalar is sufficient. Completion: parse the result and account for the exit code before acting on it.
+
+Read [references/cli.md](references/cli.md) for copy-paste command forms, inputs, output controls, and exit codes.
+
+## Decision rules
+
+- Give `choice` options stable keys and descriptions that make the categories mutually understandable.
+- Give `score` levels in ascending order; the returned number may be fractional.
+- Use `--json-state` only when the state must retain JSON structure.
+- Use `@file` or stdin for long input instead of embedding it in shell arguments.
+- Set `TYPESAFE_API_KEY` only for process-level overrides. The normal credential store remains under the user's config directory.
+- Treat model output as a structured judgment, not verified fact. Keep consequential actions behind the caller's own validation and authorization rules.
+
+## Common pitfalls
+
+1. **Calling the executable `jev-cli`.** The package is `jev-cli`, but the executable is `jev`.
+2. **Using `--value` with `run`.** Batched requests require the JSON response.
+3. **Treating transport failures as negative answers.** Exit code `4` means retryable API or network failure, not a model judgment.
+4. **Leaking state through convenience.** Inspect file and stdin content before submission when it may contain credentials or private records.
+5. **Embedding an API key in examples.** Use `jev auth set` through stdin or the environment variable without writing its value into scripts or documentation.
+
+## Verification checklist
+
+- [ ] `jev --version` succeeds.
+- [ ] `jev auth status` or `jev auth test` succeeds without exposing the key.
+- [ ] The selected question type matches the desired answer shape.
+- [ ] Submitted state contains no unauthorized secret or private data.
+- [ ] The caller handles JSON and nonzero exit codes.
+- [ ] Consequential follow-up actions retain their own authorization checks.

jev_cli/bundled_skills/jev-cli/references/cli.md

@@ -0,0 +1,142 @@
+# CLI reference
+
+## Authentication
+
+Check whether authentication is available without printing the key:
+
+```bash
+jev auth status
+```
+
+Connect to Jev and verify that the resolved API key is accepted:
+
+```bash
+jev auth test
+```
+
+In a terminal, enter the API key at the hidden prompt:
+
+```bash
+jev auth set
+```
+
+For non-interactive automation, stdin remains supported:
+
+```bash
+printf '%s' "$TYPESAFE_API_KEY" | jev auth set
+```
+
+Resolution order:
+
+1. `TYPESAFE_API_KEY`
+2. `$XDG_CONFIG_HOME/jev-cli/credentials.json`
+3. `~/.config/jev-cli/credentials.json`
+
+## Typed questions
+
+Use `-q` for `--question` and `-s` for `--state` when a shorter command is useful. `--value` has no short form.
+
+Return a yes/no probability from `0` to `1`:
+
+```bash
+jev noul --question 'Does this message require an urgent response?' --state 'Please respond today.'
+```
+
+Choose one stable key from explicit criteria:
+
+```bash
+jev choice --question 'Which team should receive this?' --state 'Checkout returns HTTP 500.' \
+  -o engineering='Software defect or technical failure' \
+  -o sales='Purchase or pricing question'
+```
+
+Score against ordered levels:
+
+```bash
+jev score --question 'How dissatisfied is this customer?' --state 'This is the third failure.' \
+  -l 'Not dissatisfied' \
+  -l 'Slightly dissatisfied' \
+  -l 'Clearly dissatisfied' \
+  -l 'Extremely dissatisfied'
+```
+
+Send a complete request from a file:
+
+```bash
+jev run request.json
+```
+
+## Input forms
+
+Literal text:
+
+```bash
+jev noul --question 'Does this require action?' --state 'Please investigate.'
+```
+
+File content:
+
+```bash
+jev noul --question 'Does this require action?' --state @message.txt
+```
+
+Standard input:
+
+```bash
+printf '%s' 'Please investigate.' | jev noul --question 'Does this require action?' --state -
+```
+
+Structured JSON state:
+
+```bash
+printf '%s' '{"message":"Please investigate","priority":"high"}' | \
+  jev noul --question 'Does this require action?' --state - --json-state
+```
+
+## Output controls
+
+Pretty JSON:
+
+```bash
+jev noul --question 'Does this require action?' --state 'Please investigate.' --pretty
+```
+
+Primary scalar only:
+
+```bash
+jev noul --question 'Does this require action?' --state 'Please investigate.' --value
+```
+
+`--value` applies to `noul`, `choice`, and `score`, not `run`.
+
+## Exit codes
+
+| Code | Meaning |
+|---:|---|
+| `0` | Success |
+| `1` | Invalid response or non-retryable API error |
+| `2` | Local input or credential error |
+| `3` | Authentication or authorization failure |
+| `4` | Retryable network, rate-limit, or server failure |
+
+Read stderr as JSON on failure. Do not interpret a nonzero exit as a model answer.
+
+## Installation
+
+From the repository root:
+
+```bash
+make install
+jev --version
+```
+
+The project requires Python 3.13 or later and `uv`.
+
+Install the bundled `jev-cli` Agent Skill:
+
+```bash
+jev install-skills
+jev install-skills --global
+jev install-skills --claude
+jev install-skills --global --claude
+```

jev_cli-0.4.1.dist-info/METADATA

@@ -0,0 +1,302 @@
+Metadata-Version: 2.4
+Name: jev-cli
+Version: 0.4.1
+Summary: Small dependency-free CLI for TypeSafe Jev
+Keywords: typesafe,jev,cli,ai
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/tumf/jev-cli
+Project-URL: Issues, https://github.com/tumf/jev-cli/issues
+Project-URL: Repository, https://github.com/tumf/jev-cli
+Description-Content-Type: text/markdown
+
+# jev-cli
+
+A small, dependency-free CLI for [TypeSafe Jev](https://docs.typesafe.ai/introduction). Send text or JSON state, ask typed questions, and receive machine-readable `noul`, `choice`, or `score` answers.
+
+The `jev` command is useful when application code needs a fast classification or judgment instead of generated prose.
+
+> **Unofficial:** This is an independent community project. It is not affiliated with, maintained by, or endorsed by TypeSafe AI.
+
+## Features
+
+- Supports all three Jev primitives: `noul`, `choice`, and `score`
+- Sends multiple questions in one request with `run`
+- Accepts text, JSON, files, and stdin
+- Emits compact JSON by default
+- Can print only the primary value for shell scripts
+- Uses structured stderr errors and meaningful exit codes
+- Has no runtime dependencies outside Python's standard library
+
+## Requirements
+
+- Python 3.13 or later
+- [uv](https://docs.astral.sh/uv/)
+- GNU Make
+- A TypeSafe API key
+
+## Install
+
+Clone the repository and install the command with `uv tool` through the Makefile. This installs `jev` into uv's executable directory and verifies the installed version.
+
+```bash
+git clone https://github.com/tumf/jev-cli.git
+cd jev-cli
+make install
+```
+
+Verify that the command is available:
+
+```bash
+jev --version
+```
+
+Expected output:
+
+```text
+jev 0.4.1
+```
+
+## Authentication
+
+The recommended approach for automation is the `TYPESAFE_API_KEY` environment variable. It takes precedence over the credential file.
+
+```bash
+export TYPESAFE_API_KEY='your-api-key'
+jev auth status
+```
+
+For local use, enter the key at the hidden prompt. `auth set` does not accept the key as a command-line argument, which keeps it out of process arguments and shell history.
+
+```bash
+jev auth set
+jev auth status
+jev auth test
+```
+
+For non-interactive automation, piping the key to `jev auth set` remains supported.
+
+`auth status` reports only whether a key is available. `auth test` sends a minimal request to Jev and verifies that the key is accepted. Neither command prints the key.
+
+The fallback credential path follows XDG conventions:
+
+- `$XDG_CONFIG_HOME/jev-cli/credentials.json` when `XDG_CONFIG_HOME` is set
+- `~/.config/jev-cli/credentials.json` otherwise
+
+The credential directory is created with mode `0700`; the file is written atomically with mode `0600`.
+
+## Quick start
+
+`--question` and `--state` also accept the short forms `-q` and `-s`. `--value` has no short form.
+
+## Install the bundled Agent Skill
+
+`jev-cli` currently bundles the `jev-cli` skill. Install it for the current project or globally:
+
+```bash
+jev install-skills
+jev install-skills --global
+```
+
+Use `--claude` to target Claude's skill directory instead:
+
+```bash
+jev install-skills --claude
+jev install-skills --global --claude
+```
+
+The command prints JSON. It refreshes only copies it previously installed and refuses to overwrite an unmanaged skill directory.
+
+Ask whether a message expresses urgency. `--value` prints only the resulting probability from `0` to `1`.
+
+```bash
+jev noul \
+  --question 'Does this message express urgency?' \
+  --state 'Please restore service today.' \
+  --value
+```
+
+Example output:
+
+```text
+0.98
+```
+
+Without `--value`, the command returns the complete API response as JSON, including model and token usage.
+
+```bash
+jev noul \
+  --question 'Does this message express urgency?' \
+  --state 'Please restore service today.' \
+  --pretty
+```
+
+## Question types
+
+### Noul: yes/no probability
+
+Use `noul` for one focused yes/no judgment. The value is the probability that the answer is yes.
+
+```bash
+jev noul \
+  --question 'Does this message request a refund?' \
+  --state 'The integration is broken, but I do not want a refund.' \
+  --value
+```
+
+### Choice: select one option
+
+Use `choice` when the answer must be one of a known set. Each option uses `KEY=DESCRIPTION` syntax.
+
+```bash
+jev choice \
+  --question 'Which team should handle this?' \
+  --state 'The payment integration keeps failing.' \
+  -o 'billing=Payment, charge, or refund issues' \
+  -o 'technical=Bugs or integration failures' \
+  -o 'other=None of these' \
+  --pretty
+```
+
+### Score: evaluate ordered levels
+
+Use `score` for an ordered scale. Levels are numbered from zero in the order supplied.
+
+```bash
+jev score \
+  --question 'How frustrated is the customer?' \
+  --state 'This has failed for three days. Please help.' \
+  -l 'Calm' \
+  -l 'Concerned but civil' \
+  -l 'Very angry' \
+  --value
+```
+
+## Input formats
+
+### Standard input
+
+Omit the state or pass `-` to read it from stdin. This is useful for pipelines and avoids putting sensitive input in shell history.
+
+```bash
+printf '%s' 'Please resolve this today.' | \
+  jev noul --question 'Does this message express urgency?' --value
+```
+
+### File input
+
+Prefix a path with `@` to read its contents.
+
+```bash
+jev noul \
+  --question 'Does this document mention security risks?' \
+  --state @document.txt \
+  --value
+```
+
+### JSON state
+
+Use `--json-state` to parse the state as JSON. Instructions can refer to named fields.
+
+```bash
+printf '%s' '{"message":"Please respond today"}' | \
+  jev noul \
+  --question 'Does `message` express urgency?' \
+  --json-state \
+  --value
+```
+
+## Batch questions
+
+Jev evaluates questions independently against the same state. Use `run` to send a complete System One request and avoid one API call per question.
+
+Create `request.json`:
+
+```json
+{
+  "state": {
+    "message": "The payment integration has failed for three days. Please fix it today."
+  },
+  "model": "jev-latest",
+  "questions": {
+    "department": {
+      "type": "choice",
+      "instructions": "Which team should handle `message`?",
+      "criteria": {
+        "billing": "Payment, charge, or refund issues",
+        "technical": "Bugs or integration failures",
+        "other": "None of these"
+      }
+    },
+    "urgent": {
+      "type": "noul",
+      "instructions": "Does `message` express urgency?"
+    }
+  }
+}
+```
+
+Send it in one request:
+
+```bash
+jev run request.json --pretty
+```
+
+A request can also be piped through stdin:
+
+```bash
+cat request.json | jev run - --pretty
+```
+
+## Output and automation
+
+The default stdout is one JSON object. Logs and structured errors go to stderr, so stdout can be piped directly into another program.
+
+Use `--value` with `noul`, `choice`, or `score` when a script needs only the primary answer:
+
+```bash
+if awk 'BEGIN { exit !(ARGV[1] >= 0.9) }' \
+  "$(jev noul --question 'Is this urgent?' --state 'Restore service today.' --value)"; then
+  echo urgent
+fi
+```
+
+Use `--model` to select another model available to the account:
+
+```bash
+jev noul --question 'Is this urgent?' --state 'Restore service today.' \
+  --model jev-latest \
+  --pretty
+```
+
+## Exit codes
+
+| Code | Meaning |
+|---:|---|
+| `0` | Success |
+| `1` | Unexpected API response or other error |
+| `2` | Invalid arguments or input |
+| `3` | Missing or rejected authentication |
+| `4` | Connection, rate-limit, or transient server error |
+
+An error is emitted as JSON on stderr:
+
+```json
+{"ok": false, "error": "TypeSafe API key is not stored; run: jev auth set"}
+```
+
+## Scope and limitations
+
+The `jev` command is a thin client for focused System One judgments. It does not generate prose, perform arithmetic, compare dates, or replace application-level validation. Keep deterministic work in code and use Jev for semantic judgments.
+
+The CLI sends the supplied state and questions to the TypeSafe API. Do not submit data that your organization is not permitted to send to that service.
+
+## License
+
+[MIT](LICENSE)

jev_cli-0.4.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+jev_cli/__init__.py,sha256=7HUg9ytx1qciSS6pktmaSj0dJWU0qD9z1-YIM0R06P8,11869
+jev_cli/bundled_skills/jev-cli/SKILL.md,sha256=w6yne7l1IA02c3rlhldNtJTN650GdE6-0N19duHkgiA,3550
+jev_cli/bundled_skills/jev-cli/references/cli.md,sha256=3t7z046QqYovrRjvsl7_MDwMf_KnH0o-Unx3ADF0dc0,2931
+jev_cli/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jev_cli-0.4.1.dist-info/licenses/LICENSE,sha256=oKoTGKD5xnfr8R9BogCNrZGMoJ9oCYg-tLqJxoeDYwQ,1061
+jev_cli-0.4.1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+jev_cli-0.4.1.dist-info/entry_points.txt,sha256=PJeuUSh7E8GY0ifzE742Z7NL_42yPSw_XPYapVdfd0I,38
+jev_cli-0.4.1.dist-info/METADATA,sha256=Dt0i_f3cdc9DLznd4o2f9qqj3v0vV8Y7GVoqtmlBZ3Q,8155
+jev_cli-0.4.1.dist-info/RECORD,,

jev_cli-0.4.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.24
+Root-Is-Purelib: true
+Tag: py3-none-any

jev_cli-0.4.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+jev = jev_cli:main
+

jev_cli-0.4.1.dist-info/licenses/LICENSE

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