taskops-cli 0.2.0__py3-none-any.whl

taskops/engine/_stream.py

@@ -0,0 +1,129 @@
+"""One `claude` process, read a delta at a time — and stripped of the developer's world.
+
+Split from `narrate` because two different things live here. `narrate` decides how a dossier is
+cut and stitched; this decides what a single reading COSTS and how soon the caller sees it.
+
+**Why streaming at all.** `subprocess.run(capture_output=True)` returns nothing until the process
+exits, and a whole-project dossier is narrated in several passes of minutes each — so
+`report all --digest` showed an empty terminal for a quarter of an hour and read as a hang. It
+was reported as one. `--output-format stream-json` on its own does NOT fix that: it emits a
+single line carrying the finished text. Partial output needs `--include-partial-messages`, which
+in turn requires `--verbose` and `-p`.
+
+The wire format itself — which line means what, and the trap in it — is read by `_events`.
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+from typing import Iterator
+
+from .._clock import now
+from .._errors import NarrationFailed
+from ._events import check_result, parsed, text_delta
+from .worker import DROPPED_ENV
+
+__all__ = ["stream_narration", "TIMEOUT", "ISOLATION"]
+
+TIMEOUT = 900.0
+"""Seconds before ONE reading is abandoned. Long enough for a real read, short enough that
+`--digest` cannot hang a terminal somebody left running forever.
+
+240s until a slice of `report all` on axion-v3 (45 closed cards, 340 KB of dossier) ran past
+it and the whole digest was thrown away after twenty minutes of work — five good slices lost
+with it, which is the worst outcome available.
+"""
+
+ISOLATION = ("--tools", "", "--max-turns", "1", "--setting-sources=", "--strict-mcp-config")
+"""What a bare `claude -p` must NOT inherit. This is the cost fix, and it is most of the clock.
+
+Measured on this machine against claude CLI 2.1.220: a bare `claude -p` loaded the developer's
+whole world — 43 skills, 6 MCP servers, 8 subagents and the hooks — and spent **32,541
+cache-creation tokens and USD 0.33 to write three lines**. Every flag deletes one source of it:
+`--setting-sources=` (empty) drops the user, project and local settings files, which is where the
+skills, the subagents and the hooks come from; `--strict-mcp-config` drops the MCP servers, whose
+tool schemas are the bulk of that prompt; `--tools ""` says the narrator reads no files and runs
+no commands, because it is handed the dossier and has nothing to look up; `--max-turns 1` makes
+that literal — one answer, no agent loop.
+
+The narration is a paragraph about a text the caller already has. None of that machinery could
+have helped it, and all of it was being paid for on every pass.
+"""
+
+_STREAM = ("--output-format", "stream-json", "--verbose", "--include-partial-messages")
+"""Ask for deltas. `--include-partial-messages` is the one that streams; it is refused without
+`--verbose`, and `stream-json` alone emits one line with the finished text."""
+
+
+def stream_narration(prompt: str, *, model: str = "",
+                     timeout: float = TIMEOUT) -> Iterator[str]:
+    """The prose of one reading, in the order it is written. Raises `NarrationFailed`.
+
+    A plain synchronous generator: the engine is sync and tested that way, and a narration is
+    one process read line by line, which asyncio would buy nothing for.
+    """
+    command = ["claude", "-p", prompt, *_STREAM, *ISOLATION]
+    if model:
+        command += ["--model", model]
+    try:
+        process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                                   text=True, bufsize=1, env=_env())
+    except FileNotFoundError as missing:
+        raise NarrationFailed(
+            "`claude` is not on PATH — the narration is written by the Claude Code CLI you are "
+            "already logged into. Install it, or write the section by hand") from missing
+    try:
+        yield from _deltas(process, now() + timeout, timeout)
+    finally:
+        # Unconditional: a terminal killed mid-narration must not leave an orphan `claude`
+        # holding a subscription slot, and a generator abandoned early lands here too.
+        process.kill()
+        process.wait()
+
+
+def _deltas(process: "subprocess.Popen[str]", deadline: float, timeout: float) -> Iterator[str]:
+    """Text deltas until the `result` event, refusing to run past the deadline.
+
+    `wait(timeout=)` alone would only bound the time AFTER stdout closes, so a process that
+    dribbles a byte a minute would never hit it. The clock is read on every line instead.
+    """
+    if process.stdout is None:                       # pragma: no cover - PIPE was requested
+        raise NarrationFailed("claude produced no output stream")
+    for line in process.stdout:
+        if now() > deadline:
+            raise NarrationFailed(f"the narration took longer than {int(timeout)}s and was "
+                                  f"abandoned — the dossier is still on disk")
+        event = parsed(line)
+        if event.get("type") == "result":
+            check_result(event)
+            return
+        text = text_delta(event)
+        if text:
+            yield text
+    _ended(process)
+
+
+def _ended(process: "subprocess.Popen[str]") -> None:
+    """stdout closed with no `result`. Say why, using whatever the process left behind."""
+    process.wait()
+    said = (process.stderr.read() if process.stderr else "").strip().splitlines()
+    if process.returncode:
+        raise NarrationFailed(f"claude exited {process.returncode}: "
+                              f"{said[-1] if said else 'no output'}")
+    raise NarrationFailed("claude answered with nothing — check `claude` runs and is "
+                          "logged in (`claude -p hello`)")
+
+
+def _env() -> dict[str, str]:
+    """The developer's environment, minus the API credentials.
+
+    `worker.DROPPED_ENV` names them and the reason is identical here: an exported
+    `ANTHROPIC_API_KEY` makes the CLI bill per token while the subscription sits unused. One
+    constant, two callers — and it is why this stays a subprocess: the flag-translating SDK
+    merges its `env` over the parent's, so it cannot DELETE a variable, only add one.
+    """
+    kept = dict(os.environ)
+    for name in DROPPED_ENV:
+        kept.pop(name, None)
+    return kept

taskops/engine/activity.py

@@ -0,0 +1,94 @@
+"""The state of the WORKERS: what happened in a window, and who is live right now.
+
+Both projections read events and leases, where `project` reads tasks and deps. The
+seam is deliberate: how liveness is judged changes often (a grace period, a new
+activity source) and how a board is drawn should not move when it does.
+"""
+
+from __future__ import annotations
+
+from .._clock import HEARTBEAT_GRACE, now
+from ..contracts import (
+    BranchState,
+    Event,
+    Fleet,
+    FleetMember,
+    Lease,
+    Standup,
+    Task,
+)
+from ..storage import Store
+from .gitstate import branch_states, unknown
+
+__all__ = ["standup", "fleet", "tasks_of"]
+
+_IN_FLIGHT = ("claimed", "in_progress", "review")
+
+
+def standup(store: Store, *, since: float, actor: str = "") -> Standup:
+    """What changed in a window. The auto-generated status report.
+
+    Derived from EVENTS rather than from task rows, so it reports what happened
+    instead of only where things landed: a task claimed, worked on and handed back
+    shows its whole arc, where a row-based report would show it as untouched.
+    """
+    events = [e for e in store.events.since(since)
+              if not actor or e["actor"] == actor]
+    touched = tasks_of(store, [e["task"] for e in events])
+    return Standup(repo=str(store.root), since=since,
+                   actors=sorted({e["actor"] for e in events}), events=events,
+                   done=[t for t in touched if t["status"] == "done"],
+                   in_flight=[t for t in touched if t["status"] in _IN_FLIGHT],
+                   blocked=[t for t in touched if t["status"] == "blocked"])
+
+
+def tasks_of(store: Store, ids: list[str]) -> list[Task]:
+    """The tasks those events were about, deduplicated, missing ones dropped.
+
+    Dropped rather than reported: an event can legitimately name a task this machine
+    has not pulled yet, and a standup is not where a sync gap gets explained.
+    """
+    out: list[Task] = []
+    for task_id in dict.fromkeys(ids):
+        found = store.tasks.get(task_id)
+        if found is not None:
+            out.append(found)
+    return out
+
+
+def fleet(store: Store, *, at: float | None = None) -> Fleet:
+    """Who is working right now, and on what.
+
+    Every live lease appears, including the ones this view no longer believes: an
+    agent whose signal went quiet past the grace period still holds its claim, and a
+    board that hid it would be hiding the exact row somebody needs to act on.
+    """
+    when = now() if at is None else at
+    doing = store.events.latest_by_task("activity")
+    # ONE subprocess for the whole fleet, not one per member: this runs on every board refresh, and
+    # a git call per agent is what turns a live board into a spinning one at ten agents.
+    branches = branch_states(store.root)
+    return Fleet(repo=str(store.root),
+                 members=[_member(lease, doing.get(lease["task"]), when, branches)
+                          for lease in store.leases.live(when)])
+
+
+def _member(lease: Lease, activity: Event | None, when: float,
+            branches: dict[str, BranchState]) -> FleetMember:
+    """One live session. `last_seen` falls back to the CLAIM, not to zero.
+
+    An agent whose hooks are not installed reports no activity at all, and reading
+    that as "last seen at the epoch" would mark every such session dead — which is
+    every session running plain Claude Code without the plugin.
+
+    `git` separates three states a board used to collapse into one: pushed, unpushed, and a branch
+    this clone cannot see at all because the agent is on another machine. Only the last is genuinely
+    unknown, and `unknown()` says so instead of reporting a clean zero.
+    """
+    last_seen = activity["ts"] if activity else lease["acquired"]
+    summary = activity["body"].get("summary", "") if activity else ""
+    return FleetMember(actor=lease["actor"], session=lease["session"],
+                       task=lease["task"], branch=lease["branch"],
+                       alive=(when - last_seen) < HEARTBEAT_GRACE,
+                       last_seen=last_seen, doing=str(summary),
+                       git=branches.get(lease["branch"], unknown(lease["branch"])))

taskops/engine/bus.py

@@ -0,0 +1,42 @@
+"""The in-process fan-out: a write here, a live board there.
+
+Deliberately small, and deliberately NOT the delivery guarantee. Every taskops
+process is short-lived and separate — MCP is a stdio transport, so each editor
+session launches its own server, and each git hook is a fresh interpreter — so a
+subscriber in one process cannot possibly see a publish in another.
+
+That is why the studio does NOT rely on this. It polls `events.after_seq(cursor)`,
+which is an indexed integer scan over a table every process writes to, and pushes
+what it finds to browsers. This bus is the fast path for subscribers that live in
+the SAME process as the writer — the studio's own writes, and the relay — so a
+board updates without waiting for the next poll tick.
+
+The honest summary: SQLite is the transport, and this is a latency optimisation. A
+missed publish costs a fraction of a second, never a lost event.
+
+The fan-out MACHINERY is `wire.Broadcast`, shared with the ephemeral channel that
+carries narration deltas. Two singletons over one implementation, because the
+difference between them is what they carry and who is allowed to persist it — not
+how a listener is registered. A second hand-written publish/subscribe would drift.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, TypeAlias
+
+from ..contracts import Event
+from .wire import Broadcast
+
+__all__ = ["EventBus", "BUS"]
+
+Listener = Callable[[Event], None]
+
+EventBus: TypeAlias = Broadcast[Event]
+"""The bus's type, named. Kept as a name because it is the thing every caller and
+every test refers to, and because "an EventBus" says what a `Broadcast[Event]` is
+for."""
+
+BUS: EventBus = Broadcast()
+"""The process-wide bus. A module-level singleton because the alternative is
+threading one through every use case to serve one optional subscriber — and the
+subscriber is always the same object: whatever is streaming to browsers."""

taskops/engine/commitline.py

@@ -0,0 +1,110 @@
+"""Reading and rewriting a `git commit` shell command.
+
+This exists because of what a Claude Code `PreToolUse` hook can do: return `updatedInput`
+and have the tool call run with a MODIFIED command. So the `Task:` trailer can be injected
+into the agent's own `git commit -m …` before it executes — the agent never writes it, never
+forgets it, and never sees a failure about it.
+
+Parsing shell is a bad idea in general, so the scope here is deliberately narrow: recognise
+`git commit` with a `-m` message, and rebuild the same command with a different message.
+Anything else — a compound command, `-F`, an editor commit with no `-m` — is reported as
+"cannot rewrite", and the caller falls back to allowing or denying without a rewrite. Guessing
+at a command somebody is about to run is how a coordination tool breaks a commit.
+"""
+
+from __future__ import annotations
+
+import shlex
+
+__all__ = ["is_commit", "message_of", "with_message"]
+
+_MESSAGE_FLAGS = ("-m", "--message")
+
+
+def is_commit(command: str) -> bool:
+    """Is this a `git commit`."""
+    return _subcommand(_words(command)) == "commit"
+
+
+def message_of(command: str) -> str:
+    """The `-m` message, or "" when there is not exactly one to read.
+
+    "" covers several different situations on purpose — no `-m` at all (an editor commit),
+    `-F` (a file), or several `-m` flags (git joins them into paragraphs). The caller cannot
+    do anything useful with any of them beyond declining to rewrite, so they collapse.
+    """
+    words = _words(command)
+    found = [words[i + 1] for i, word in enumerate(words[:-1])
+             if word in _MESSAGE_FLAGS]
+    return found[0] if len(found) == 1 else ""
+
+
+def with_message(command: str, message: str) -> str:
+    """The same command with its `-m` value replaced. "" if it cannot be done safely.
+
+    A compound command is refused outright. `git commit -m x && git push` would need this to
+    understand shell operators to rewrite correctly, and a rewrite that dropped the second
+    half would be far worse than no rewrite at all — the agent's push would silently not
+    happen.
+    """
+    if _is_compound(command) or not message_of(command):
+        return ""
+    words = _words(command)
+    out: list[str] = []
+    skip = False
+    for word in words:
+        if skip:
+            out.append(message)
+            skip = False
+            continue
+        out.append(word)
+        skip = word in _MESSAGE_FLAGS
+    return shlex.join(out)
+
+
+def _words(command: str) -> list[str]:
+    """Shell-split, or [] if the command cannot be lexed.
+
+    Never raises: the input is whatever an agent typed, and an unbalanced quote must read as
+    "not something I can analyse" rather than take the hook down and block the commit.
+    """
+    try:
+        return shlex.split(command)
+    except ValueError:
+        return []
+
+
+def _is_compound(command: str) -> bool:
+    """Does the command chain, pipe, redirect or substitute.
+
+    Checked on the RAW string rather than the lexed words, because shlex strips exactly the
+    operators this is looking for — after splitting, `a && b` and `a b` are hard to tell
+    apart, and mistaking one for the other is what would drop half a command.
+    """
+    return any(token in command for token in ("&&", "||", ";", "|", "$(", "`", ">", "<"))
+
+
+_VALUED_FLAGS = ("-C", "-c", "--git-dir", "--work-tree", "--namespace", "--exec-path")
+
+
+def _subcommand(words: list[str]) -> str:
+    """The git subcommand: the first bare word after `git`, or "".
+
+    Parsed properly rather than by looking for "commit" near the front, which is what this did
+    first — and `git log --grep commit` was then read as a commit, so the guard would have
+    inspected a read-only command. Git's own pre-subcommand flags are skipped, including the
+    ones that take a value (`git -C /tmp commit`), because otherwise their argument would be
+    mistaken for the subcommand.
+    """
+    if not words or words[0] != "git":
+        return ""
+    index = 1
+    while index < len(words):
+        word = words[index]
+        if word in _VALUED_FLAGS:
+            index += 2
+        elif word.startswith("-"):
+            index += 1
+        else:
+            return word
+    return ""

taskops/engine/day.py

@@ -0,0 +1,142 @@
+"""A span of calendar days, projected out of the log — the deterministic dossier.
+
+Its own module rather than a third window report beside `standup`, because the WINDOW is the
+design. A standup asks "what changed in the last 24 hours" and moves every time it is run; this
+asks "what happened on Tuesday", or "what happened in July", and July is the same tomorrow.
+That is what makes this report worth writing down and worth diffing against the next one.
+
+A day is the SMALLEST case, not the only one. "How did the project go" is not a question about
+Tuesday, and answering it by reading thirty daily files is how nobody answers it — so the same
+assembly runs over any span of whole days, ending at a midnight the reader would recognise.
+
+Local midnight, not UTC. The reader lives in a timezone and closed a card at 23:50 in it; a UTC
+day would file that under the wrong date for everyone west of Greenwich and be defensible only
+to the machine.
+"""
+
+from __future__ import annotations
+
+import time
+
+from .._clock import now
+from .._errors import BadRequest
+from .._types import LOCAL_ONLY_KINDS, WORKING_STATUSES
+from ..contracts import PeriodReport
+from ..storage import Store
+from ._closed import closed_cards
+from ._opened import opened_cards, waiting_tasks
+from .activity import tasks_of
+from .history import rolls
+
+__all__ = ["period_report", "day_report", "label_of", "first_date", "window", "shift",
+           "date_of", "MAX_EVENTS", "MAX_CLOSED"]
+
+MAX_EVENTS = 20_000
+"""A ceiling, not a page. A day that overflows it is a day nobody could read anyway, and the
+alternative — a silent 500-row default — would produce a dossier that looks complete."""
+
+MAX_CLOSED = 200
+"""How many closed cards one report renders in full. A month can close more than a person
+will read, and every card carries its whole commit list — so the cap is real. What is NOT
+allowed is cutting quietly: the overflow is counted into `dropped` and printed."""
+
+
+def day_report(store: Store, date: str) -> PeriodReport:
+    """Everything that happened on `date` (`YYYY-MM-DD`) — the one-day case of a period."""
+    return period_report(store, date, date)
+
+
+def period_report(store: Store, start_date: str, end_date: str,
+                  label: str = "") -> PeriodReport:
+    """Every day from `start_date` to `end_date` INCLUSIVE, from events and git alone.
+
+    One assembly, not two: a week is a day with a wider window, and a second copy of this
+    would be the copy that forgets to exclude heartbeats.
+
+    `label` is an override for the one name the dates cannot produce: `report all` covers a
+    span that is only incidentally 2026-07-14..2026-07-28, and calling its file that would
+    mean yesterday's "everything" and today's are two different documents.
+    """
+    start, end = window(start_date)[0], window(end_date)[1]
+    if end <= start:
+        raise BadRequest(f"`{start_date}` is after `{end_date}` — a range runs forwards")
+    events = [e for e in store.events.since(start - 1.0, limit=MAX_EVENTS)
+              if start <= e["ts"] < end and e["kind"] not in LOCAL_ONLY_KINDS]
+    touched = tasks_of(store, [e["task"] for e in events])
+    dones = [e for e in events if e["kind"] == "done"]
+    opened = opened_cards(store, events)
+    return PeriodReport(
+        repo=str(store.root), from_date=start_date, to_date=end_date,
+        label=label or label_of(start_date, end_date),
+        closed=closed_cards(store, dones[-MAX_CLOSED:]),
+        dropped=max(0, len(dones) - MAX_CLOSED),
+        opened=opened,
+        in_flight=[t for t in touched if t["status"] in WORKING_STATUSES],
+        blocked=[t for t in touched if t["status"] == "blocked"],
+        waiting=waiting_tasks(touched, opened),
+        conversations=[e for e in events if e["kind"] in ("comment", "message")],
+        actors=rolls(events),
+        commits_total=sum(1 for e in events if e["kind"] == "commit"))
+
+
+def label_of(start_date: str, end_date: str) -> str:
+    """`2026-07-28` for one day, `2026-07-22..2026-07-28` for a range.
+
+    Derived in ONE place because it is both the report's heading and the name of the file it
+    is written to — computing it twice is how a `2026-07-22..28.md` ends up titled otherwise.
+    """
+    return start_date if start_date == end_date else f"{start_date}..{end_date}"
+
+
+def first_date(store: Store) -> str:
+    """The local date of the OLDEST event in the log — where `report all` starts.
+
+    Read from the log rather than from the repository's first commit: taskops knows about the
+    project from its first event, and claiming to cover days that predate the log would be
+    reporting silence as a fact.
+    """
+    oldest = store.events.since(-1.0, limit=1)
+    return date_of(oldest[0]["ts"]) if oldest else date_of(now())
+
+
+def window(date: str) -> tuple[float, float]:
+    """`2026-07-28` -> the timestamps of local midnight and the NEXT local midnight.
+
+    Both ends come from `mktime`, which normalises an out-of-range day (`32 July` is
+    `1 August`) and applies the zone's own rules — so the day the clocks change is 23 or 25
+    hours long here, exactly as it was for the person who worked it. `start + 86400` would
+    be wrong twice a year, and wrong in the direction of losing an hour of somebody's work.
+    """
+    try:
+        parsed = time.strptime(date, "%Y-%m-%d")
+    except ValueError:
+        raise BadRequest(f"`{date}` is not a date — use YYYY-MM-DD, "
+                         f"e.g. 2026-07-28") from None
+    fields = (parsed.tm_year, parsed.tm_mon, parsed.tm_mday)
+    return (_midnight(fields), _midnight((fields[0], fields[1], fields[2] + 1)))
+
+
+def shift(date: str, *, days: int = 0, months: int = 0) -> str:
+    """`2026-07-28`, `days=-6` -> `2026-07-22`. What turns `--last 7d` into a start date.
+
+    `mktime` does the calendar: an out-of-range field is normalised, so `months=-1` on the
+    31st of a month with no 31st lands on the 1st or the 3rd of the next one rather than
+    raising. Approximate at the edges and never wrong about how long a month is, which is the
+    trade a hand-rolled `date - 30` gets backwards.
+    """
+    parsed = time.strptime(date, "%Y-%m-%d")
+    return date_of(_midnight((parsed.tm_year, parsed.tm_mon + months,
+                              parsed.tm_mday + days)))
+
+
+def _midnight(fields: tuple[int, int, int]) -> float:
+    """Local 00:00 of a (year, month, day). `-1` for `tm_isdst` lets libc decide, which is
+    the only way to get the right answer on the hour a DST transition repeats."""
+    year, month, day = fields
+    return time.mktime((year, month, day, 0, 0, 0, 0, 0, -1))
+
+
+def date_of(ts: float) -> str:
+    """The local calendar date a timestamp falls on. The inverse of `window`, and what turns
+    "now" into a default without a second notion of where a day starts."""
+    return time.strftime("%Y-%m-%d", time.localtime(ts))

taskops/engine/diffstat.py

@@ -0,0 +1,63 @@
+"""How big each commit was, for a whole day's worth of them in ONE subprocess.
+
+`git diff-tree --numstat` takes one commit; handing it several makes it diff the first
+against the rest, which is a different question and a wrong answer. `git log --no-walk`
+is the batched form: it prints the named commits and nothing they descend from, so N shas
+cost one process instead of N — the same reasoning as `gitstate.branch_states`.
+
+Same degrade rule as the rest of `gitio`: never raises. A report that cannot be produced
+because a sha was garbage-collected is worse than one that reports zeros.
+"""
+
+from __future__ import annotations
+
+import subprocess
+from pathlib import Path
+
+__all__ = ["numstats", "parse"]
+
+
+def numstats(root: Path, shas: list[str]) -> dict[str, tuple[int, int]]:
+    """`{sha: (additions, deletions)}` for the shas git could resolve. ONE subprocess.
+
+    Shas git does not know are simply absent from the result — the caller reads a missing
+    key as zeros, so an unknown commit and an empty commit render the same way, which is
+    the honest thing to say when git will not tell us the difference.
+    """
+    wanted = [sha for sha in dict.fromkeys(shas) if sha]
+    if not wanted:
+        return {}
+    try:
+        done = subprocess.run(["git", "log", "--numstat", "--format=%H", "--no-walk",
+                               *wanted], cwd=root, capture_output=True, text=True,
+                              timeout=20, check=False)
+    except (OSError, subprocess.SubprocessError):
+        return {}
+    return parse(done.stdout) if done.returncode == 0 else {}
+
+
+def parse(out: str) -> dict[str, tuple[int, int]]:
+    """The `--numstat` stream -> totals per commit.
+
+    A bare line is a sha (the `%H` header) and a three-column line is one file. Binary files
+    report `-` for both counts, which is not zero but is the only number that can be summed,
+    so they contribute nothing rather than breaking the parse.
+
+    Split out and pure so the format can be tested from a literal string: reproducing this
+    from a real repository would mean building commits in a fixture to assert on arithmetic.
+    """
+    totals: dict[str, tuple[int, int]] = {}
+    current = ""
+    for line in out.splitlines():
+        parts = line.split("\t")
+        if len(parts) == 1 and line.strip():
+            current = line.strip()
+            totals.setdefault(current, (0, 0))
+        elif len(parts) == 3 and current:
+            adds, dels = totals[current]
+            totals[current] = (adds + _count(parts[0]), dels + _count(parts[1]))
+    return totals
+
+
+def _count(cell: str) -> int:
+    return int(cell) if cell.isdigit() else 0