deepcell-cli 0.6.1__py3-none-any.whl

deepcell_cli/logging_setup.py

@@ -0,0 +1,161 @@
+"""Log configuration for the ``deepcell-mcp`` server.
+
+Why this duplicates ``backend/src/core/logging_config.py``
+-----------------------------------------------------------
+It cannot import it. ``deepcell-cli`` is a standalone published package, and
+the ``mcp-server`` container is built from the ``cli/`` context alone
+(``docker/docker-compose.yml``) — ``backend/`` is not in the image. So the wire
+contract is shared, the code is not.
+
+**The wire contract is the thing to keep in sync**, not this file's structure:
+the key names below (``level`` lowercase, ``message``, ``logger``, ``service``,
+``logging.googleapis.com/sourceLocation``) are what
+``docker/ops-agent/config.yaml`` parses and ``docker/ops-agent/verify.sh``
+asserts. ``level`` rather than ``severity`` is deliberate — see that config's
+header for why a plain ``severity`` key does not set the LogEntry severity.
+
+Everything goes to **stderr**, never stdout. Under the stdio transport, stdout
+*is* the MCP protocol channel: a log line there corrupts the session. Docker's
+json-file driver captures both streams, so the deployed stack loses nothing.
+"""
+
+from __future__ import annotations
+
+import json
+import logging
+import os
+import sys
+from datetime import datetime, timezone
+
+_LOG_FORMATS = ("text", "json")
+
+_TEXT_FMT = "%(asctime)s - %(name)s - %(levelname)s - %(filename)s:%(lineno)d - %(message)s"
+
+_SOURCE_LOCATION_KEY = "logging.googleapis.com/sourceLocation"
+
+# Attribute names a fresh LogRecord already owns; anything else on a record was
+# put there by a caller's ``extra=``. Derived rather than hard-coded because the
+# set moves between Python versions (``taskName`` arrived in 3.12).
+_RESERVED_RECORD_ATTRS = frozenset(
+    logging.LogRecord("x", logging.INFO, "x", 0, "x", None, None).__dict__
+) | {"message", "asctime"}
+
+# Top-level keys this formatter owns. An extra colliding with one is prefixed
+# rather than allowed to overwrite it — losing the message because a caller
+# passed ``extra={"message": ...}`` would be a bad trade.
+_JSON_RESERVED_KEYS = frozenset(
+    {"time", "level", "message", "logger", "service", "stack_trace", _SOURCE_LOCATION_KEY}
+)
+
+
+class JsonFormatter(logging.Formatter):
+    """One Cloud Logging-shaped JSON object per record.
+
+    Per-record ``extra=`` fields become **top-level keys**, matching
+    ``backend/src/core/logging_config.py`` — a field named the same way must
+    land under the same key whichever service emitted it, since both feed the
+    same ``jsonPayload.<field>`` queries.
+
+    Never raises: ``default=str`` stringifies anything unserializable rather
+    than losing the line to a formatter traceback. ``ensure_ascii=False`` keeps
+    emoji as UTF-8.
+    """
+
+    def __init__(self, service: str | None = None) -> None:
+        super().__init__()
+        self._service = service if service is not None else _resolve_service()
+
+    def format(self, record: logging.LogRecord) -> str:
+        payload: dict[str, object] = {
+            "time": datetime.fromtimestamp(record.created, timezone.utc)
+            .isoformat()
+            .replace("+00:00", "Z"),
+            "level": record.levelname.lower(),
+            "message": record.getMessage(),
+            "logger": record.name,
+            _SOURCE_LOCATION_KEY: {
+                "file": record.filename,
+                "line": str(record.lineno),
+                "function": record.funcName,
+            },
+        }
+        if self._service:
+            payload["service"] = self._service
+        if record.exc_info:
+            payload["stack_trace"] = self.formatException(record.exc_info)
+        elif record.exc_text:
+            payload["stack_trace"] = record.exc_text
+
+        for key, value in record.__dict__.items():
+            if key in _RESERVED_RECORD_ATTRS:
+                continue
+            payload[f"ctx_{key}" if key in _JSON_RESERVED_KEYS else key] = value
+
+        return json.dumps(payload, ensure_ascii=False, default=str)
+
+
+def _resolve_service() -> str | None:
+    """The `service` label, from LOG_SERVICE.
+
+    Docker's json-file path carries the container ID, not its name, so
+    ``resource.labels.container_name`` does not exist for a GCE VM tail. Each
+    service labels itself instead.
+    """
+    return os.getenv("LOG_SERVICE", "").strip() or None
+
+
+def _resolve_format(default: str = "text") -> tuple[str, str | None]:
+    """Read LOG_FORMAT, falling back to `default` with a complaint if unusable."""
+    raw = os.getenv("LOG_FORMAT", "").strip().lower()
+    if not raw:
+        return default, None
+    if raw not in _LOG_FORMATS:
+        return default, (
+            f"Ignoring unrecognized LOG_FORMAT={raw!r}; expected one of "
+            f"{', '.join(_LOG_FORMATS)}. Using {default}."
+        )
+    return raw, None
+
+
+def _resolve_level(default: int = logging.INFO) -> tuple[int, str | None]:
+    """Read LOG_LEVEL (name or number), falling back to `default` with a complaint."""
+    raw = os.getenv("LOG_LEVEL", "").strip()
+    if not raw:
+        return default, None
+    if raw.isdigit():
+        return int(raw), None
+    resolved = getattr(logging, raw.upper(), None)
+    # `getLevelName` round-trips only for registered levels; anything else comes
+    # back as the "Level %s" placeholder — so `LOG_LEVEL=raiseExceptions` is
+    # rejected rather than silently resolved to some unrelated module attribute.
+    if (
+        isinstance(resolved, int)
+        and not isinstance(resolved, bool)
+        and not logging.getLevelName(resolved).startswith("Level ")
+    ):
+        return resolved, None
+    return default, (
+        f"Ignoring unrecognized LOG_LEVEL={raw!r}; "
+        f"using {logging.getLevelName(default)}"
+    )
+
+
+def setup_logging(level: int = logging.INFO) -> None:
+    """Install the MCP server's stderr log handler.
+
+    Honours ``LOG_LEVEL`` (name or number), ``LOG_FORMAT`` (``text``/``json``)
+    and ``LOG_SERVICE``. Safe to call more than once — ``force=True`` replaces
+    handlers rather than stacking them.
+    """
+    resolved_level, level_problem = _resolve_level(level)
+    fmt, fmt_problem = _resolve_format()
+
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(
+        JsonFormatter() if fmt == "json" else logging.Formatter(_TEXT_FMT)
+    )
+    logging.basicConfig(level=resolved_level, handlers=[handler], force=True)
+
+    for problem in (fmt_problem, level_problem):
+        if problem:
+            logging.getLogger(__name__).warning(problem)

deepcell_cli/main.py

@@ -0,0 +1,518 @@
+"""Root Click group and global options for the ``deepcell`` CLI."""
+
+from __future__ import annotations
+
+import copy
+
+import click
+
+from deepcell_cli import __version__
+from deepcell_cli.config import DEFAULT_API_URL
+from deepcell_cli.context import Ctx, pass_ctx
+
+
+# ── Flexible group (global opts after subcommand) ─────────
+
+
+class FlexibleGroup(click.Group):
+    """Click Group that allows global options after the subcommand name.
+
+    Supports: deepcell guide orient/start -f plain
+    In addition to: deepcell -f plain guide orient/start
+    """
+
+    # Global options that take a value
+    _GLOBAL_VALUE_OPTS = {"-f", "--format", "--project", "--workspace"}
+    # Global flags (no value)
+    _GLOBAL_FLAG_OPTS = {"-v", "--verbose"}
+
+    def format_commands(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        """Render the command index staged, in the order the work happens.
+
+        The stage of each command is declared in ``deepcell_cli.stages`` and
+        nowhere else. There is deliberately no fallback bucket: a command with
+        no stage does not quietly appear under ``Other``, it fails
+        ``stages.assert_fully_staged`` in the test suite. The old safety net is
+        exactly how ``account`` and ``changes`` went uncategorized unnoticed.
+
+        Within a stage, only commands with a confusable sibling get a summary
+        line (``stages.DISAMBIGUATED``); the rest collapse to a name run. That
+        is what keeps this near ``deepcell guide``'s one-screen budget while
+        still answering the question an agent actually gets wrong — which of
+        ``describe`` / ``query`` / ``grep`` to reach for.
+        """
+        from deepcell_cli import stages
+
+        commands = {name: self.get_command(ctx, name) for name in self.list_commands(ctx)}
+        visible = {n: c for n, c in commands.items() if c and not c.hidden}
+
+        def _run(names: list[str]) -> str:
+            return " · ".join(names)
+
+        for tier in stages.STAGE_ORDER:
+            names = [n for n in stages.commands_in(tier) if n in visible]
+            if not names:
+                continue
+            heading = f"{tier.upper()} — {stages.STAGE_SUMMARY[tier]}"
+            with formatter.section(heading):
+                rows = [
+                    (n, visible[n].get_short_help_str(limit=formatter.width))
+                    for n in names
+                    if n in stages.DISAMBIGUATED
+                ]
+                if rows:
+                    formatter.write_dl(rows)
+                rest = [n for n in names if n not in stages.DISAMBIGUATED]
+                if rest:
+                    formatter.write_text(_run(rest))
+
+        # The three tiers that are not stages: one collapsed line each.
+        tail = [
+            (tier, [n for n in stages.commands_in(tier) if n in visible])
+            for tier in stages.TAIL_ORDER
+        ]
+        tail = [(t, n) for t, n in tail if n]
+        if tail:
+            # Short dl terms on purpose. Folding the tier summary into the term
+            # ("Learn (the five reference surfaces)") overruns Click's term
+            # column and throws the whole name run onto its own deeply indented
+            # line — the summaries are not worth that, since these three tiers
+            # are self-describing in a way the stages are not.
+            with formatter.section("Also"):
+                formatter.write_dl(
+                    [(tier.capitalize(), _run(names)) for tier, names in tail]
+                )
+
+    def format_help(self, ctx: click.Context, formatter: click.HelpFormatter) -> None:
+        super().format_help(ctx, formatter)
+        status = _build_status_section()
+        if status:
+            formatter.write("\n")
+            formatter.write(status)
+
+    def resolve_command(self, ctx: click.Context, args: list[str]):
+        try:
+            return super().resolve_command(ctx, args)
+        except click.UsageError as exc:
+            if args and "No such command" in str(exc):
+                _track_unknown_command(args[0], args[1:])
+            raise
+
+    def _target_command_opts(
+        self, cmd_name: str, rest: list[str]
+    ) -> tuple[set[str], int]:
+        """Options accepted by the final command in the chain, and where it ends.
+
+        Walks nested groups (``defs add-item``) using the leading
+        positionals so hoisting can defer to an option the subcommand itself
+        defines (which may be repeatable or carry different semantics).
+
+        The second element is the index in *rest* just past the resolved
+        subcommand chain. Only options AFTER that point belong to the
+        subcommand: ``defs --workspace a add-item`` writes it at group
+        position, where the user means the global option.
+        """
+        cmd: click.Command | None = self.commands.get(cmd_name)
+        i = 0
+        while isinstance(cmd, click.Group) and i < len(rest):
+            nxt = rest[i]
+            if nxt.startswith("-"):
+                # Step OVER a leading global option instead of giving up on the
+                # walk. Bailing here resolves a nested command to its group,
+                # whose params may differ from the target leaf's options.
+                if nxt in self._GLOBAL_VALUE_OPTS and i + 1 < len(rest):
+                    i += 2
+                elif nxt in self._GLOBAL_FLAG_OPTS or nxt.startswith(
+                    tuple(f"{o}=" for o in self._GLOBAL_VALUE_OPTS)
+                ):
+                    i += 1
+                else:
+                    break
+                continue
+            sub = cmd.commands.get(nxt)
+            if sub is None:
+                break
+            cmd = sub
+            i += 1
+        opts: set[str] = set()
+        if cmd is not None:
+            for p in cmd.params:
+                opts.update(p.opts)
+                opts.update(p.secondary_opts)
+        return opts, i
+
+    def parse_args(self, ctx: click.Context, args: list[str]) -> list[str]:
+        # Find subcommand position. Skip the VALUE of a leading global option
+        # as well as the option itself — otherwise `--workspace query describe
+        # f.deepcell` treated the workspace name `query` as the subcommand.
+        # `mcp_server._command_index` already resolves this way; the two
+        # parsers disagreeing is what let blocked-command checks and the real
+        # dispatch see different commands.
+        cmd_idx = None
+        i = 0
+        while i < len(args):
+            arg = args[i]
+            if arg in self._GLOBAL_VALUE_OPTS:
+                i += 2
+                continue
+            if arg.startswith("-"):
+                i += 1
+                continue
+            if arg in self.commands:
+                cmd_idx = i
+                break
+            i += 1
+
+        if cmd_idx is not None:
+            before = list(args[:cmd_idx])
+            cmd_name = args[cmd_idx]
+            after = list(args[cmd_idx + 1 :])
+
+            # An option the target subcommand defines itself must stay with it —
+            # Hoisting an option that a nested leaf defines can silently change
+            # its meaning. The same option written BEFORE the subcommand name is
+            # not yet in the subcommand's scope, so Click would reject it on the
+            # group; move it across the subcommand instead of hoisting it to root.
+            local_opts, sub_end = self._target_command_opts(cmd_name, after)
+            hoist_value_opts = self._GLOBAL_VALUE_OPTS - local_opts
+            hoist_flag_opts = self._GLOBAL_FLAG_OPTS - local_opts
+
+            new_after: list[str] = []
+            relocated: list[str] = []
+            i = 0
+            while i < len(after):
+                a = after[i]
+                # Before the subcommand name, a local option is relocated after
+                # it; after the subcommand name it is simply left in place.
+                sink = new_after if i >= sub_end else relocated
+                if a in self._GLOBAL_VALUE_OPTS and i + 1 < len(after):
+                    (before if a in hoist_value_opts else sink).extend(
+                        [a, after[i + 1]]
+                    )
+                    i += 2
+                elif a.startswith(
+                    tuple(f"{o}=" for o in self._GLOBAL_VALUE_OPTS)
+                ):
+                    opt = a.split("=", 1)[0]
+                    (before if opt in hoist_value_opts else sink).append(a)
+                    i += 1
+                elif a in self._GLOBAL_FLAG_OPTS:
+                    (before if a in hoist_flag_opts else sink).append(a)
+                    i += 1
+                else:
+                    new_after.append(a)
+                    i += 1
+
+            args = before + [cmd_name] + new_after + relocated
+
+        return super().parse_args(ctx, args)
+
+
+# Tracking daemons started by `_track_unknown_command`. In production this is
+# fire-and-forget — daemons die with the process. In tests the list lets the
+# conftest drain in-flight threads between tests so a stale POST doesn't leak
+# into a successor test's `respx` mock context.
+_TRACKING_THREADS: list = []
+
+
+def _track_unknown_command(command: str, args: list[str]) -> None:
+    """Fire-and-forget POST of unknown command to backend."""
+    import threading
+
+    from deepcell_cli.config import client_headers as _client_headers
+
+    # Resolved HERE, on the calling thread, not inside `_send`. The surface
+    # comes from an environment variable, and under the MCP server this runs
+    # inside `CliRunner.invoke`, whose isolation restores os.environ the moment
+    # the command returns — usually before the daemon thread gets scheduled. A
+    # thread reading it later would report `cli` for an MCP caller.
+    surface_headers = dict(_client_headers())
+
+    def _send() -> None:
+        try:
+            import time
+
+            import httpx
+
+            from deepcell_cli.config import get_access_token, get_api_url
+
+            token = get_access_token()
+            headers = dict(surface_headers)
+            if token:
+                headers["Authorization"] = f"Bearer {token}"
+            httpx.Client(timeout=5.0).post(
+                f"{get_api_url()}/cli/unknown-commands",
+                json={
+                    "command": command,
+                    "args": args,
+                    "cli_version": __version__,
+                    "timestamp": time.time(),
+                },
+                headers=headers,
+            )
+        except Exception:
+            pass
+
+    t = threading.Thread(target=_send, daemon=True)
+    _TRACKING_THREADS.append(t)
+    t.start()
+
+
+def _build_status_section() -> str:
+    """Build a dynamic Status section for --help output.
+
+    The facts come from the same collector `deepcell doctor` uses, so the two
+    surfaces cannot disagree about who you are or where your next command
+    lands. Only the rendering differs: this is a footnote on a help screen,
+    `doctor` is the command you run when the footnote says something is wrong.
+    """
+    from deepcell_cli.commands.doctor import _collect
+
+    try:
+        # No health probe: --help is typed constantly and does not report
+        # server state, so the round trip would be latency for nothing.
+        report = _collect(Ctx(), timeout=5.0, probe=False)
+    except Exception:
+        # A help screen must render even when the environment is broken.
+        return ""
+
+    lines = ["Status:"]
+    if report["identity"] == "none":
+        lines.append("  Not signed in. Run `deepcell login` to sign in.")
+        return "\n".join(lines) + "\n"
+
+    if report["identity"] == "anonymous":
+        lines.append("  Not signed in. Run `deepcell login` to sign in.")
+    else:
+        lines.append(f"  Logged in as {report['email'] or 'unknown'}")
+
+    workspace = report["workspace"]
+    if not workspace:
+        lines.append(
+            '  No active project. Run `deepcell project create "My Project"` to get started.'
+        )
+        return "\n".join(lines) + "\n"
+
+    count = report["files"]
+    if count is None:
+        lines.append(f"  Project: {workspace}")
+    else:
+        lines.append(f"  Project: {workspace} ({count} file{'s' if count != 1 else ''})")
+
+    lines.append("\n  `deepcell doctor` checks all of this, including the server.")
+    return "\n".join(lines) + "\n"
+
+
+# ── Root group ──────────────────────────────────────────────
+
+# f-string so the documented default can never drift from the real one in
+# deepcell_cli.config (issue #998: the epilog used to claim localhost while
+# the built-in default pointed at production).
+_EPILOG = f"""\b
+Getting started:
+  deepcell doctor                            # check this machine's setup
+  deepcell guide orient/start                # build something (no account needed)
+  deepcell register                          # keep your work (or: deepcell login)
+
+\b
+Environment variables:
+  DEEPCELL_API_URL        API endpoint (default: {DEFAULT_API_URL})
+  DEEPCELL_PROJECT        Override active project (DEEPCELL_WORKSPACE still honored)
+  DEEPCELL_CONFIG         Alternate config.json path (session-scoped config)
+  DEEPCELL_ACCESS_TOKEN   Auth token for CI/headless use
+  DEEPCELL_NO_ANON        Set to opt out of the anonymous session
+  DEEPCELL_NO_UPGRADE_CHECK  Set to silence the upgrade-available notice
+"""
+
+
+class _FormatChoice(click.Choice):
+    """``-f`` is ``--format``, but nearly every command here takes a FILE.
+
+    ``-f <file>`` is the natural guess, and the stock Choice error answers it
+    with "'model.deepcell' is not one of 'json', 'table', 'plain'" — accurate,
+    and silent about the one thing the caller needed to know: the filename is a
+    *positional* argument. In the 2026-08-09 cli-eval run a worker made this
+    exact call three times in a row (`revise_structure_rename`), re-reading the
+    same unhelpful error each time — the "error message that did not teach"
+    signature. Say the actual fix instead.
+    """
+
+    def convert(self, value, param, ctx):  # type: ignore[no-untyped-def]
+        if isinstance(value, str) and value.endswith(".deepcell"):
+            # Deliberately NOT ctx.command_path: -f is a group-level option, so
+            # at this point the context is the root group and command_path is
+            # bare "deepcell" — rendering it into the example would suggest
+            # `deepcell model.deepcell ...`, which is not a command at all.
+            self.fail(
+                f"{value!r} is a filename, but -f/--format selects the output "
+                f"format ({', '.join(self.choices)}). Filenames are positional "
+                f"arguments — `deepcell <command> {value} ...`, not -f. "
+                f"Run `deepcell <command> --help` for the exact argument order.",
+                param,
+                ctx,
+            )
+        return super().convert(value, param, ctx)
+
+
+# help_option_names inherits through Click's Context into every subcommand
+# and group, so this single setting enables `-h` CLI-wide (eval U4: it
+# previously worked nowhere, two exit-2s in one trace).
+@click.group(
+    cls=FlexibleGroup,
+    epilog=_EPILOG,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+@click.version_option(__version__, prog_name="deepcell")
+@click.option("-v", "--verbose", is_flag=True, help="Print debug info to stderr.")
+@click.option(
+    "-f",
+    "--format",
+    "fmt",
+    type=_FormatChoice(["json", "table", "plain"]),
+    default=None,
+    help="Output format (default: plain).",
+)
+@click.option(
+    "--project",
+    "--workspace",
+    "workspace",
+    default=None,
+    metavar="SLUG",
+    help="Target project for this invocation (overrides DEEPCELL_PROJECT and the active project).",
+)
+@click.pass_context
+def cli(ctx: click.Context, verbose: bool, fmt: str | None, workspace: str | None) -> None:
+    """DeepCell CLI — put ideas, calculations, documents and slides in one file.
+
+    A .deepcell file keeps conclusions with the assumptions, evidence and
+    calculations behind them, and it remembers how the parts connect: change
+    one idea and you can see what it affects. Four selectable surfaces —
+    Reasoning (ideas), Spreadsheet (calculations), Document (prose), Deck
+    (slides). Qualitative work may need no Spreadsheet; another may use all four.
+
+    \b
+    Start here — the two entry points, and what each is for:
+      deepcell help [command]     What to TYPE. Exact flags, arguments, exits.
+      deepcell guide [topic]      What to DO next. The procedure, in order.
+
+    \b
+    Then, when a specific answer is needed:
+      deepcell rules [id]         Invariants that must remain true.
+      deepcell ref [id]           Legal names and values, generated from code.
+      deepcell example list       Complete valid artifacts and transcripts.
+    """
+    from deepcell_cli.config import get_default_format
+    from deepcell_cli.upgrade_check import schedule as schedule_upgrade_check
+
+    ctx.ensure_object(Ctx)
+    ctx.obj.verbose = verbose
+    ctx.obj.fmt = fmt or get_default_format()
+    ctx.obj.workspace = workspace
+    # No `ctx.obj.command` here on purpose: `ctx.invoked_subcommand` is the
+    # group only (`defs`, never `defs add-item`). `Ctx.client` resolves the
+    # full path from Click's context stack once a leaf command is running.
+
+    # Reads a cached answer (no network) and defers the notice to context
+    # close, so it lands after the command's own output. Never raises.
+    schedule_upgrade_check(ctx)
+
+
+# ── Register sub-commands ───────────────────────────────────
+
+from deepcell_cli.commands.auth import login, register, logout, whoami, verify_email  # noqa: E402
+from deepcell_cli.commands.account import account  # noqa: E402
+from deepcell_cli.commands.workspace import project  # noqa: E402
+from deepcell_cli.commands.files import ls, cat, write, rm  # noqa: E402
+from deepcell_cli.commands.download import download  # noqa: E402
+from deepcell_cli.commands.describe import describe  # noqa: E402
+from deepcell_cli.commands.query import query, cell_meta, relationships  # noqa: E402
+from deepcell_cli.commands.edit import edit  # noqa: E402
+from deepcell_cli.commands.replace import replace  # noqa: E402
+from deepcell_cli.commands.defs import defs  # noqa: E402
+from deepcell_cli.commands.guide import guide  # noqa: E402
+from deepcell_cli.commands.rules import rules  # noqa: E402
+from deepcell_cli.commands.ref import ref  # noqa: E402
+from deepcell_cli.commands.help_cmd import help_cmd  # noqa: E402
+from deepcell_cli.commands.example import example  # noqa: E402
+from deepcell_cli.commands.doctor import doctor  # noqa: E402
+from deepcell_cli.commands.export import to_excel  # noqa: E402
+from deepcell_cli.commands.deck import deck  # noqa: E402
+from deepcell_cli.commands.doc import doc  # noqa: E402
+from deepcell_cli.commands.impact import impact  # noqa: E402
+from deepcell_cli.commands.export_docx import to_docx  # noqa: E402
+from deepcell_cli.commands.export_pdf import to_pdf  # noqa: E402
+from deepcell_cli.commands.export_pptx import to_pptx  # noqa: E402
+from deepcell_cli.commands.version import log, diff, restore  # noqa: E402
+from deepcell_cli.commands.changes import changes  # noqa: E402
+from deepcell_cli.commands.variant import variant  # noqa: E402
+from deepcell_cli.commands.grep import grep  # noqa: E402
+from deepcell_cli.commands.sync import clone, pull, push, sync_status, commit  # noqa: E402
+from deepcell_cli.commands.merge import merge  # noqa: E402
+from deepcell_cli.commands.import_cmd import import_cmd  # noqa: E402
+from deepcell_cli.commands.ingest import ingest  # noqa: E402
+from deepcell_cli.commands.reasoning import claim, assumption, reasoning, reasoning_diff  # noqa: E402
+from deepcell_cli.commands.share import share  # noqa: E402
+from deepcell_cli.commands.viewer import viewer  # noqa: E402
+from deepcell_cli.commands.upgrade import upgrade  # noqa: E402
+
+cli.add_command(login)
+cli.add_command(register)
+cli.add_command(logout)
+cli.add_command(whoami)
+cli.add_command(account)
+cli.add_command(verify_email, "verify-email")
+cli.add_command(project)
+# ``workspace`` was the name until the concept was renamed. It stays
+# registered so existing scripts and muscle memory keep working, but
+# hidden: `surface.py` and `main`'s own help both skip hidden commands,
+# so it produces no help row and no entry in any generated surface.
+_workspace_alias = copy.copy(project)
+_workspace_alias.name = "workspace"
+_workspace_alias.hidden = True
+cli.add_command(_workspace_alias, "workspace")
+cli.add_command(ls)
+cli.add_command(cat)
+cli.add_command(write)
+cli.add_command(rm)
+cli.add_command(download)
+cli.add_command(describe)
+cli.add_command(query)
+cli.add_command(cell_meta, "cell-meta")
+cli.add_command(relationships)
+cli.add_command(edit)
+cli.add_command(replace)
+cli.add_command(defs)
+cli.add_command(guide)
+cli.add_command(rules)
+cli.add_command(ref)
+cli.add_command(help_cmd)
+cli.add_command(example)
+cli.add_command(doctor)
+cli.add_command(to_excel, "to-excel")
+cli.add_command(to_pptx, "to-pptx")
+cli.add_command(to_docx, "to-docx")
+cli.add_command(to_pdf, "to-pdf")
+cli.add_command(doc, "doc")
+cli.add_command(impact, "impact")
+cli.add_command(deck, "deck")
+cli.add_command(log)
+cli.add_command(diff)
+cli.add_command(restore)
+cli.add_command(changes)
+cli.add_command(variant)
+cli.add_command(grep)
+cli.add_command(clone)
+cli.add_command(pull)
+cli.add_command(push)
+cli.add_command(sync_status, "status")
+cli.add_command(commit)
+cli.add_command(merge)
+cli.add_command(import_cmd, "import")
+cli.add_command(ingest)
+cli.add_command(claim)
+cli.add_command(assumption)
+cli.add_command(reasoning)
+cli.add_command(reasoning_diff, "reasoning-diff")
+cli.add_command(share)
+cli.add_command(viewer)
+cli.add_command(upgrade)