taskops-cli 0.2.0__py3-none-any.whl

taskops/storage/store.py

@@ -0,0 +1,120 @@
+"""The database: one SQLite file per repository, and the ONLY package with SQL.
+
+`tests/architecture` enforces that. A query written anywhere else is a second place
+that knows the column order, and it is always the one nobody updates when the
+schema moves.
+
+`Store` owns the connection and the schema; each table is its own object
+(`store.tasks`, `store.leases`, …). Flat methods would make this file know every
+table; this way it knows only the connection.
+"""
+
+from __future__ import annotations
+
+import sqlite3
+from functools import cached_property
+from pathlib import Path
+from types import TracebackType
+
+from . import schema
+from ._delivered import DeliveredTable
+from ._deps import DepTable
+from ._events import EventTable
+from ._leases import LeaseTable
+from ._tasks import TaskTable
+from .locate import DB_FILE
+
+__all__ = ["Store", "BUSY_TIMEOUT"]
+
+BUSY_TIMEOUT = 15.0
+"""Seconds a connection waits for a write lock before giving up.
+
+Under WAL a reader never waits, so this bounds writer-versus-writer only. Fifteen
+is generous against the writes taskops actually makes — a claim and an append, both
+sub-millisecond — and it is deliberately SHORTER than a lease TTL: an agent that
+cannot get the lock inside fifteen seconds should be told, not left hanging past
+the point where its own claim expires underneath it.
+"""
+
+
+class Store:
+    def __init__(self, root: Path, *, check_same_thread: bool = True) -> None:
+        # check_same_thread=False lets the studio read from its request threads;
+        # that server serialises its own writes, so it stays safe.
+        self.root = Path(root)
+        db_path = self.root / DB_FILE
+        db_path.parent.mkdir(parents=True, exist_ok=True)
+        self.db = sqlite3.connect(db_path, check_same_thread=check_same_thread,
+                                  timeout=BUSY_TIMEOUT,
+                                  isolation_level="DEFERRED")
+        self.db.row_factory = sqlite3.Row
+        schema.apply(self.db)
+
+    # ---- tables (cached: one object per store, built on first touch)
+
+    @cached_property
+    def tasks(self) -> TaskTable:
+        return TaskTable(self.db)
+
+    @cached_property
+    def deps(self) -> DepTable:
+        """The DAG. Queried from both ends; see `_deps` for the direction."""
+        return DepTable(self.db)
+
+    @cached_property
+    def leases(self) -> LeaseTable:
+        """Claims with a deadline — the concurrency story. Writes go under
+        `claiming()`, never bare, or the expiry sweep can interleave."""
+        return LeaseTable(self.db)
+
+    @cached_property
+    def events(self) -> EventTable:
+        return EventTable(self.db)
+
+    @cached_property
+    def delivered(self) -> DeliveredTable:
+        return DeliveredTable(self.db)
+
+    # ---- lifecycle
+
+    def claiming(self) -> None:
+        """Take the write lock NOW, before this call reads or writes anything.
+
+        A claim is sweep-then-decide-then-insert, and under a DEFERRED transaction the lock
+        is only taken at the insert — so two agents can both read the same dead lease as
+        sweepable and both then try to claim. BEGIN IMMEDIATE closes that window.
+
+        MUST be the first statement of the call. sqlite3 opens a transaction implicitly on
+        the first write, and `BEGIN IMMEDIATE` inside one raises "cannot start a transaction
+        within a transaction" — which is exactly how this was found, by an end-to-end test
+        where a heartbeat wrote first. Tolerating that case with `if not in_transaction`
+        would have been worse: the lock would silently not be taken, and the race this
+        exists to prevent would be back with nothing to show for it.
+        """
+        self.db.execute("BEGIN IMMEDIATE")
+
+    def commit(self) -> None:
+        self.db.commit()
+
+    def close(self) -> None:
+        self.db.close()
+
+    def __enter__(self) -> "Store":
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> None:
+        """Clean exit commits; a raised exception rolls back. Always closes.
+
+        sqlite3 opens a transaction on the first write and `close()` does NOT
+        commit it, so a block that only closed would discard everything it wrote —
+        a claim that reported success and left no lease.
+        """
+        try:
+            self.db.rollback() if exc_type else self.db.commit()
+        finally:
+            self.close()

taskops/storage/sync.py

@@ -0,0 +1,139 @@
+"""The committed log ↔ the local cache. Multi-developer sync with no server.
+
+`.taskops/events.jsonl` is append-only text, one event per line, and it is
+COMMITTED. That is the whole mechanism: two developers' agents converge by `git
+pull`, because appending to different ends of a file is the one edit git merges
+without help, and content-hash ids make importing the same event twice a no-op.
+
+What this module deliberately does NOT do is decide what an event MEANS. It moves bytes; turning
+events into tasks and dependencies is `engine.replay`, which is also where the one genuine conflict
+— two machines changing a task's status — is settled by timestamp.
+
+There are no conflicts in the LOG to resolve: events are facts about the past, so the union of two
+logs is the correct log.
+
+`activity` never leaves the machine (`LOCAL_ONLY_KINDS`): it is a per-tool-call
+heartbeat, and replicating it would add thousands of lines a day to a file whose
+whole value is that a human can read its diff.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Iterator, cast
+
+from .._types import LOCAL_ONLY_KINDS
+from ..contracts import Event
+from ._rows import as_dict
+from .locate import LOG_FILE
+from .store import Store
+
+__all__ = ["export_events", "import_events", "all_events", "read_log", "event_from"]
+
+
+def export_events(store: Store, *, limit: int = 1000) -> int:
+    """Append this machine's new events to the log. Returns how many were written.
+
+    The file is opened per call and closed immediately: a long-lived handle would
+    keep a deleted inode alive after a `git checkout` swapped the file, and every
+    write after that would go somewhere nobody can read.
+    """
+    fresh = store.events.unexported(limit=limit)
+    shared = [e for e in fresh if e["kind"] not in LOCAL_ONLY_KINDS]
+    if shared:
+        _append(store.root / LOG_FILE, shared)
+    if fresh:
+        # Local-only kinds are marked too, or every export re-scans every activity
+        # event this machine has ever written.
+        store.events.mark_exported([e["id"] for e in fresh])
+    return len(shared)
+
+
+def _append(path: Path, events: list[Event]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as handle:
+        for event in events:
+            handle.write(json.dumps(event, sort_keys=True,
+                                    separators=(",", ":")) + "\n")
+
+
+def import_events(store: Store) -> list[Event]:
+    """Load the log into the cache. Returns the events that were NEW here.
+
+    The events themselves and not a count, because the caller has to do something with them:
+    materialising tasks from them is `engine.replay`'s job, and it must see exactly the new ones.
+    Returning a number was the earlier signature, and it is how the board stayed empty after a
+    teammate's `git pull` — the events arrived and nothing turned them into tasks.
+
+    Reads the whole file every time. At tens of thousands of events that is a few milliseconds, and
+    the alternative — a byte offset into a file `git pull` rewrites from the middle — is a cursor
+    that silently skips a merge.
+    """
+    fresh: list[Event] = []
+    for event in read_log(store.root):
+        if store.events.append(event, exported=True):
+            fresh.append(event)
+    return fresh
+
+
+def read_log(root: Path) -> Iterator[Event]:
+    """Every well-formed event in the log, in file order.
+
+    A malformed line is SKIPPED, not fatal: this file is merged by git and written
+    by however many taskops versions a team runs, and one bad line must not make
+    the project unreadable. Nothing is lost silently — the line is still in git.
+    """
+    path = root / LOG_FILE
+    if not path.is_file():
+        return
+    with path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            event = _parse(line)
+            if event is not None:
+                yield event
+
+
+def _parse(line: str) -> Event | None:
+    """One log line -> an Event, or None."""
+    raw = line.strip()
+    if not raw:
+        return None
+    try:
+        parsed: Any = json.loads(raw)
+    except json.JSONDecodeError:
+        return None
+    return event_from(parsed)
+
+
+def event_from(parsed: Any) -> Event | None:
+    """One decoded JSON value -> an Event, or None when it cannot be one.
+
+    Every field is coerced rather than trusted. The producer is another machine's
+    taskops, possibly a newer one, and `json.loads` returns Any — so without this
+    an unexpected type would flow into the database and fail later at a render.
+
+    Split from `_parse` because the committed log is no longer the only way a foreign
+    event arrives: `POST /api/sync` receives them already decoded. Two coercions in two
+    modules is how the two paths would start disagreeing about what a valid event IS —
+    and since the id is the content, disagreeing means forking history.
+    """
+    if not isinstance(parsed, dict):
+        return None
+    fields = cast("dict[str, Any]", parsed)
+    if not fields.get("id") or not fields.get("kind"):
+        return None
+    return Event(id=str(fields["id"]), task=str(fields.get("task", "")),
+                 actor=str(fields.get("actor", "")), kind=fields["kind"],
+                 body=as_dict(json.dumps(fields.get("body", {}))),
+                 ts=float(fields.get("ts", 0.0)))
+
+
+def all_events(root: Path) -> list[Event]:
+    """The whole log, for a caller that has to re-apply state rather than fill gaps.
+
+    Separate from `import_events` because they answer different questions: that one says "what is
+    new here", this one says "what does the log say" — and a cache being rebuilt from a deleted
+    database needs the second, since by then nothing is new.
+    """
+    return list(read_log(root))

taskops/transports/__init__.py

@@ -0,0 +1,6 @@
+"""Layer 6 — the surfaces. Thin by construction: CLI, MCP and HTTP all call the same
+use cases, and `tests/architecture` forbids any of them from importing storage or engine
+directly. That rule is what stops a fourth place where a decision lives.
+"""
+
+from __future__ import annotations

taskops/transports/cli/commands/__init__.py

@@ -0,0 +1,3 @@
+"""The CLI commands. One module per verb, each registering its own flags."""
+
+from __future__ import annotations

taskops/transports/cli/commands/_digest.py

@@ -0,0 +1,64 @@
+"""`report … --digest` in a terminal: the narration as it is being written.
+
+Its own module because it is the only command that takes MINUTES, and the only one that writes
+to stdout before it returns. Everything else here renders a finished answer and hands back a
+string for `main` to print.
+
+The user's report was "esto nunca terminó": `report all --digest` on a real project narrates a
+whole-project dossier in several passes, and with the output captured the terminal showed
+nothing at all for a quarter of an hour. Nothing was broken — nothing was VISIBLE. So this
+prints a header before the first pass, names each pass as it starts, and renders the prose live.
+
+The FILE is untouched by any of it: `digest` writes the joined text, and no escape sequence ever
+reaches disk.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import IO
+
+from ...._clock import now
+from ....render import Ink
+from ....usecases import Selector, digest
+
+__all__ = ["stream_digest"]
+
+
+def stream_digest(where: Path, sel: Selector, *, kind: str, model: str = "",
+                  force: bool = False, out: IO[str] | None = None) -> str:
+    """Narrate the window, showing it happen. Returns the line `main` prints at the end."""
+    to = out or sys.stdout
+    ink = Ink(colour=_colour(to))
+    started = now()
+
+    def show(text: str) -> None:
+        for line in ink.feed(text):
+            print(line, file=to)
+        to.flush()
+
+    def announce(n: int, total: int) -> None:
+        for line in ink.flush():
+            print(line, file=to)
+        print(f"\n▸ narrating {n}/{total} …" if total > 1 else "", file=to)
+        to.flush()
+
+    print(f"▸ reading the {kind} dossier of {where} — this calls Claude and takes minutes",
+          file=to)
+    to.flush()
+    path = digest(where, sel, model=model, force=force, on_pass=announce, on_text=show)
+    for line in ink.flush():
+        print(line, file=to)
+    return f"\nnarrated {path} in {now() - started:.0f}s"
+
+
+def _colour(to: IO[str]) -> bool:
+    """Whether to style at all — decided HERE and not in the renderer, which is pure.
+
+    A pipe, a file and a CI log get the markdown verbatim, which is byte for byte what this
+    command emitted before it streamed. `NO_COLOR` is honoured because a person who set it
+    means every tool, not the ones that remembered.
+    """
+    return bool(getattr(to, "isatty", bool)()) and not os.environ.get("NO_COLOR")

taskops/transports/cli/commands/_serve_init.py

@@ -0,0 +1,65 @@
+"""Creating one project on a server, and minting the secret that is its only door.
+
+Split from `serve` because the two halves have nothing in common but a name: that one opens a
+socket, this one writes two things to disk and prints a URL. Keeping them apart is also what
+keeps the token handling in a file small enough to read in one sitting — which is the correct
+size for the only code in taskops that mints a credential.
+
+The model is the one that has already been proven in `bgist`: the token is minted BY THE BOX,
+lands in a `0600` file, is printed exactly once, and never touches git or a log. Nothing here
+can recover it — a lost token is re-minted, not looked up — because a tool that can print a
+secret twice is a tool whose transcript is a secret.
+"""
+
+from __future__ import annotations
+
+import secrets
+from pathlib import Path
+
+from ...._errors import TaskopsError
+from ....transports.http.projects import NAME, TOKEN_FILE
+from ....usecases import init as setup
+
+__all__ = ["create"]
+
+TOKEN_BYTES = 16
+"""128 bits from `secrets`, hex-encoded. Long enough that the 404 on a wrong name is the only
+enumeration surface, and short enough to paste."""
+
+
+def create(root: Path, project: str) -> str:
+    """Make `<root>/<project>/`, init a taskops store in it, mint the token. Idempotent
+    EXCEPT for the token, which is minted once and never reprinted."""
+    if not NAME.match(project):
+        raise TaskopsError(f"'{project}' cannot name a project — use [a-z0-9-], "
+                           f"1 to 40 characters, because the name is also a URL segment")
+    home = root / project
+    home.mkdir(parents=True, exist_ok=True)
+    # No git hooks: a server directory is a store of boards, not a working tree, and there is
+    # no repository here whose commits a hook could bind to.
+    setup(home, install_git_hooks=False)
+    token = _mint(home / TOKEN_FILE)
+    return _describe(home, project, token)
+
+
+def _mint(path: Path) -> str:
+    """Write the secret `0600`, or leave an existing one alone and return "".
+
+    `touch(mode=0o600)` BEFORE the write, so the file never exists — not even for the
+    microsecond between create and chmod — with the umask's permissions.
+    """
+    if path.is_file():
+        return ""
+    path.touch(mode=0o600)
+    token = secrets.token_hex(TOKEN_BYTES)
+    path.write_text(token + "\n", encoding="utf-8")
+    return token
+
+
+def _describe(home: Path, project: str, token: str) -> str:
+    if not token:
+        return (f"{project} already exists at {home}\n"
+                f"its token is in {home / TOKEN_FILE} — it is never printed twice")
+    return (f"created {project} at {home}\n"
+            f"token (shown ONCE, kept in {home / TOKEN_FILE}):\n\n    {token}\n\n"
+            f"open the board at  http://<host>/{project}/?token={token}")

taskops/transports/cli/commands/_shared.py

@@ -0,0 +1,50 @@
+"""What every command's parser repeats. One place, so the flags cannot drift.
+
+`--repo` defaults to the cwd because the callers are hooks: git runs them from inside the
+repository, and Claude Code runs them from the project directory, so requiring the path
+would make every hook line longer for no information.
+"""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+__all__ = ["add_target", "add_actor", "add_identity", "repo_of"]
+
+
+def add_target(parser: argparse.ArgumentParser, *, inherit: bool = False) -> None:
+    parser.add_argument("--repo", default=_default(".", inherit),
+                        help="path in the repository (default: the current directory)")
+
+
+def add_actor(parser: argparse.ArgumentParser, *, inherit: bool = False) -> None:
+    parser.add_argument("--actor", default=_default("", inherit),
+                        help="who is calling: agent:<dev>/<name> or dev:<name>")
+
+
+def _default(value: str, inherit: bool) -> object:
+    """`SUPPRESS` when a PARENT parser already carries this flag.
+
+    argparse writes a subparser's defaults into the namespace the parent already filled, so
+    a group whose subcommands re-declare `--repo` would silently reset it: `taskops tasks
+    --repo /x list` would look in the current directory instead. `SUPPRESS` is the only way
+    to say "set nothing when it was not given", which leaves the parent's value standing.
+    """
+    return argparse.SUPPRESS if inherit else value
+
+
+def add_identity(parser: argparse.ArgumentParser) -> None:
+    """`--actor` and `--session`, for the callers that know who they are.
+
+    Both optional: an actor resolves from $TASKOPS_ACTOR or git, and a session id only
+    exists when Claude Code passed one. A hook that has them should say so, because that is
+    what links the work to a transcript on the live board.
+    """
+    parser.add_argument("--actor", default="",
+                        help="who is calling: agent:<dev>/<name> or dev:<name>")
+    parser.add_argument("--session", default="", help="the Claude Code session id")
+
+
+def repo_of(args: argparse.Namespace) -> Path:
+    return Path(str(args.repo))

taskops/transports/cli/commands/_tasks_args.py

@@ -0,0 +1,112 @@
+"""The subcommands of `taskops tasks`: the names, their flags, and which `run` each reaches.
+
+Split from `tasks.py` for the file budget, and the seam is the honest one: that module holds
+the two behaviours this group adds (the compact list, creating one card), this one holds the
+wiring. Most subcommands point straight at a `run` that already exists, which is the whole
+point of the group — `taskops tasks done` and `taskops update --status done` are one code
+path, so they cannot start answering differently.
+
+Every subparser inherits `--repo` and `--actor` rather than owning them, so both orders work:
+`taskops tasks --repo /x list` and `taskops tasks list --repo /x`. See `_shared._default`.
+"""
+
+from __future__ import annotations
+
+import argparse
+from typing import Callable
+
+from . import ask as ask_cmd
+from . import log as log_cmd
+from . import plan as plan_cmd
+from . import update as update_cmd
+from ._shared import add_actor, add_target
+
+__all__ = ["add_subcommands", "add_list_flags"]
+
+Runner = Callable[[argparse.Namespace], str]
+
+
+def add_list_flags(parser: argparse.ArgumentParser) -> None:
+    """What the list shows. On BOTH `taskops tasks` and `taskops tasks list`, because the
+    bare group name IS the list — a flag that worked on only one of the two spellings would
+    be a flag whose absence looks like the feature is missing.
+
+    `--status` takes any string rather than argparse `choices` so the refusal can be the
+    package's own sentence; see `tasks.run_list`.
+    """
+    parser.add_argument("--all", action="store_true",
+                        help="show closed tasks too, after the open ones")
+    parser.add_argument("--status", default=None, metavar="<status>",
+                        help="show only tasks in this status")
+
+
+def add_subcommands(parent: argparse.ArgumentParser, *, listing: Runner,
+                    adding: Runner, editing: Runner) -> None:
+    sub = parent.add_subparsers(dest="subcommand", metavar="<subcommand>")
+    add_list_flags(_flags(sub.add_parser("list", help="one line per open task"), listing))
+
+    _edit_flags(_flags(sub.add_parser("edit", help="rewrite a task's title, spec or priority"),
+                       editing))
+
+    show = _flags(sub.add_parser("show", help="read one task in full"), ask_cmd.run)
+    show.add_argument("what", metavar="task", help="the task id")
+
+    _add_flags(_flags(sub.add_parser("add", help="create one task"), adding))
+
+    from_json = _flags(sub.add_parser("plan", help="create tasks from JSON (a file, or -)"),
+                       plan_cmd.run)
+    from_json.add_argument("source", help="path to a JSON array of tasks, or - for stdin")
+
+    _close(sub, "done", "finish a task", "done")
+    _close(sub, "release", "hand a task back, unfinished", "released")
+
+    entries = _flags(sub.add_parser("log", help="the agent's conversation for a card"),
+                     log_cmd.run)
+    entries.add_argument("task", help="the task id")
+    entries.add_argument("--limit", type=int, default=0,
+                         help="entries to keep, newest last (default 400)")
+
+    found = _flags(sub.add_parser("search", help="search titles and specs"), ask_cmd.run)
+    found.add_argument("what", metavar="text", help="what to look for")
+
+
+def _flags(parser: argparse.ArgumentParser, run: Runner) -> argparse.ArgumentParser:
+    add_target(parser, inherit=True)
+    add_actor(parser, inherit=True)
+    parser.set_defaults(run=run)
+    return parser
+
+
+def _add_flags(parser: argparse.ArgumentParser) -> None:
+    """One card's worth of `plan`'s JSON, as flags. Anything with a graph in it stays JSON —
+    `after` here takes ids only, because an index refers to a batch this command cannot have."""
+    parser.add_argument("title", help="what the task is")
+    parser.add_argument("--spec", default="", help="the brief: what done looks like")
+    parser.add_argument("--after", default="", help="comma-separated ids this waits on")
+    parser.add_argument("--files", default="", help="comma-separated edit surface")
+    parser.add_argument("--priority", type=int, default=None, help="0 urgent … 3 whenever")
+    parser.add_argument("--label", default="", dest="labels", help="comma-separated labels")
+
+
+def _edit_flags(parser: argparse.ArgumentParser) -> None:
+    """The three fields a card can be corrected in. All default to `None` — "not passed" —
+    so that `--spec ""` clears a brief instead of being indistinguishable from not saying it.
+    Requiring at least one is the use case's job, not argparse's: the CLI is one of three
+    surfaces, and a rule only argparse knows is a rule the other two do not have."""
+    parser.add_argument("task", help="the task id")
+    parser.add_argument("--title", default=None, help="what the task is")
+    parser.add_argument("--spec", default=None, help="the brief: what done looks like")
+    parser.add_argument("--priority", type=int, default=None, help="0 urgent … 3 whenever")
+
+
+def _close(sub: "argparse._SubParsersAction[argparse.ArgumentParser]", name: str,
+           help_text: str, status: str) -> None:
+    """`done` and `release` are `update` with the status already chosen — the two transitions
+    a person makes by hand, spelled as the actions they are instead of a flag value to recall.
+    The rest of `update`'s namespace is defaulted here, because its `run` reads the whole of it."""
+    parser = _flags(sub.add_parser(name, help=help_text), update_cmd.run)
+    parser.add_argument("task", help="the task id")
+    parser.add_argument("-m", "--comment", default="", help="what happened, for the thread")
+    parser.add_argument("--no-code", action="store_true", dest="no_code",
+                        help="this task legitimately produces no commit")
+    parser.set_defaults(status=status, mentions="", blocked_on="")

taskops/transports/cli/commands/_window.py

@@ -0,0 +1,45 @@
+"""Which days the caller asked for — argparse's flags turned into ONE `Selector`.
+
+Its own module because the refusals are the interesting part and `report.py` already owns the
+flag table and the three ways of emitting a dossier. Nothing here reads a repository: it maps
+what was typed onto what `usecases` resolves, and says no to combinations that would otherwise
+be settled by the order of a chain of ifs.
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from ...._errors import BadRequest
+from ....usecases import Selector
+
+__all__ = ["selector"]
+
+
+def selector(args: argparse.Namespace) -> Selector:
+    """The window, refusing a MIX of ways of asking for it.
+
+    `report day --last 7d` is somebody who means one of the two and would not notice which
+    one won — so neither does taskops. The flags are named after the kind that owns them, and
+    borrowing another kind's flag is an error rather than a silently ignored preference.
+    """
+    if args.kind != "range" and (args.last or args.from_date or args.to):
+        raise BadRequest(f"--last, --from and --to belong to `report range` — "
+                         f"`report {args.kind}` takes {_instead(str(args.kind))}")
+    if args.kind == "all":
+        return Selector(whole=True)
+    if args.kind != "range":
+        return Selector(date=str(args.date))
+    if not (args.last or args.from_date):
+        raise BadRequest("`report range` needs a window — --last 7d (also 2w, 1m), or "
+                         "--from YYYY-MM-DD [--to YYYY-MM-DD]")
+    if args.last and args.from_date:
+        raise BadRequest("--last and --from are two ways of naming the same start — pick "
+                         "one, or the report covers a window nobody asked for")
+    return Selector(date=str(args.from_date), to=str(args.to), last=str(args.last))
+
+
+def _instead(kind: str) -> str:
+    """What the kind the caller named DOES accept. Naming the alternative is the difference
+    between an error somebody fixes and one they retry with the same flag."""
+    return "no window at all — it covers everything" if kind == "all" else "--date"

taskops/transports/cli/commands/ask.py

@@ -0,0 +1,27 @@
+"""Read one task in full, or search when you have no id.
+
+No parser of its own any more: `taskops ask` was a command for agents, and agents have
+`taskops_ask` over MCP with a better contract. The function stayed exactly where it was,
+because `taskops tasks show` and `taskops tasks search` reach THIS — two implementations of
+"read a task" is how the CLI and the MCP start disagreeing about what a task looks like.
+"""
+
+from __future__ import annotations
+
+import argparse
+
+from ....render import render_search, render_view
+from ....usecases import ask as read
+from ....usecases import search
+from ._shared import repo_of
+
+__all__ = ["run"]
+
+
+def run(args: argparse.Namespace) -> str:
+    """A bare argument, because a human types `taskops ask tk-4f2a` far more often than a
+    query — and an id is recognisable on sight, so guessing which one it is costs nothing."""
+    what = str(args.what)
+    if what.startswith("tk-"):
+        return render_view(read(repo_of(args), what, actor=args.actor))
+    return render_search(search(repo_of(args), what), what)