quaestor-cli 0.3.0__tar.gz → 0.4.0__tar.gz

{quaestor_cli-0.3.0 → quaestor_cli-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: quaestor-cli
-Version: 0.3.0
+Version: 0.4.0
 Summary: Command-line client for the Quaestor API — built for humans and agents.
 Project-URL: Homepage, https://quaestor.app
 Project-URL: Repository, https://github.com/neuromaxer/quaestor-lite
@@ -39,10 +39,9 @@ uv tool install quaestor-cli
 ## Setup
 
 Create an API key in the Quaestor web app under **Profile → Developer Access**.
-Set the backend URL, then store the key from stdin. On macOS, copy the key and run:
+The CLI uses the hosted production API automatically. On macOS, copy the key and run:
 
 ```bash
-export QUAESTOR_URL="https://your-quaestor-backend"   # defaults to http://localhost:8000
 pbpaste | qst auth login
 qst doctor
 ```
@@ -54,9 +53,9 @@ The key is stored at `~/.config/quaestor/credentials.json` with mode `0600`. The
 CLI also supports `QUAESTOR_API_KEY`; an existing environment variable takes
 precedence over the file, but it is not needed for this setup.
 
-`qst` refuses to send a key over plain HTTP to anything but a loopback host. Set
-`QUAESTOR_ALLOW_INSECURE=1` only if you are knowingly running a plaintext self-hosted
-backend.
+Logging in again replaces the key while preserving an existing server override.
+`qst doctor` reports authentication as unknown when the server cannot verify it;
+only an explicit authentication refusal means the key was rejected.
 
 ## The evening diary workflow
 
@@ -84,7 +83,7 @@ qst doctor                       Check URL, reachability, credential and granted
 qst agenda [--week|--days N]     Overdue, past deadline, ready to plan, and each day's quests
 qst quests [words] [filters]     Find quests: --status, --overdue, --on, --from/--to,
                                  --deadline-by, --under <quest>, --archived, --sort, --limit
-qst quest show <quest>           Status, dates, sub-quest progress, description, latest Quest Log
+qst quest show <quest>           Status, dates, sub-quest progress, linked quests, its link, description, latest Quest Log
 qst quest log <quest>            Quest Log entries, newest first (--date for one day)
 qst quest add <title>            --under <quest> --on fri --due <date> --priority high --emoji 🚀 ...
 qst quest edit <quest>           --title --emoji --priority --start/--due (or 'none') --under/--top-level
@@ -96,10 +95,14 @@ qst quest reschedule <q> <from> [to]   Move one planned day (to today by default
 qst quest check <quest>          Check off a day (--date, --undo); starts Backlog/Todo quests
 qst quest note <quest> <text>    Append to that day's Quest Log entry (--date, --replace)
 qst quest link|unlink <quest> <streak>  Link a streak (context only, nothing syncs)
+qst quest link-quest|unlink-quest <quest> <other>  Link two related quests (both list each other)
+qst quest mention <quest>        Markdown link for a note or description; the app shows it as a chip
 ```
 
 Every command takes `--json` for machine-readable output on stdout. Every write takes
-`--dry-run`, which prints the request and sends nothing.
+`--dry-run`, which prints the request and writes nothing. `log` uses a read-only
+streak lookup to validate the name, mode and `--unit` before printing the resolved
+payload. A COUNT/TIME mismatch or wrong unit exits `1` without posting an event.
 
 ### Windows
 
@@ -219,3 +222,18 @@ documentation](https://github.com/neuromaxer/quaestor-lite/blob/main/docs/featur
 
 Python 3.12+. Depends only on `httpx` and `typer` — it speaks HTTP and never imports the
 Quaestor backend, so it installs in seconds and tolerates version skew against the server.
+
+## Developer configuration
+
+Use `qst --dev doctor` to target `http://localhost:8000` for that invocation.
+The development flag is hidden from normal help and never persists a local URL.
+
+Staging and self-hosted deployments can still use `QUAESTOR_URL` or an existing
+`base_url` in the credential store. Resolution order is `--dev`, environment, stored
+URL, then the hosted production default. Ordinary hosted setup needs no override.
+
+Quest links (`qst quest mention`, `show`) point at the web app: `https://quaestor.app` by
+default, `http://localhost:3000` with `--dev`, or `QUAESTOR_APP_URL` for other deployments.
+
+`qst` refuses to send a key over plain HTTP except to loopback. Set
+`QUAESTOR_ALLOW_INSECURE=1` only for deliberate plaintext development deployments.

{quaestor_cli-0.3.0 → quaestor_cli-0.4.0}/README.md

@@ -17,10 +17,9 @@ uv tool install quaestor-cli
 ## Setup
 
 Create an API key in the Quaestor web app under **Profile → Developer Access**.
-Set the backend URL, then store the key from stdin. On macOS, copy the key and run:
+The CLI uses the hosted production API automatically. On macOS, copy the key and run:
 
 ```bash
-export QUAESTOR_URL="https://your-quaestor-backend"   # defaults to http://localhost:8000
 pbpaste | qst auth login
 qst doctor
 ```
@@ -32,9 +31,9 @@ The key is stored at `~/.config/quaestor/credentials.json` with mode `0600`. The
 CLI also supports `QUAESTOR_API_KEY`; an existing environment variable takes
 precedence over the file, but it is not needed for this setup.
 
-`qst` refuses to send a key over plain HTTP to anything but a loopback host. Set
-`QUAESTOR_ALLOW_INSECURE=1` only if you are knowingly running a plaintext self-hosted
-backend.
+Logging in again replaces the key while preserving an existing server override.
+`qst doctor` reports authentication as unknown when the server cannot verify it;
+only an explicit authentication refusal means the key was rejected.
 
 ## The evening diary workflow
 
@@ -62,7 +61,7 @@ qst doctor                       Check URL, reachability, credential and granted
 qst agenda [--week|--days N]     Overdue, past deadline, ready to plan, and each day's quests
 qst quests [words] [filters]     Find quests: --status, --overdue, --on, --from/--to,
                                  --deadline-by, --under <quest>, --archived, --sort, --limit
-qst quest show <quest>           Status, dates, sub-quest progress, description, latest Quest Log
+qst quest show <quest>           Status, dates, sub-quest progress, linked quests, its link, description, latest Quest Log
 qst quest log <quest>            Quest Log entries, newest first (--date for one day)
 qst quest add <title>            --under <quest> --on fri --due <date> --priority high --emoji 🚀 ...
 qst quest edit <quest>           --title --emoji --priority --start/--due (or 'none') --under/--top-level
@@ -74,10 +73,14 @@ qst quest reschedule <q> <from> [to]   Move one planned day (to today by default
 qst quest check <quest>          Check off a day (--date, --undo); starts Backlog/Todo quests
 qst quest note <quest> <text>    Append to that day's Quest Log entry (--date, --replace)
 qst quest link|unlink <quest> <streak>  Link a streak (context only, nothing syncs)
+qst quest link-quest|unlink-quest <quest> <other>  Link two related quests (both list each other)
+qst quest mention <quest>        Markdown link for a note or description; the app shows it as a chip
 ```
 
 Every command takes `--json` for machine-readable output on stdout. Every write takes
-`--dry-run`, which prints the request and sends nothing.
+`--dry-run`, which prints the request and writes nothing. `log` uses a read-only
+streak lookup to validate the name, mode and `--unit` before printing the resolved
+payload. A COUNT/TIME mismatch or wrong unit exits `1` without posting an event.
 
 ### Windows
 
@@ -197,3 +200,18 @@ documentation](https://github.com/neuromaxer/quaestor-lite/blob/main/docs/featur
 
 Python 3.12+. Depends only on `httpx` and `typer` — it speaks HTTP and never imports the
 Quaestor backend, so it installs in seconds and tolerates version skew against the server.
+
+## Developer configuration
+
+Use `qst --dev doctor` to target `http://localhost:8000` for that invocation.
+The development flag is hidden from normal help and never persists a local URL.
+
+Staging and self-hosted deployments can still use `QUAESTOR_URL` or an existing
+`base_url` in the credential store. Resolution order is `--dev`, environment, stored
+URL, then the hosted production default. Ordinary hosted setup needs no override.
+
+Quest links (`qst quest mention`, `show`) point at the web app: `https://quaestor.app` by
+default, `http://localhost:3000` with `--dev`, or `QUAESTOR_APP_URL` for other deployments.
+
+`qst` refuses to send a key over plain HTTP except to loopback. Set
+`QUAESTOR_ALLOW_INSECURE=1` only for deliberate plaintext development deployments.

{quaestor_cli-0.3.0 → quaestor_cli-0.4.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "quaestor-cli"
-version = "0.3.0"
+version = "0.4.0"
 description = "Command-line client for the Quaestor API — built for humans and agents."
 readme = "README.md"
 requires-python = ">=3.12"

{quaestor_cli-0.3.0 → quaestor_cli-0.4.0}/src/quaestor_cli/commands/doctor.py

@@ -10,7 +10,7 @@ from quaestor_cli import __version__, api
 from quaestor_cli.client import QuaestorClient
 from quaestor_cli.config import ENV_API_KEY, credentials_path
 from quaestor_cli.errors import CliError, ExitCode
-from quaestor_cli.output import emit, emit_json, format_scopes
+from quaestor_cli.output import emit, emit_json, format_scopes, warn
 from quaestor_cli.runtime import CliState, JsonFlag, cli_state, execute
 
 UNKNOWN = "unknown"
@@ -45,7 +45,7 @@ class Diagnosis:
     credential_source: str
     key_label: str
     reachable: bool
-    authenticated: bool
+    authenticated: bool | None
     scopes: list[str] | None
     """None when the server has no /auth/whoami, i.e. scopes are unknowable."""
     user: str | None = None
@@ -58,6 +58,8 @@ class Diagnosis:
         """Worst problem found decides the exit code."""
         if not self.reachable:
             return ExitCode.SERVER
+        if self.authenticated is None:
+            return ExitCode.SERVER
         if not self.authenticated:
             return ExitCode.AUTH
         return ExitCode.OK
@@ -77,7 +79,12 @@ def _run(state: CliState) -> None:
     else:
         emit(*_lines(diagnosis))
     if diagnosis.exit_code is not ExitCode.OK:
-        raise CliError(diagnosis.detail or "Health check failed.", diagnosis.exit_code)
+        detail = diagnosis.detail or "Health check failed."
+        if state.json_output:
+            # The diagnosis already includes the failure; keep stdout one JSON document.
+            warn(detail)
+            raise typer.Exit(code=int(diagnosis.exit_code))
+        raise CliError(detail, diagnosis.exit_code)
 
 
 def diagnose(state: CliState) -> Diagnosis:
@@ -86,13 +93,14 @@ def diagnose(state: CliState) -> Diagnosis:
     anonymous = QuaestorClient(base_url=state.config.base_url)
     health = anonymous.probe(api.HEALTHZ_PATH)
 
-    authenticated = False
+    authenticated: bool | None = None
     scopes: list[str] | None = None
     user: str | None = None
     detail: str | None = None
     if not health.is_success:
         detail = health.detail
     elif credential is None:
+        authenticated = False
         detail = f"No API key: set {ENV_API_KEY} or run 'qst auth login'."
     else:
         auth = _check_credential(state)
@@ -106,7 +114,7 @@ def diagnose(state: CliState) -> Diagnosis:
         base_url=state.config.base_url,
         credential_source=credential.source if credential else "none",
         key_label=credential.label if credential else "-",
-        reachable=health.is_success,
+        reachable=health.reachable,
         authenticated=authenticated,
         scopes=scopes,
         user=user,
@@ -119,7 +127,7 @@ def diagnose(state: CliState) -> Diagnosis:
 class _CredentialCheck:
     """What the identity lookup could establish about the credential."""
 
-    authenticated: bool
+    authenticated: bool | None
     scopes: list[str] | None
     user: str | None
     detail: str | None
@@ -138,12 +146,17 @@ def _check_credential(state: CliState) -> _CredentialCheck:
             detail=None,
         )
     if not lookup.is_unsupported:
-        return _CredentialCheck(authenticated=False, scopes=None, user=None, detail=lookup.probe.detail)
+        return _CredentialCheck(
+            authenticated=False if lookup.probe.rejected_credential else None,
+            scopes=None,
+            user=None,
+            detail=lookup.probe.detail,
+        )
 
     # Server predates /auth/whoami: doctor must still say whether the key works.
     fallback = client.probe(api.STREAKS_PATH, {"limit": 1})
     return _CredentialCheck(
-        authenticated=fallback.is_success,
+        authenticated=True if fallback.is_success else False if fallback.rejected_credential else None,
         scopes=None,
         user=None,
         detail=None if fallback.is_success else fallback.detail,
@@ -154,19 +167,31 @@ def _lines(diagnosis: Diagnosis) -> tuple[str, ...]:
     """Render the diagnosis as aligned human-readable lines."""
     if diagnosis.scopes is not None:
         scopes = format_scopes(diagnosis.scopes)
+    elif not diagnosis.reachable:
+        scopes = f"{UNKNOWN} (host unreachable)"
+    elif diagnosis.authenticated is None:
+        scopes = f"{UNKNOWN} (authentication check failed)"
+    elif diagnosis.credential_source == "none":
+        scopes = f"{UNKNOWN} (no API key)"
     elif not diagnosis.authenticated:
         # The credential was rejected, so scopes were never knowable. Blaming the
         # server's age here points the reader at the wrong problem.
         scopes = f"{UNKNOWN} (credential was rejected)"
     else:
         scopes = f"{UNKNOWN} (this server has no /auth/whoami)"
+    if not diagnosis.reachable:
+        authenticated = f"{UNKNOWN} (host unreachable)"
+    elif diagnosis.authenticated is None:
+        authenticated = f"{UNKNOWN} (authentication check failed)"
+    else:
+        authenticated = "yes" if diagnosis.authenticated else "no"
     fields = (
         ("cli version", diagnosis.cli_version),
         ("base url", diagnosis.base_url),
         ("credential", f"{diagnosis.credential_source} ({diagnosis.key_label})"),
         ("store", str(credentials_path())),
         ("reachable", "yes" if diagnosis.reachable else "no"),
-        ("authenticated", "yes" if diagnosis.authenticated else "no"),
+        ("authenticated", authenticated),
         ("user", diagnosis.user or "-"),
         ("scopes", scopes),
     )

{quaestor_cli-0.3.0 → quaestor_cli-0.4.0}/src/quaestor_cli/commands/log.py

@@ -186,21 +186,16 @@ def _window_from_duration(day: date, duration: timedelta, now: datetime) -> Time
 
 def _run(state: CliState, *, streak_query: str, intent: LogIntent, unit: str | None) -> None:
     """Resolve the streak, validate it against the intent, then POST the event."""
-    if state.dry_run:
-        report_dry_run(
-            state,
-            path=api.EVENTS_PATH,
-            body=intent.to_body(streak_id=None, idempotency_key=state.idempotency_key),
-            unresolved_streak=streak_query,
-        )
-        return
-
     client = state.client()
     match = resolve_streak(api.list_streaks(client), streak_query)
     _check_mode(match.streak, intent)
     _check_unit(match.streak, unit)
 
     body = intent.to_body(streak_id=match.streak.id, idempotency_key=state.idempotency_key)
+    if state.dry_run:
+        report_dry_run(state, path=api.EVENTS_PATH, body=body)
+        return
+
     created = api.create_event(client, body)
 
     if state.json_output:

{quaestor_cli-0.3.0 → quaestor_cli-0.4.0}/src/quaestor_cli/commands/quest.py

@@ -22,6 +22,7 @@ from quaestor_cli.client import QuaestorClient
 from quaestor_cli.commands.quest_format import fmt_day, named, priority, progress, timeline
 from quaestor_cli.errors import CliError, ExitCode, usage_error
 from quaestor_cli.output import emit, emit_json
+from quaestor_cli.quest_links import mention_markdown, quest_url
 from quaestor_cli.quest_models import PRIORITY_LABEL, STATUS_LABEL, Quest
 from quaestor_cli.resolve import resolve_streak
 from quaestor_cli.runtime import (
@@ -163,8 +164,9 @@ def show_command(ctx: typer.Context, quest: QuestArg, json_output: JsonFlag = Fa
         client = state.client()
         today = date.today()
         detail, raw = quest_api.get_detail(client, _resolve(client, quest).id, today=today)
+        url = quest_url(state.config.app_url, detail.quest.id)
         if state.json_output:
-            emit_json(raw)
+            emit_json({**raw, "url": url} if isinstance(raw, dict) else raw)
             return
         q = detail.quest
         dates = ", ".join(f"{fmt_day(t.day, today)} {_state_label(t, today)}" for t in q.todo_dates)
@@ -177,6 +179,8 @@ def show_command(ctx: typer.Context, quest: QuestArg, json_output: JsonFlag = Fa
             f"  todo dates: {dates or '-'}",
             f"  sub-quests: {f'{progress(q)} done' if q.progress_total else 'none'}",
             f"  streaks:    {', '.join(streak_names) if streak_names else 'none linked'}",
+            f"  linked:     {'; '.join(lq.full_path for lq in detail.linked) if detail.linked else 'none'}",
+            f"  link:       {url}",
             *[f"  {line}" for line in _hidden_note(q)],
         ]
         if detail.description.strip():
@@ -681,7 +685,7 @@ def link_command(
     json_output: JsonFlag = False,
     dry_run: DryRunFlag = False,
 ) -> None:
-    """Link a streak to a quest (context only: nothing is logged or synced)."""
+    """Link a streak to a quest (context only: nothing is logged or synced). For quests, see link-quest."""
     state = cli_state(ctx, json_output, dry_run)
     execute(lambda: _link(state, quest, streak, unlink=False))
 
@@ -697,3 +701,76 @@ def unlink_command(
     """Remove a streak link from a quest (a no-op if it isn't linked)."""
     state = cli_state(ctx, json_output, dry_run)
     execute(lambda: _link(state, quest, streak, unlink=True))
+
+
+# ---------------------------------------------------------------------------
+# Quest links (symmetric: each quest lists the other) and mentions
+# ---------------------------------------------------------------------------
+
+
+def _link_quest(state: CliState, quest: str, other: str, *, unlink: bool) -> None:
+    client = state.client()
+    target = _resolve(client, quest)
+    match = _resolve(client, other)
+    if match.id == target.id:
+        raise usage_error(f"{target.full_path} can't be linked to itself.")
+    linked = match.id in target.linked_quest_ids
+    if linked != unlink:
+        # Already in the requested state: nothing to send, and not an error for an agent.
+        state_word = "is already linked to" if linked else "wasn't linked to"
+        if state.json_output:
+            emit_json({"changed": False, "quest": target.full_path, "linked_quest": match.full_path})
+        else:
+            emit(f"{target.full_path} {state_word} {match.full_path}; nothing changed.")
+        return
+
+    def describe(result: quest_api.WriteResult) -> list[str]:
+        verb, joiner = ("Unlinked", "from") if unlink else ("Linked", "to")
+        return [f"{verb} {target.full_path} {joiner} {match.full_path}."]
+
+    step = Step("DELETE" if unlink else "PUT", quest_api.quest_path(target.id, "links", match.id))
+    resolved = {"quest": target.full_path, "linked_quest": match.full_path}
+    _run(state, Plan([step], describe, target=target, resolved=resolved))
+
+
+@app.command("link-quest")
+def link_quest_command(
+    ctx: typer.Context,
+    quest: QuestArg,
+    other: Annotated[str, typer.Argument(help="The quest to link (name or path).")],
+    json_output: JsonFlag = False,
+    dry_run: DryRunFlag = False,
+) -> None:
+    """Link two quests as related; both then list each other (navigation only, nothing syncs)."""
+    state = cli_state(ctx, json_output, dry_run)
+    execute(lambda: _link_quest(state, quest, other, unlink=False))
+
+
+@app.command("unlink-quest")
+def unlink_quest_command(
+    ctx: typer.Context,
+    quest: QuestArg,
+    other: Annotated[str, typer.Argument(help="The linked quest (name or path).")],
+    json_output: JsonFlag = False,
+    dry_run: DryRunFlag = False,
+) -> None:
+    """Remove the link between two quests, from both sides (a no-op if they aren't linked)."""
+    state = cli_state(ctx, json_output, dry_run)
+    execute(lambda: _link_quest(state, quest, other, unlink=True))
+
+
+@app.command("mention")
+def mention_command(ctx: typer.Context, quest: QuestArg, json_output: JsonFlag = False) -> None:
+    """Print a Markdown link to a quest. Put it in a note or description: the app shows it as a quest chip."""
+    state = cli_state(ctx, json_output)
+
+    def run() -> None:
+        target = _resolve(state.client(), quest)
+        url = quest_url(state.config.app_url, target.id)
+        markdown = mention_markdown(state.config.app_url, target.id, target.label)
+        if state.json_output:
+            emit_json({"quest": target.full_path, "id": target.id, "url": url, "markdown": markdown})
+        else:
+            emit(markdown)
+
+    execute(run)

{quaestor_cli-0.3.0 → quaestor_cli-0.4.0}/src/quaestor_cli/config.py

@@ -1,9 +1,4 @@
-"""Credential and base-URL resolution.
-
-The environment is the primary mechanism (`QUAESTOR_API_KEY`, `QUAESTOR_URL`);
-`~/.config/quaestor/credentials.json` is the fallback store written by
-`qst auth login`. The environment always wins over the file.
-"""
+"""Resolve credentials and developer URL overrides, defaulting to hosted Quaestor."""
 
 from __future__ import annotations
 
@@ -16,9 +11,14 @@ from urllib.parse import urlparse
 
 from quaestor_cli.errors import auth_error, server_error, usage_error
 
-DEFAULT_BASE_URL = "http://localhost:8000"
+DEFAULT_BASE_URL = "https://ql-backend-fniqyq6lfa-ey.a.run.app"
+LOCAL_BASE_URL = "http://localhost:8000"
+# The web app, for quest links (`<app>/home?tab=quests&quest=<id>`) that it shows as chips.
+DEFAULT_APP_URL = "https://quaestor.app"
+LOCAL_APP_URL = "http://localhost:3000"
 ENV_API_KEY = "QUAESTOR_API_KEY"
 ENV_BASE_URL = "QUAESTOR_URL"
+ENV_APP_URL = "QUAESTOR_APP_URL"
 
 _API_KEY_PREFIX = "qst_live_"
 _CREDENTIALS_FILE_MODE = 0o600
@@ -48,6 +48,7 @@ class Config:
 
     base_url: str
     credential: Credential | None
+    app_url: str = DEFAULT_APP_URL
 
     def require_credential(self) -> Credential:
         """Return the credential or fail with the auth exit code."""
@@ -79,8 +80,8 @@ def credentials_path() -> Path:
     return config_dir() / "credentials.json"
 
 
-def load_config() -> Config:
-    """Resolve base URL and credential from the environment, then the file."""
+def load_config(*, dev: bool = False) -> Config:
+    """Resolve an explicit dev target, then environment, file, and hosted defaults."""
     stored = _read_credentials_file()
     env_key = os.environ.get(ENV_API_KEY, "").strip()
 
@@ -91,8 +92,10 @@ def load_config() -> Config:
         credential = Credential(api_key=stored.api_key, source="file")
 
     env_url = os.environ.get(ENV_BASE_URL, "").strip()
-    base_url = (env_url or stored.base_url or DEFAULT_BASE_URL).rstrip("/")
-    return Config(base_url=base_url, credential=credential)
+    base_url = (LOCAL_BASE_URL if dev else env_url or stored.base_url or DEFAULT_BASE_URL).rstrip("/")
+    env_app_url = os.environ.get(ENV_APP_URL, "").strip()
+    app_url = (LOCAL_APP_URL if dev else env_app_url or DEFAULT_APP_URL).rstrip("/")
+    return Config(base_url=base_url, credential=credential, app_url=app_url)
 
 
 _LOOPBACK_HOSTS = frozenset({"localhost", "127.0.0.1", "::1", "[::1]"})
@@ -157,7 +160,11 @@ def save_credential(api_key: str) -> Path:
     os.chmod(directory, _CREDENTIALS_DIR_MODE)
 
     path = credentials_path()
-    payload = json.dumps({"api_key": key}, indent=2) + "\n"
+    stored = _read_credentials_file()
+    contents = {"api_key": key}
+    if stored.base_url:
+        contents["base_url"] = stored.base_url
+    payload = json.dumps(contents, indent=2) + "\n"
     # Open with the mode up front so the secret is never briefly world-readable,
     # then chmod as well for the case where the file already existed.
     fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, _CREDENTIALS_FILE_MODE)

{quaestor_cli-0.3.0 → quaestor_cli-0.4.0}/src/quaestor_cli/main.py

@@ -47,12 +47,13 @@ def main(
         help="Reuse this key when retrying a write (add, note, log) so it is applied once.",
     ),
     version: bool = typer.Option(False, "--version", help="Print the CLI version and exit."),
+    dev: bool = typer.Option(False, "--dev", hidden=True, help="Use the local development API."),
 ) -> None:
     """Accept global flags before the subcommand, e.g. `qst --json streaks`."""
     if version:
         typer.echo(__version__)
         raise typer.Exit()
-    ctx.obj = RootFlags(json_output=json_output, dry_run=dry_run, idempotency_key=idempotency_key)
+    ctx.obj = RootFlags(json_output=json_output, dry_run=dry_run, idempotency_key=idempotency_key, dev=dev)
 
 
 def _with_window_rules(summary: str) -> str:

quaestor_cli-0.4.0/src/quaestor_cli/quest_links.py

@@ -0,0 +1,20 @@
+"""Links to quests in the web app, which shows them as quest chips in Markdown.
+
+Same format as the app's "Copy link" (`<app>/home?tab=quests&quest=<id>`), so a
+mention an agent writes into a note or description renders exactly like one pasted there.
+"""
+
+from __future__ import annotations
+
+import re
+
+_LABEL_SPECIAL = re.compile(r"([\\\[\]])")
+
+
+def quest_url(app_url: str, quest_id: str) -> str:
+    return f"{app_url.rstrip('/')}/home?tab=quests&quest={quest_id}"
+
+
+def mention_markdown(app_url: str, quest_id: str, label: str) -> str:
+    """`[label](url)` with Markdown brackets in the label escaped, so a title can't break the link."""
+    return f"[{_LABEL_SPECIAL.sub(r'\\\1', label)}]({quest_url(app_url, quest_id)})"

{quaestor_cli-0.3.0 → quaestor_cli-0.4.0}/src/quaestor_cli/quest_models.py

@@ -59,6 +59,8 @@ class Quest:
     progress_done: int
     progress_total: int
     emoji: str | None = None
+    # Related quests (symmetric): each lists the other.
+    linked_quest_ids: tuple[str, ...] = ()
     # Archived, or inside an archived quest: still addressable, but hidden in the app.
     hidden: bool = False
     # The actionable missed day (spec §6.2), when listed with a local today.
@@ -99,6 +101,7 @@ class Quest:
         raw_path = payload.get("path")
         path = tuple(str(p) for p in raw_path) if isinstance(raw_path, list) else ()
         raw_streaks = payload.get("streak_ids")
+        raw_linked = payload.get("linked_quest_ids")
         return cls(
             id=str(payload.get("id", "")),
             title=str(payload.get("title", "")),
@@ -113,6 +116,7 @@ class Quest:
             end_date=_optional_date(payload.get("end_date")),
             todo_dates=dates,
             streak_ids=tuple(str(s) for s in raw_streaks) if isinstance(raw_streaks, list) else (),
+            linked_quest_ids=tuple(str(q) for q in raw_linked) if isinstance(raw_linked, list) else (),
             diary_count=_optional_int(payload.get("diary_count")) or 0,
             progress_done=_optional_int(progress.get("done")) or 0,
             progress_total=_optional_int(progress.get("total")) or 0,
@@ -130,13 +134,28 @@ class DiaryEntry:
     source: str | None
 
 
+@dataclass(frozen=True)
+class LinkedQuest:
+    """A linked quest as the detail names it."""
+
+    id: str
+    title: str
+    status: str
+    path: tuple[str, ...]
+
+    @property
+    def full_path(self) -> str:
+        return PATH_SEPARATOR.join([*self.path, self.title or "Untitled"])
+
+
 @dataclass(frozen=True)
 class QuestDetail:
-    """A quest plus its Markdown description and diary (newest first)."""
+    """A quest plus its Markdown description, diary (newest first) and linked quests."""
 
     quest: Quest
     description: str
     diary: tuple[DiaryEntry, ...]
+    linked: tuple[LinkedQuest, ...] = ()
 
     @classmethod
     def from_payload(cls, payload: Mapping[str, Any]) -> QuestDetail:
@@ -145,10 +164,20 @@ class QuestDetail:
             for e in _mappings(payload.get("diary"))
             if (d := _optional_date(e.get("date"))) is not None
         )
+        linked = tuple(
+            LinkedQuest(
+                id=str(q.get("id", "")),
+                title=str(q.get("title", "")),
+                status=str(q.get("status", "")),
+                path=tuple(str(p) for p in raw) if isinstance(raw := q.get("path"), list) else (),
+            )
+            for q in _mappings(payload.get("linked_quests"))
+        )
         return cls(
             quest=Quest.from_payload(payload),
             description=str(payload.get("description") or ""),
             diary=diary,
+            linked=linked,
         )
 
 

{quaestor_cli-0.3.0 → quaestor_cli-0.4.0}/src/quaestor_cli/runtime.py

@@ -18,7 +18,7 @@ from quaestor_cli.output import emit, emit_json, warn
 
 JsonFlag = Annotated[bool, typer.Option("--json", help="Emit machine-readable JSON on stdout.")]
 DryRunFlag = Annotated[
-    bool, typer.Option("--dry-run", help="Print the request that would be sent; send nothing.")
+    bool, typer.Option("--dry-run", help="Print the request that would be sent; write nothing.")
 ]
 
 
@@ -36,6 +36,7 @@ class RootFlags:
     json_output: bool = False
     dry_run: bool = False
     idempotency_key: str | None = None
+    dev: bool = False
 
 
 def _default_idempotency_key() -> str:
@@ -74,7 +75,7 @@ def cli_state(ctx: typer.Context, json_output: bool = False, dry_run: bool = Fal
     return CliState(
         json_output=json_output or root.json_output,
         dry_run=dry_run or root.dry_run,
-        config=load_config(),
+        config=load_config(dev=root.dev),
         **extra,
     )
 
@@ -86,11 +87,7 @@ def report_dry_run(
     body: Mapping[str, Any],
     unresolved_streak: str | None = None,
 ) -> None:
-    """Print the request a write command would send, without contacting the API.
-
-    Names stay unresolved because resolving one needs a request, and --dry-run
-    promises none.
-    """
+    """Print a write preview without sending it; callers may resolve names via GET."""
     if state.json_output:
         request = {"method": "POST", "url": state.url_for(path), "body": dict(body)}
         emit_json({"dry_run": True, "request": request, "unresolved_streak": unresolved_streak})

{quaestor_cli-0.3.0 → quaestor_cli-0.4.0}/tests/test_cli_auth.py

@@ -10,7 +10,7 @@ import pytest
 import respx
 from typer.testing import CliRunner
 
-from conftest import FAKE_KEY
+from conftest import BASE_URL, FAKE_KEY
 from factories import (
     API_KEY_ID,
     AUTH_USER_ID,
@@ -18,7 +18,7 @@ from factories import (
     streak_payload,
     whoami_payload,
 )
-from quaestor_cli.config import credentials_path
+from quaestor_cli.config import DEFAULT_BASE_URL, LOCAL_BASE_URL, credentials_path, load_config
 from quaestor_cli.main import app
 
 STORED_KEY = "qst_live_fedcba9876543210_stored-secret"
@@ -44,6 +44,76 @@ def test_login_without_input_exits_one(runner: CliRunner) -> None:
     assert "No API key on stdin" in result.stderr
 
 
+def test_login_preserves_stored_server_when_replacing_key(
+    runner: CliRunner, api_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Logging in again keeps the server that subsequent commands use."""
+    path = credentials_path()
+    path.parent.mkdir(parents=True)
+    path.write_text(json.dumps({"api_key": FAKE_KEY, "base_url": BASE_URL}))
+    monkeypatch.delenv("QUAESTOR_URL")
+    monkeypatch.delenv("QUAESTOR_API_KEY")
+    api_mock.get("/auth/whoami").mock(return_value=httpx.Response(200, json=whoami_payload()))
+
+    login = runner.invoke(app, ["auth", "login"], input=f"{STORED_KEY}\n")
+
+    assert login.exit_code == 0, login.output
+    assert json.loads(path.read_text()) == {"api_key": STORED_KEY, "base_url": BASE_URL}
+    assert stat.S_IMODE(path.stat().st_mode) == 0o600
+    whoami = runner.invoke(app, ["auth", "whoami", "--json"])
+    assert whoami.exit_code == 0, whoami.output
+    assert json.loads(whoami.stdout)["base_url"] == BASE_URL
+    assert api_mock.calls.last.request.headers["authorization"] == f"Bearer {STORED_KEY}"
+
+
+def test_login_uses_hosted_api_without_url_configuration(
+    runner: CliRunner, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """Fresh setup reaches production after storing only the API key."""
+    monkeypatch.delenv("QUAESTOR_URL")
+    monkeypatch.delenv("QUAESTOR_API_KEY")
+    assert DEFAULT_BASE_URL.startswith("https://")
+    assert DEFAULT_BASE_URL != LOCAL_BASE_URL
+
+    login = runner.invoke(app, ["auth", "login"], input=f"{STORED_KEY}\n")
+
+    assert login.exit_code == 0, login.output
+    with respx.mock(base_url=f"{DEFAULT_BASE_URL}/api/v1") as mock:
+        whoami = mock.get("/auth/whoami").mock(return_value=httpx.Response(200, json=whoami_payload()))
+        result = runner.invoke(app, ["auth", "whoami", "--json"])
+
+    assert result.exit_code == 0, result.output
+    assert json.loads(result.stdout)["base_url"] == DEFAULT_BASE_URL
+    assert whoami.calls.last.request.headers["authorization"] == f"Bearer {STORED_KEY}"
+
+
+def test_dev_flag_overrides_other_servers_without_changing_the_store(
+    runner: CliRunner,
+) -> None:
+    """Local testing is explicit and does not change the server for later commands."""
+    path = credentials_path()
+    path.parent.mkdir(parents=True)
+    contents = {"api_key": STORED_KEY, "base_url": "https://staging.example"}
+    path.write_text(json.dumps(contents))
+
+    with respx.mock(base_url=f"{LOCAL_BASE_URL}/api/v1") as mock:
+        mock.get("/auth/whoami").mock(return_value=httpx.Response(200, json=whoami_payload()))
+        result = runner.invoke(app, ["--dev", "auth", "whoami", "--json"])
+
+    assert result.exit_code == 0, result.output
+    assert json.loads(result.stdout)["base_url"] == LOCAL_BASE_URL
+    assert json.loads(path.read_text()) == contents
+    assert load_config().base_url == BASE_URL
+
+
+def test_dev_flag_is_not_shown_in_normal_help(runner: CliRunner) -> None:
+    """Development configuration stays out of the normal setup path."""
+    result = runner.invoke(app, ["--help"], color=False)
+
+    assert result.exit_code == 0, result.output
+    assert "--dev" not in result.stdout
+
+
 def test_stored_key_is_used_when_environment_is_empty(
     runner: CliRunner, api_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
 ) -> None:

{quaestor_cli-0.3.0 → quaestor_cli-0.4.0}/tests/test_cli_log.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 
 import httpx
+import pytest
 import respx
 from typer.testing import CliRunner
 
@@ -102,14 +103,15 @@ def test_log_resolves_a_prefix_to_one_streak(runner: CliRunner, api_mock: respx.
     assert json.loads(events.calls.last.request.content)["streak_id"] == COUNT_STREAK_ID
 
 
+@pytest.mark.parametrize("dry_run_args", [[], ["--dry-run"]], ids=["write", "dry-run"])
 def test_log_unknown_streak_exits_three_and_lists_names(
-    runner: CliRunner, api_mock: respx.MockRouter
+    runner: CliRunner, api_mock: respx.MockRouter, dry_run_args: list[str]
 ) -> None:
     """User names a streak that does not exist and gets the real names back."""
     _mock_streaks(api_mock, streak_payload("Reading"))
     events = api_mock.post("/events").mock(return_value=httpx.Response(201, json=count_event_payload()))
 
-    result = runner.invoke(app, ["log", "meditate", "5"])
+    result = runner.invoke(app, ["log", "meditate", "5", *dry_run_args])
 
     assert result.exit_code == 3
     assert "No streak matches 'meditate'" in result.stderr
@@ -117,14 +119,17 @@ def test_log_unknown_streak_exits_three_and_lists_names(
     assert not events.called
 
 
-def test_log_ambiguous_streak_writes_nothing(runner: CliRunner, api_mock: respx.MockRouter) -> None:
+@pytest.mark.parametrize("dry_run_args", [[], ["--dry-run"]], ids=["write", "dry-run"])
+def test_log_ambiguous_streak_writes_nothing(
+    runner: CliRunner, api_mock: respx.MockRouter, dry_run_args: list[str]
+) -> None:
     """User types an ambiguous name; the CLI lists candidates and posts nothing."""
     _mock_streaks(
         api_mock, streak_payload("Reading", streak_id="a"), streak_payload("Running", streak_id="b")
     )
     events = api_mock.post("/events").mock(return_value=httpx.Response(201, json=count_event_payload()))
 
-    result = runner.invoke(app, ["log", "r", "5"])
+    result = runner.invoke(app, ["log", "r", "5", *dry_run_args])
 
     assert result.exit_code == 3
     assert "ambiguous" in result.stderr
@@ -142,16 +147,56 @@ def test_log_duplicate_request_reports_already_logged(runner: CliRunner, api_moc
     assert "Already logged" in result.stdout
 
 
-def test_log_dry_run_sends_no_request(runner: CliRunner, api_mock: respx.MockRouter) -> None:
-    """User previews a log entry; nothing is sent and nothing is written."""
-    _mock_streaks(api_mock, streak_payload("Reading"))
-    api_mock.post("/events").mock(return_value=httpx.Response(201, json=count_event_payload()))
+def test_log_dry_run_resolves_streak_but_writes_nothing(
+    runner: CliRunner, api_mock: respx.MockRouter
+) -> None:
+    """User previews a resolved log entry; only the streak lookup is sent."""
+    streaks = _mock_streaks(api_mock, streak_payload("Reading"))
+    events = api_mock.post("/events").mock(return_value=httpx.Response(201, json=count_event_payload()))
 
     result = runner.invoke(app, ["log", "Reading", "5", "--dry-run"])
 
     assert result.exit_code == 0, result.output
-    assert not api_mock.calls
+    assert streaks.called
+    assert all(call.request.method == "GET" for call in api_mock.calls)
+    assert not events.called
     assert "DRY RUN" in result.stdout
+    assert COUNT_STREAK_ID in result.stdout
+
+
+def test_log_time_dry_run_json_has_resolved_body(runner: CliRunner, api_mock: respx.MockRouter) -> None:
+    """A valid TIME preview includes the resolved ID and exact window without writing."""
+    _mock_streaks(api_mock, time_streak_payload("Leetcode 🧑‍💻"))
+    events = api_mock.post("/events").mock(return_value=httpx.Response(201, json=time_event_payload()))
+
+    result = runner.invoke(
+        app,
+        [
+            "--json",
+            "--dry-run",
+            "log",
+            "Leetcode",
+            "--from",
+            "09:00",
+            "--to",
+            "09:45",
+            "--date",
+            "2026-09-20",
+        ],
+    )
+
+    assert result.exit_code == 0, result.output
+    payload = json.loads(result.stdout)
+    assert payload["dry_run"] is True
+    assert payload["unresolved_streak"] is None
+    request = payload["request"]
+    assert request["method"] == "POST"
+    assert request["body"]["streak_id"] == TIME_STREAK_ID
+    assert request["body"]["type"] == "time"
+    assert request["body"]["started_at_local"] == "2026-09-20T09:00:00"
+    assert request["body"]["ended_at_local"] == "2026-09-20T09:45:00"
+    assert all(call.request.method == "GET" for call in api_mock.calls)
+    assert not events.called
 
 
 def test_log_json_output_is_parseable(runner: CliRunner, api_mock: respx.MockRouter) -> None:
@@ -199,24 +244,54 @@ def test_log_count_value_on_time_streak_is_refused(runner: CliRunner, api_mock:
     assert not events.called
 
 
-def test_log_minutes_on_count_streak_is_refused(runner: CliRunner, api_mock: respx.MockRouter) -> None:
+@pytest.mark.parametrize("global_flag", [True, False], ids=["global", "local"])
+@pytest.mark.parametrize("json_output", [False, True], ids=["text", "json"])
+def test_log_dry_run_count_value_on_time_streak_is_refused(
+    runner: CliRunner, api_mock: respx.MockRouter, global_flag: bool, json_output: bool
+) -> None:
+    """A dry run rejects a count on a resolved TIME streak without posting an event."""
+    _mock_streaks(api_mock, time_streak_payload("Leetcode 🧑‍💻"))
+    events = api_mock.post("/events").mock(return_value=httpx.Response(201, json=time_event_payload()))
+
+    args = ["--dry-run", "log", "Leetcode", "1"] if global_flag else ["log", "Leetcode", "1", "--dry-run"]
+    if json_output:
+        args.insert(0, "--json")
+    result = runner.invoke(app, args)
+
+    assert result.exit_code == 1, result.output
+    assert "TIME streak" in result.stderr
+    assert not events.called
+    assert all(call.request.method == "GET" for call in api_mock.calls)
+    if json_output:
+        assert json.loads(result.stdout)["error"]["exit_code"] == 1
+    else:
+        assert result.stdout == ""
+
+
+@pytest.mark.parametrize("dry_run_args", [[], ["--dry-run"]], ids=["write", "dry-run"])
+def test_log_minutes_on_count_streak_is_refused(
+    runner: CliRunner, api_mock: respx.MockRouter, dry_run_args: list[str]
+) -> None:
     """User passes --minutes to a COUNT streak and is redirected to a plain value."""
     _mock_streaks(api_mock, streak_payload("Reading"))
     events = api_mock.post("/events").mock(return_value=httpx.Response(201, json=count_event_payload()))
 
-    result = runner.invoke(app, ["log", "Reading", "--minutes", "45"])
+    result = runner.invoke(app, ["log", "Reading", "--minutes", "45", *dry_run_args])
 
     assert result.exit_code == 1
     assert "COUNT streak" in result.stderr
     assert not events.called
 
 
-def test_log_wrong_unit_is_refused(runner: CliRunner, api_mock: respx.MockRouter) -> None:
+@pytest.mark.parametrize("dry_run_args", [[], ["--dry-run"]], ids=["write", "dry-run"])
+def test_log_wrong_unit_is_refused(
+    runner: CliRunner, api_mock: respx.MockRouter, dry_run_args: list[str]
+) -> None:
     """User asserts the wrong unit; the CLI refuses rather than logging the number blind."""
     _mock_streaks(api_mock, streak_payload("Reading"))
     events = api_mock.post("/events").mock(return_value=httpx.Response(201, json=count_event_payload()))
 
-    result = runner.invoke(app, ["log", "Reading", "5", "--unit", "minutes"])
+    result = runner.invoke(app, ["log", "Reading", "5", "--unit", "minutes", *dry_run_args])
 
     assert result.exit_code == 1
     assert "measured in pages" in result.stderr

quaestor_cli-0.4.0/tests/test_cli_quest_links.py

@@ -0,0 +1,119 @@
+"""Quest-to-quest links and mentions: `qst quest link-quest / unlink-quest / mention / show`."""
+
+from __future__ import annotations
+
+import json
+from typing import Any
+
+import httpx
+import pytest
+import respx
+from typer.testing import CliRunner
+
+from factories import PARENT_QUEST_ID, QUEST_ID, quest_payload
+from quaestor_cli.main import app
+
+APP = "https://quaestor.app"
+
+
+def _quest(title: str, quest_id: str, linked: list[str] | None = None, **kw: Any) -> dict[str, Any]:
+    return {**quest_payload(title, quest_id=quest_id, **kw), "linked_quest_ids": linked or []}
+
+
+def _resolves(api_mock: respx.MockRouter, *quests: dict[str, Any]) -> None:
+    for q in quests:
+        route = api_mock.get("/quests/resolve", params={"ref": q["title"]})
+        route.mock(return_value=httpx.Response(200, json=q))
+
+
+def test_link_quest_links_both_by_name(runner: CliRunner, api_mock: respx.MockRouter) -> None:
+    """Agent links Website to Launch by name; one PUT to the links endpoint, confirmed with both paths."""
+    _resolves(api_mock, _quest("Website", QUEST_ID), _quest("Launch", PARENT_QUEST_ID))
+    route = api_mock.put(f"/quests/{QUEST_ID}/links/{PARENT_QUEST_ID}").mock(
+        return_value=httpx.Response(200, json=_quest("Website", QUEST_ID, [PARENT_QUEST_ID]))
+    )
+    result = runner.invoke(app, ["quest", "link-quest", "Website", "Launch"])
+    assert result.exit_code == 0, result.output
+    assert route.called and "Linked Website to Launch." in result.stdout
+
+
+def test_link_quest_already_linked_sends_nothing(runner: CliRunner, api_mock: respx.MockRouter) -> None:
+    """Agent repeats a link that exists; nothing is sent and the JSON says nothing changed."""
+    _resolves(api_mock, _quest("Website", QUEST_ID, [PARENT_QUEST_ID]), _quest("Launch", PARENT_QUEST_ID))
+    route = api_mock.put(f"/quests/{QUEST_ID}/links/{PARENT_QUEST_ID}")
+    result = runner.invoke(app, ["quest", "link-quest", "Website", "Launch", "--json"])
+    assert result.exit_code == 0, result.output
+    assert not route.called
+    assert json.loads(result.stdout) == {"changed": False, "quest": "Website", "linked_quest": "Launch"}
+
+
+def test_link_quest_to_itself_is_a_usage_error(runner: CliRunner, api_mock: respx.MockRouter) -> None:
+    """Agent tries to link a quest to itself; refused before anything is sent."""
+    _resolves(api_mock, _quest("Website", QUEST_ID))
+    result = runner.invoke(app, ["quest", "link-quest", "Website", "Website"])
+    assert result.exit_code == 1 and "can't be linked to itself" in result.output
+
+
+def test_unlink_quest_deletes_the_link(runner: CliRunner, api_mock: respx.MockRouter) -> None:
+    """Agent unlinks two linked quests; one DELETE, and --dry-run would have sent nothing."""
+    _resolves(api_mock, _quest("Website", QUEST_ID, [PARENT_QUEST_ID]), _quest("Launch", PARENT_QUEST_ID))
+    route = api_mock.delete(f"/quests/{QUEST_ID}/links/{PARENT_QUEST_ID}").mock(
+        return_value=httpx.Response(200, json=_quest("Website", QUEST_ID))
+    )
+    dry = runner.invoke(app, ["quest", "unlink-quest", "Website", "Launch", "--dry-run"])
+    assert dry.exit_code == 0, dry.output
+    assert route.call_count == 0
+    result = runner.invoke(app, ["quest", "unlink-quest", "Website", "Launch"])
+    assert result.exit_code == 0, result.output
+    assert route.called and "Unlinked Website from Launch." in result.stdout
+
+
+def test_mention_prints_markdown_link_for_a_chip(runner: CliRunner, api_mock: respx.MockRouter) -> None:
+    """Agent asks for a mention of a quest with brackets in its title; it gets an escaped Markdown link."""
+    _resolves(api_mock, _quest("Fix [urgent] bug", QUEST_ID, path=["Launch"]))
+    result = runner.invoke(app, ["quest", "mention", "Fix [urgent] bug"])
+    assert result.exit_code == 0, result.output
+    assert result.stdout.strip() == f"[Fix \\[urgent\\] bug]({APP}/home?tab=quests&quest={QUEST_ID})"
+
+    as_json = json.loads(runner.invoke(app, ["quest", "mention", "Fix [urgent] bug", "--json"]).stdout)
+    assert as_json["url"] == f"{APP}/home?tab=quests&quest={QUEST_ID}"
+    assert as_json["quest"] == "Launch › Fix [urgent] bug"
+
+
+def test_mention_uses_the_configured_app_url(
+    runner: CliRunner, api_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A self-hosted app sets QUAESTOR_APP_URL; mentions point there."""
+    monkeypatch.setenv("QUAESTOR_APP_URL", "https://quests.example.org/")
+    _resolves(api_mock, _quest("Website", QUEST_ID))
+    result = runner.invoke(app, ["quest", "mention", "Website"])
+    assert f"(https://quests.example.org/home?tab=quests&quest={QUEST_ID})" in result.stdout
+
+
+def test_show_lists_linked_quests_and_the_quest_link(runner: CliRunner, api_mock: respx.MockRouter) -> None:
+    """User shows a quest; linked quests appear by full path, plus the quest's own link (also in --json)."""
+    _resolves(api_mock, _quest("Website", QUEST_ID, [PARENT_QUEST_ID]))
+    detail = {
+        **_quest("Website", QUEST_ID, [PARENT_QUEST_ID]),
+        "description": "",
+        "diary": [],
+        "linked_quests": [
+            {
+                "id": PARENT_QUEST_ID,
+                "title": "Schema",
+                "emoji": None,
+                "status": "todo",
+                "path": ["Launch", "Backend"],
+            }
+        ],
+    }
+    api_mock.get(f"/quests/{QUEST_ID}").mock(return_value=httpx.Response(200, json=detail))
+
+    result = runner.invoke(app, ["quest", "show", "Website"])
+    assert result.exit_code == 0, result.output
+    assert "linked:     Launch › Backend › Schema" in result.stdout
+    assert f"link:       {APP}/home?tab=quests&quest={QUEST_ID}" in result.stdout
+
+    as_json = json.loads(runner.invoke(app, ["quest", "show", "Website", "--json"]).stdout)
+    assert as_json["url"] == f"{APP}/home?tab=quests&quest={QUEST_ID}"
+    assert as_json["linked_quests"][0]["path"] == ["Launch", "Backend"]

{quaestor_cli-0.3.0 → quaestor_cli-0.4.0}/tests/test_cli_timer_review_doctor.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 import json
 
 import httpx
+import pytest
 import respx
 from typer.testing import CliRunner
 
@@ -277,9 +278,76 @@ def test_doctor_reports_unreachable_backend(runner: CliRunner, api_mock: respx.M
 
     assert result.exit_code == 4
     assert "reachable:     no" in result.stdout
+    assert "authenticated: unknown (host unreachable)" in result.stdout
+    assert "scopes:        unknown (host unreachable)" in result.stdout
+    assert "credential was rejected" not in result.stdout
     assert "Cannot reach" in result.stderr
 
 
+def test_doctor_reports_unknown_authentication_in_json_when_unreachable(
+    runner: CliRunner, api_mock: respx.MockRouter
+) -> None:
+    """An unreachable host cannot establish whether the credential works."""
+    api_mock.get("/healthz").mock(side_effect=httpx.ConnectError("connection refused"))
+
+    result = runner.invoke(app, ["doctor", "--json"])
+
+    assert result.exit_code == 4, result.output
+    diagnosis = json.loads(result.stdout)
+    assert diagnosis["reachable"] is False
+    assert diagnosis["authenticated"] is None
+    assert diagnosis["scopes"] is None
+    assert len(api_mock.calls) == 1
+
+
+@pytest.mark.parametrize("response", ["connection", "server"])
+def test_doctor_reports_unknown_when_authentication_check_fails(
+    runner: CliRunner, api_mock: respx.MockRouter, response: str
+) -> None:
+    """A working health check does not turn a failed identity lookup into rejection."""
+    api_mock.get("/healthz").mock(return_value=httpx.Response(200, json={"ok": True}))
+    identity = api_mock.get("/auth/whoami")
+    if response == "connection":
+        identity.mock(side_effect=httpx.ConnectError("connection refused"))
+    else:
+        identity.mock(return_value=httpx.Response(503, json={"detail": "Unavailable"}))
+
+    result = runner.invoke(app, ["doctor"])
+
+    assert result.exit_code == 4, result.output
+    assert "reachable:     yes" in result.stdout
+    assert "authenticated: unknown (authentication check failed)" in result.stdout
+    assert "credential was rejected" not in result.stdout
+
+
+def test_doctor_reports_reachable_but_unhealthy_server(runner: CliRunner, api_mock: respx.MockRouter) -> None:
+    """A server that answers with 503 is reachable, but cannot verify the key."""
+    api_mock.get("/healthz").mock(return_value=httpx.Response(503, json={"detail": "Unavailable"}))
+
+    result = runner.invoke(app, ["doctor", "--json"])
+
+    assert result.exit_code == 4, result.output
+    diagnosis = json.loads(result.stdout)
+    assert diagnosis["reachable"] is True
+    assert diagnosis["authenticated"] is None
+    assert diagnosis["detail"] == "Unavailable"
+    assert len(api_mock.calls) == 1
+
+
+def test_doctor_does_not_claim_rejection_when_no_key_is_configured(
+    runner: CliRunner, api_mock: respx.MockRouter, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """A missing credential has never been presented for authentication."""
+    monkeypatch.delenv("QUAESTOR_API_KEY")
+    api_mock.get("/healthz").mock(return_value=httpx.Response(200, json={"ok": True}))
+
+    result = runner.invoke(app, ["doctor"])
+
+    assert result.exit_code == 2, result.output
+    assert "scopes:        unknown (no API key)" in result.stdout
+    assert "credential was rejected" not in result.stdout
+
+
 def test_doctor_reports_bad_credential(runner: CliRunner, api_mock: respx.MockRouter) -> None:
     """Backend is up but the key is rejected; doctor exits with the auth code."""
     api_mock.get("/healthz").mock(return_value=httpx.Response(200, json={"ok": True}))

{quaestor_cli-0.3.0 → quaestor_cli-0.4.0}/uv.lock

@@ -416,7 +416,7 @@ wheels = [
 
 [[package]]
 name = "quaestor-cli"
-version = "0.3.0"
+version = "0.4.0"
 source = { editable = "." }
 dependencies = [
     { name = "httpx" },