typesafeai-cli 0.3.1__py3-none-any.whl

typesafe_cli/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.1"

typesafe_cli/cli.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import typer
+
+from typesafe_cli.commands.agent import schema as agent_schema
+from typesafe_cli.commands.ask import ask
+from typesafe_cli.commands.auth import status as auth_status
+from typesafe_cli.commands.decide import decide
+from typesafe_cli.commands.extract import extract
+from typesafe_cli.commands.find import find
+from typesafe_cli.commands.models import models
+from typesafe_cli.commands.oneshot import choice, noul, score
+from typesafe_cli.commands.rank import rank
+from typesafe_cli.commands.screen import screen
+from typesafe_cli.commands.skills import install as skills_install
+from typesafe_cli.commands.skills import list_skills
+from typesafe_cli.commands.smoke import smoke
+from typesafe_cli.commands.suggest_skill import suggest_skill
+from typesafe_cli.commands.verify import verify
+from typesafe_cli.help import AgentCommand, AgentGroup
+
+app = typer.Typer(
+    name="typesafe",
+    cls=AgentGroup,
+    no_args_is_help=True,
+    add_completion=False,
+    pretty_exceptions_enable=False,
+    help="Agent CLI for TypeSafe System One (Jev). Typed judgments, not chat. Agents must not read TYPESAFE_* env vars or key files; use typesafe auth status.",
+)
+
+
+def _on_agent(args: bool = False) -> bool:
+    if args:
+        from typesafe_cli.detect import set_force_agent
+
+        set_force_agent(True)
+    return args
+
+
+def _on_no_agent(args: bool = False) -> bool:
+    if args:
+        from typesafe_cli.detect import set_force_agent
+
+        set_force_agent(False)
+    return args
+
+
+@app.callback()
+def _global_options(
+    agent: bool = typer.Option(
+        False,
+        "--agent",
+        help="Force agent mode (JSON help/schema)",
+        is_eager=True,
+        callback=_on_agent,
+    ),
+    no_agent: bool = typer.Option(
+        False,
+        "--no-agent",
+        help="Disable agent mode",
+        is_eager=True,
+        callback=_on_no_agent,
+    ),
+) -> None:
+    del agent, no_agent
+
+
+auth_app = typer.Typer(cls=AgentGroup, no_args_is_help=True, help="Authentication helpers")
+auth_app.command("status", cls=AgentCommand)(auth_status)
+app.add_typer(auth_app, name="auth")
+
+agent_app = typer.Typer(cls=AgentGroup, no_args_is_help=True, help="Agent discovery")
+agent_app.command("schema", cls=AgentCommand)(agent_schema)
+app.add_typer(agent_app, name="agent")
+
+skills_app = typer.Typer(cls=AgentGroup, no_args_is_help=True, help="Install the official TypeSafe skill")
+skills_app.command("install", cls=AgentCommand)(skills_install)
+skills_app.command("list", cls=AgentCommand)(list_skills)
+app.add_typer(skills_app, name="skills")
+
+app.command("ask", cls=AgentCommand)(ask)
+app.command("noul", cls=AgentCommand)(noul)
+app.command("choice", cls=AgentCommand)(choice)
+app.command("score", cls=AgentCommand)(score)
+app.command("find", cls=AgentCommand)(find)
+app.command("rank", cls=AgentCommand)(rank)
+app.command("extract", cls=AgentCommand)(extract)
+app.command("verify", cls=AgentCommand)(verify)
+app.command("screen", cls=AgentCommand)(screen)
+app.command("suggest-skill", cls=AgentCommand)(suggest_skill)
+app.command("decide", cls=AgentCommand)(decide)
+app.command("models", cls=AgentCommand)(models)
+app.command("smoke", cls=AgentCommand)(smoke)

typesafe_cli/client.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+from typing import Any
+
+from typesafe_sdk import Choice, Noul, Score, TypeSafeClient
+
+from typesafe_cli.config import Config
+
+
+def answers_to_dict(response: Any) -> dict[str, Any]:
+    answers: dict[str, Any] = {}
+    raw_answers = getattr(response, "answers", {}) or {}
+    for qid, answer in raw_answers.items():
+        answers[qid] = _answer_to_dict(answer)
+    usage = getattr(response, "usage", None)
+    return {
+        "model": getattr(response, "model", None),
+        "answers": answers,
+        "usage": {
+            "input_tokens": getattr(usage, "input_tokens", None) if usage is not None else None,
+            "output_tokens": getattr(usage, "output_tokens", None) if usage is not None else None,
+        },
+    }
+
+
+def _answer_to_dict(answer: Any) -> dict[str, Any]:
+    if hasattr(answer, "noul") and not hasattr(answer, "choice") and not hasattr(answer, "score"):
+        return {"type": "noul", "noul": answer.noul}
+    if hasattr(answer, "choice"):
+        return {
+            "type": "choice",
+            "choice": answer.choice,
+            "probabilities": _stringify_keys(getattr(answer, "probabilities", {})),
+            "confidence": getattr(answer, "confidence", None),
+        }
+    if hasattr(answer, "score"):
+        return {
+            "type": "score",
+            "score": answer.score,
+            "legend": _stringify_keys(getattr(answer, "legend", {})),
+            "probabilities": _stringify_keys(getattr(answer, "probabilities", {})),
+            "confidence": getattr(answer, "confidence", None),
+        }
+    raise TypeError(f"unsupported answer type: {type(answer)!r}")
+
+
+def _stringify_keys(mapping: Any) -> dict[str, Any]:
+    if not mapping:
+        return {}
+    return {str(key): value for key, value in dict(mapping).items()}
+
+
+def to_sdk_questions(questions: dict[str, dict[str, Any]]) -> dict[str, Any]:
+    sdk: dict[str, Any] = {}
+    for qid, question in questions.items():
+        qtype = question["type"]
+        instructions = question["instructions"]
+        criteria = question.get("criteria")
+        if qtype == "noul":
+            sdk[qid] = Noul(instructions=instructions, criteria=criteria)
+        elif qtype == "choice":
+            sdk[qid] = Choice(instructions=instructions, criteria=criteria)
+        elif qtype == "score":
+            sdk[qid] = Score(instructions=instructions, criteria=criteria)
+        else:
+            raise ValueError(f"unknown question type: {qtype}")
+    return sdk
+
+
+def system_one(
+    *,
+    config: Config,
+    state: str | dict | list,
+    questions: dict[str, dict[str, Any]],
+    model: str | None = None,
+) -> dict[str, Any]:
+    if not config.api_key:
+        raise RuntimeError("missing API key")
+    resolved_model = model or config.model
+    with TypeSafeClient(
+        api_key=config.api_key,
+        base_url=config.base_url,
+        model=resolved_model,
+    ) as client:
+        response = client.system_one(
+            state=state,
+            questions=to_sdk_questions(questions),
+            model=resolved_model,
+        )
+    return answers_to_dict(response)
+
+
+def list_models(*, config: Config) -> dict[str, Any]:
+    if not config.api_key:
+        raise RuntimeError("missing API key")
+    with TypeSafeClient(api_key=config.api_key, base_url=config.base_url) as client:
+        listed = client.models.list()
+    models = [
+        {
+            "name": getattr(item, "name", None),
+            "description": getattr(item, "description", None),
+            "release_date": getattr(item, "release_date", None),
+        }
+        for item in getattr(listed, "models", ())
+    ]
+    return {"models": models}

typesafe_cli/commands/agent.py

@@ -0,0 +1,12 @@
+from __future__ import annotations
+
+import typer
+
+from typesafe_cli.io import emit_success
+from typesafe_cli.schema import command_schema
+
+
+def schema(
+    compact: bool = typer.Option(False, "--compact", help="Names and flags only"),
+) -> None:
+    emit_success(data=command_schema(compact=compact), command="agent schema")

typesafe_cli/commands/ask.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Any
+
+import typer
+from typesafe_sdk import TypeSafeError
+
+from typesafe_cli.client import system_one
+from typesafe_cli.config import load_config
+from typesafe_cli.io import emit_success, fail
+from typesafe_cli.questions import QuestionError, load_questions_file, load_state_file, parse_state_text
+
+
+def ask(
+    state: str | None = typer.Option(None, "--state", help="Inline state (string or JSON)"),
+    state_file: Path | None = typer.Option(None, "--state-file", help="State file; '-' reads stdin"),
+    questions_file: Path | None = typer.Option(None, "--questions-file", help="JSON questions file"),
+    model: str | None = typer.Option(None, "--model"),
+    key: str | None = typer.Option(None, "--key"),
+    creds: Path | None = typer.Option(None, "--creds"),
+) -> None:
+    if questions_file is None:
+        fail(code="usage", message="--questions-file is required", exit_code=2)
+
+    try:
+        questions, embedded_state = load_questions_file(questions_file)
+        resolved_state = _resolve_state(state=state, state_file=state_file, embedded=embedded_state)
+        config = load_config(key=key, creds=creds, model=model)
+    except QuestionError as exc:
+        fail(code="usage", message=str(exc), exit_code=2)
+    except (OSError, ValueError) as exc:
+        fail(code="usage", message=str(exc), exit_code=2)
+
+    if not config.api_key:
+        fail(code="auth", message="missing TYPESAFE_API_KEY (or --key / --creds)", exit_code=1)
+
+    try:
+        data = system_one(config=config, state=resolved_state, questions=questions, model=model)
+    except TypeSafeError as exc:
+        fail(code="request", message=str(exc), exit_code=1)
+    except Exception as exc:  # noqa: BLE001 — surface SDK/network failures as exit 1
+        fail(code="request", message=str(exc), exit_code=1)
+
+    emit_success(data=data, command="ask")
+
+
+def _resolve_state(
+    *,
+    state: str | None,
+    state_file: Path | None,
+    embedded: str | dict | list | None,
+) -> str | dict | list:
+    provided = int(state is not None) + int(state_file is not None)
+    if provided > 1:
+        raise QuestionError("use only one of --state or --state-file")
+    if state is not None:
+        return parse_state_text(state)
+    if state_file is not None:
+        if str(state_file) == "-":
+            return parse_state_text(sys.stdin.read())
+        return load_state_file(state_file)
+    if embedded is not None:
+        return embedded
+    raise QuestionError("state is required (--state, --state-file, or state in the questions file)")
+
+
+def run_evaluation(
+    *,
+    state: str | dict | list,
+    questions: dict[str, dict[str, Any]],
+    key: str | None,
+    creds: Path | None,
+    model: str | None,
+    command: str,
+) -> None:
+    try:
+        config = load_config(key=key, creds=creds, model=model)
+    except (OSError, ValueError) as exc:
+        fail(code="usage", message=str(exc), exit_code=2)
+    if not config.api_key:
+        fail(code="auth", message="missing TYPESAFE_API_KEY (or --key / --creds)", exit_code=1)
+    try:
+        data = system_one(config=config, state=state, questions=questions, model=model)
+    except TypeSafeError as exc:
+        fail(code="request", message=str(exc), exit_code=1)
+    except Exception as exc:  # noqa: BLE001
+        fail(code="request", message=str(exc), exit_code=1)
+    emit_success(data=data, command=command)

typesafe_cli/commands/auth.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from typesafe_cli.config import load_config
+from typesafe_cli.io import emit_success, fail
+
+
+def status(
+    key: str | None = typer.Option(None, "--key"),
+    creds: Path | None = typer.Option(None, "--creds"),
+    model: str | None = typer.Option(None, "--model"),
+) -> None:
+    """Report whether a key is loaded. Never prints the key. Agents must not read TYPESAFE_* vars or key files."""
+    try:
+        config = load_config(key=key, creds=creds, model=model)
+    except (OSError, ValueError) as exc:
+        fail(code="usage", message=str(exc), exit_code=2)
+    emit_success(
+        data={
+            "has_key": bool(config.api_key),
+            "base_url": config.base_url,
+            "model": config.model,
+        },
+        command="auth status",
+    )

typesafe_cli/commands/decide.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+
+from typesafe_cli.io import emit_success, fail
+from typesafe_cli.questions import QuestionError
+from typesafe_cli.recipes.decide import apply_decide, extract_answers, parse_noul_band
+from typesafe_cli.recipes.thresholds import CHOICE_MIN_TOP_P, NOUL_UNCERTAIN_HIGH, NOUL_UNCERTAIN_LOW
+
+
+def decide(
+    answers_file: Path = typer.Option(..., "--answers-file", help="JSON envelope or answers object"),
+    noul_band: str = typer.Option(
+        f"{NOUL_UNCERTAIN_LOW}:{NOUL_UNCERTAIN_HIGH}",
+        "--noul-band",
+        help="Inclusive uncertain band low:high",
+    ),
+    choice_min_p: float = typer.Option(
+        CHOICE_MIN_TOP_P,
+        "--choice-min-p",
+        help="Abstain when the winning choice probability is below this",
+    ),
+) -> None:
+    """Map raw Jev answers to no/uncertain/yes (or abstain) without another HTTP call."""
+    try:
+        payload = json.loads(answers_file.read_text(encoding="utf-8"))
+        answers = extract_answers(payload)
+        low, high = parse_noul_band(noul_band)
+        if not 0.0 <= choice_min_p <= 1.0:
+            raise QuestionError("--choice-min-p must be between 0 and 1")
+        decisions = apply_decide(answers, noul_low=low, noul_high=high, choice_min_p=choice_min_p)
+    except (OSError, json.JSONDecodeError, QuestionError) as exc:
+        fail(code="usage", message=str(exc), exit_code=2)
+    emit_success(
+        data={
+            "decisions": decisions,
+            "policy": {"noul_band": [low, high], "choice_min_p": choice_min_p},
+        },
+        command="decide",
+    )

typesafe_cli/commands/eval.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from typesafe_sdk import TypeSafeError
+
+from typesafe_cli.client import system_one
+from typesafe_cli.config import load_config
+from typesafe_cli.io import fail
+
+
+def ready_config(*, key: str | None, creds: Path | None, model: str | None):
+    try:
+        config = load_config(key=key, creds=creds, model=model)
+    except (OSError, ValueError) as exc:
+        fail(code="usage", message=str(exc), exit_code=2)
+    if not config.api_key:
+        fail(code="auth", message="missing TYPESAFE_API_KEY (or --key / --creds)", exit_code=1)
+    return config
+
+
+def call_system_one(
+    *,
+    state: str | dict | list,
+    questions: dict[str, dict[str, Any]],
+    key: str | None,
+    creds: Path | None,
+    model: str | None,
+) -> dict[str, Any]:
+    config = ready_config(key=key, creds=creds, model=model)
+    try:
+        return system_one(config=config, state=state, questions=questions, model=model)
+    except TypeSafeError as exc:
+        fail(code="request", message=str(exc), exit_code=1)
+    except Exception as exc:  # noqa: BLE001
+        fail(code="request", message=str(exc), exit_code=1)

typesafe_cli/commands/extract.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+
+from typesafe_cli.commands.eval import call_system_one
+from typesafe_cli.io import emit_success, fail
+from typesafe_cli.questions import QuestionError
+from typesafe_cli.recipes.extract import extract_questions, find_spans
+
+
+def extract(
+    question: str = typer.Option(..., "--question", help="Which span to pick"),
+    file: Path | None = typer.Option(None, "--file", help="Document to scan"),
+    state_file: Path | None = typer.Option(None, "--state-file", help="JSON or text document"),
+    pattern: str | None = typer.Option(None, "--pattern", help="email, phone, or money"),
+    candidates: Path | None = typer.Option(None, "--candidates", help="JSON array of candidate strings"),
+    model: str | None = typer.Option(None, "--model"),
+    key: str | None = typer.Option(None, "--key"),
+    creds: Path | None = typer.Option(None, "--creds"),
+) -> None:
+    """Pick a verbatim value from regex (or supplied) spans. Jev does not invent the string."""
+    try:
+        text = _document_text(file=file, state_file=state_file)
+        spans = _spans(text=text, pattern=pattern, candidates=candidates)
+    except (OSError, json.JSONDecodeError, QuestionError) as exc:
+        fail(code="usage", message=str(exc), exit_code=2)
+
+    if not spans:
+        emit_success(
+            data={"value": None, "choice": "none", "skipped": True, "candidates": []},
+            command="extract",
+        )
+        return
+
+    data = call_system_one(
+        state={"document": text, "candidates": spans, "question": question},
+        questions=extract_questions(spans, question),
+        key=key,
+        creds=creds,
+        model=model,
+    )
+    answer = data["answers"]["value"]
+    choice = answer["choice"]
+    value = None if choice == "none" else choice
+    emit_success(
+        data={
+            "value": value,
+            "choice": choice,
+            "confidence": answer.get("confidence"),
+            "candidates": spans,
+            "skipped": False,
+            "model": data.get("model"),
+            "usage": data.get("usage"),
+        },
+        command="extract",
+    )
+
+
+def _document_text(*, file: Path | None, state_file: Path | None) -> str:
+    provided = int(file is not None) + int(state_file is not None)
+    if provided != 1:
+        raise QuestionError("exactly one of --file or --state-file is required")
+    path = file or state_file
+    assert path is not None
+    return path.read_text(encoding="utf-8")
+
+
+def _spans(*, text: str, pattern: str | None, candidates: Path | None) -> list[str]:
+    if candidates is not None:
+        raw = json.loads(candidates.read_text(encoding="utf-8"))
+        if not isinstance(raw, list) or not all(isinstance(item, str) for item in raw):
+            raise QuestionError("--candidates must be a JSON array of strings")
+        seen: list[str] = []
+        for item in raw:
+            if item not in seen:
+                seen.append(item)
+        return seen
+    if pattern is None:
+        raise QuestionError("--pattern or --candidates is required")
+    return find_spans(text, pattern)

typesafe_cli/commands/find.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from typesafe_cli.commands.eval import call_system_one
+from typesafe_cli.io import emit_success, fail
+from typesafe_cli.questions import QuestionError
+from typesafe_cli.recipes.find import FIND_CHUNK, find_questions, merge_find_results, tag_lines, tagged_state, windows
+
+
+def find(
+    file: Path = typer.Option(..., "--file", help="Local file to search"),
+    query: str = typer.Option(..., "--query", help="Plain-language question"),
+    model: str | None = typer.Option(None, "--model"),
+    key: str | None = typer.Option(None, "--key"),
+    creds: Path | None = typer.Option(None, "--creds"),
+) -> None:
+    """Semantic line search: tag lines, Choice over ids, Noul whether an answer exists."""
+    try:
+        text = file.read_text(encoding="utf-8")
+        lines = tag_lines(text)
+        if not lines:
+            raise QuestionError("file is empty")
+    except (OSError, QuestionError) as exc:
+        fail(code="usage", message=str(exc), exit_code=2)
+
+    by_id = {line["id"]: line["text"] for line in lines}
+    chunks = []
+    for window in windows(lines, size=FIND_CHUNK):
+        data = call_system_one(
+            state=tagged_state(window),
+            questions=find_questions(window, query),
+            key=key,
+            creds=creds,
+            model=model,
+        )
+        chunks.append(data)
+
+    merged = merge_find_results(lines_by_id=by_id, chunks=chunks)
+    emit_success(
+        data={
+            "query": query,
+            "file": str(file),
+            "verdict": merged["verdict"],
+            "exists": merged["exists"],
+            "lines": merged["query_lines"][:20],
+            "model": merged["model"],
+            "usage": merged["usage"],
+        },
+        command="find",
+    )

typesafe_cli/commands/models.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from typesafe_sdk import TypeSafeError
+
+from typesafe_cli.client import list_models
+from typesafe_cli.config import load_config
+from typesafe_cli.io import emit_success, fail
+
+
+def models(
+    key: str | None = typer.Option(None, "--key"),
+    creds: Path | None = typer.Option(None, "--creds"),
+    model: str | None = typer.Option(None, "--model"),
+) -> None:
+    try:
+        config = load_config(key=key, creds=creds, model=model)
+    except (OSError, ValueError) as exc:
+        fail(code="usage", message=str(exc), exit_code=2)
+    if not config.api_key:
+        fail(code="auth", message="missing TYPESAFE_API_KEY (or --key / --creds)", exit_code=1)
+    try:
+        data = list_models(config=config)
+    except TypeSafeError as exc:
+        fail(code="request", message=str(exc), exit_code=1)
+    except Exception as exc:  # noqa: BLE001
+        fail(code="request", message=str(exc), exit_code=1)
+    emit_success(data=data, command="models")

typesafe_cli/commands/oneshot.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import typer
+
+from typesafe_cli.commands.ask import run_evaluation
+from typesafe_cli.io import fail
+from typesafe_cli.questions import QuestionError, load_questions, load_state_file, parse_state_text
+
+
+def _state_from_flags(state: str | None, state_file: Path | None) -> str | dict | list:
+    provided = int(state is not None) + int(state_file is not None)
+    if provided != 1:
+        raise QuestionError("exactly one of --state or --state-file is required")
+    if state is not None:
+        return parse_state_text(state)
+    assert state_file is not None
+    if str(state_file) == "-":
+        return parse_state_text(sys.stdin.read())
+    return load_state_file(state_file)
+
+
+def noul(
+    instructions: str = typer.Argument(..., help="Yes/no question"),
+    state: str | None = typer.Option(None, "--state"),
+    state_file: Path | None = typer.Option(None, "--state-file"),
+    question_id: str = typer.Option("noul", "--id"),
+    model: str | None = typer.Option(None, "--model"),
+    key: str | None = typer.Option(None, "--key"),
+    creds: Path | None = typer.Option(None, "--creds"),
+) -> None:
+    try:
+        resolved = _state_from_flags(state, state_file)
+        questions = load_questions({question_id: {"type": "noul", "instructions": instructions}})
+    except QuestionError as exc:
+        fail(code="usage", message=str(exc), exit_code=2)
+    run_evaluation(state=resolved, questions=questions, key=key, creds=creds, model=model, command="noul")
+
+
+def choice(
+    instructions: str = typer.Argument(..., help="Choice question"),
+    state: str | None = typer.Option(None, "--state"),
+    state_file: Path | None = typer.Option(None, "--state-file"),
+    option: list[str] = typer.Option(..., "--option", help="Choice option; at least two"),
+    question_id: str = typer.Option("choice", "--id"),
+    model: str | None = typer.Option(None, "--model"),
+    key: str | None = typer.Option(None, "--key"),
+    creds: Path | None = typer.Option(None, "--creds"),
+) -> None:
+    criteria = _parse_named_flags(option)
+    try:
+        resolved = _state_from_flags(state, state_file)
+        questions = load_questions(
+            {question_id: {"type": "choice", "instructions": instructions, "criteria": criteria}}
+        )
+    except QuestionError as exc:
+        fail(code="usage", message=str(exc), exit_code=2)
+    run_evaluation(state=resolved, questions=questions, key=key, creds=creds, model=model, command="choice")
+
+
+def score(
+    instructions: str = typer.Argument(..., help="Score question"),
+    state: str | None = typer.Option(None, "--state"),
+    state_file: Path | None = typer.Option(None, "--state-file"),
+    level: list[str] = typer.Option(..., "--level", help="Score level, lowest first; at least two"),
+    question_id: str = typer.Option("score", "--id"),
+    model: str | None = typer.Option(None, "--model"),
+    key: str | None = typer.Option(None, "--key"),
+    creds: Path | None = typer.Option(None, "--creds"),
+) -> None:
+    try:
+        resolved = _state_from_flags(state, state_file)
+        questions = load_questions(
+            {question_id: {"type": "score", "instructions": instructions, "criteria": level}}
+        )
+    except QuestionError as exc:
+        fail(code="usage", message=str(exc), exit_code=2)
+    run_evaluation(state=resolved, questions=questions, key=key, creds=creds, model=model, command="score")
+
+
+def _parse_named_flags(values: list[str]) -> dict[str, str | None]:
+    criteria: dict[str, str | None] = {}
+    for raw in values:
+        if "=" in raw:
+            name, description = raw.split("=", 1)
+            criteria[name] = description
+        else:
+            criteria[raw] = None
+    return criteria