calkit-python 0.48.3__py3-none-any.whl → 0.49.0__py3-none-any.whl

calkit/cli/__init__.py

@@ -1,7 +1,17 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
 from .core import *  # noqa: F403
 
+if TYPE_CHECKING:
+    import typer
+
 
 def run() -> None:
+    import os
+    import sys
+
     # Intercept ``--use-version`` before Typer/Click parses argv: Click
     # processes eager options like ``--help`` and ``--version`` (and the
     # group's ``no_args_is_help``) ahead of the callback body, so an
@@ -11,7 +21,61 @@ def run() -> None:
     _maybe_exec_with_version()
     from .main import app
 
-    app()
+    # Completion lists commands, so needs them all
+    if any(k.startswith("_") and k.endswith("_COMPLETE") for k in os.environ):
+        app()
+    else:
+        _only_invoked(app, sys.argv[1:])()
+
+
+def _only_invoked(
+    app: typer.Typer, args: list[str], top: bool = True
+) -> typer.Typer:
+    """Narrow ``app`` to the command or group ``args`` invoke.
+
+    Typer builds every command's options before running one, which for all
+    of Calkit's takes a few tenths of a second, so this leaves out the ones
+    that won't run. Anything else, e.g., ``--help`` or a misspelled command,
+    keeps them all, so help and suggestions list everything.
+    decisions/calkit.yaml has a question on how much that saves.
+    """
+    import copy
+    import re
+
+    from typer.main import get_command_name, solve_typer_info_defaults
+
+    from .main.core import APP_OPTIONS_WITH_VALUES
+
+    # Find the command name, skipping the top level's options
+    takes_value = {
+        flag for flags in APP_OPTIONS_WITH_VALUES.values() for flag in flags
+    }
+    i = 0
+    while i < len(args) and args[i].startswith("-") and top:
+        i += 2 if args[i] in takes_value else 1
+    if i >= len(args) or args[i].startswith("-"):
+        return app
+    name, rest = args[i], args[i + 1 :]
+
+    def names(spec: str | None) -> list[str]:
+        return re.split(r" ?[,|] ?", spec) if spec else []
+
+    narrowed = copy.copy(app)
+    for cmd in app.registered_commands:
+        default = cmd.callback and get_command_name(cmd.callback.__name__)
+        if name in names(cmd.name or default):
+            narrowed.registered_commands = [cmd]
+            narrowed.registered_groups = []
+            return narrowed
+    for group in app.registered_groups:
+        sub_app = group.typer_instance
+        if sub_app and name in names(solve_typer_info_defaults(group).name):
+            group = copy.copy(group)
+            group.typer_instance = _only_invoked(sub_app, rest, top=False)
+            narrowed.registered_commands = []
+            narrowed.registered_groups = [group]
+            return narrowed
+    return app
 
 
 def _maybe_exec_with_version() -> None:

calkit/cli/check.py

@@ -6,6 +6,7 @@ import functools
 import json
 import os
 import platform as _platform
+import re
 import shutil
 import subprocess
 import textwrap
@@ -18,7 +19,15 @@ import calkit
 from calkit.cli import AliasGroup, raise_error, warn
 from calkit.core import get_md5
 
-check_app = typer.Typer(cls=AliasGroup, no_args_is_help=True)
+
+def stage_calkit_files(*args: object, **kwargs: object) -> None:
+    """Stage what a check wrote, which stages depend on."""
+    calkit.environments.stage_calkit_files()
+
+
+check_app = typer.Typer(
+    cls=AliasGroup, no_args_is_help=True, result_callback=stage_calkit_files
+)
 
 
 def _juliaup_version_installed(julia_version: str) -> bool:
@@ -62,6 +71,7 @@ def _check_julia_env(
     julia_version: str | None = None,
     verbose: bool = False,
     cache_key: str | None = None,
+    force: bool = False,
 ) -> str:
     """Check a Julia environment and instantiate only when needed."""
     abs_env_path = os.path.abspath(env_path)
@@ -80,7 +90,7 @@ def _check_julia_env(
     cache_env_name = cache_key or (
         f"julia::{abs_env_path}::{julia_version or ''}"
     )
-    if calkit.environments.check_cache(
+    if not force and calkit.environments.check_cache(
         env_name=cache_env_name,
         env=env,
         wdir=env_dir,
@@ -471,8 +481,20 @@ def check_environment(
     verbose: Annotated[
         bool, typer.Option("--verbose", help="Print verbose output.")
     ] = False,
+    force: Annotated[
+        bool,
+        typer.Option(
+            "--force",
+            "-f",
+            help="Rebuild the environment from scratch, e.g., after "
+            "something it was built from changed outside the project.",
+        ),
+    ] = False,
 ) -> str | None:
-    """Check that an environment is up-to-date."""
+    """Check that an environment is up-to-date.
+
+    An environment is also rebuilt when one of its 'inputs' changes.
+    """
     from calkit.environments import (
         get_all_conda_lock_fpaths,
         get_all_docker_lock_fpaths,
@@ -480,7 +502,6 @@ def check_environment(
         get_default_venv_prefix,
         get_env_lock_fpath,
         write_scheduler_env_lock,
-        write_system_env_lock,
     )
 
     dotenv.load_dotenv(dotenv_path=".env", verbose=verbose)
@@ -491,9 +512,28 @@ def check_environment(
     if isinstance(envs, list):
         raise_error("Error: Environments should be a dict, not a list")
     assert isinstance(envs, dict)
-    if env_name not in envs:
+    found = calkit.environments.get_env(env_name, envs)
+    if found is None:
         raise_error(f"Environment '{env_name}' does not exist")
-    env = envs[env_name]
+    env = found
+    # Docker records its inputs in its lock, which rebuilds it already
+    try:
+        rebuild = force or (
+            env["kind"] != "docker"
+            and calkit.environments.inputs_changed_since_build(env_name, env)
+        )
+    except ValueError as e:
+        raise_error(f"Environment '{env_name}': {e}")
+    if rebuild and env["kind"] not in (
+        "docker",
+        calkit.environments.SWITCH_KIND,
+    ):
+        try:
+            removed = calkit.environments.remove_built_env(env_name, envs)
+        except (ValueError, OSError, subprocess.CalledProcessError) as e:
+            raise_error(f"Failed to remove environment '{env_name}': {e}")
+        if removed and verbose:
+            typer.echo(f"Removed {removed} to rebuild it")
     if env["kind"] == "docker":
         lock_fpath = get_env_lock_fpath(
             env=env, env_name=env_name, as_posix=False
@@ -535,6 +575,7 @@ def check_environment(
             registry=env.get("registry"),
             lock_archs=calkit.docker.get_lock_archs(env),
             quiet=not verbose,
+            rebuild=rebuild,
         )
     elif env["kind"] == "conda":
         lock_fpath = get_env_lock_fpath(
@@ -615,6 +656,7 @@ def check_environment(
             output_fpath=get_env_lock_fpath(
                 env=env, env_name=env_name, as_posix=False
             ),  # type: ignore
+            rebuild=rebuild,
         )
     elif env["kind"] == "julia":
         env_path = env.get("path")
@@ -630,6 +672,7 @@ def check_environment(
             julia_version=julia_version,
             verbose=verbose,
             cache_key=env_name,
+            force=rebuild,
         )
     elif env["kind"] in ("slurm", "pbs"):
         # Job-scheduler envs have no external manifest to validate; the
@@ -637,6 +680,81 @@ def check_environment(
         # env config so DVC stages that depend on the env get invalidated
         # when the config changes.
         write_scheduler_env_lock(env_name=env_name, env=env)
+    elif env["kind"] == calkit.environments.SWITCH_KIND:
+        # Checking a switch means checking what it picks here. Until a stage
+        # has run with it, i.e., none depends on its lock, options on other
+        # machines are locked too, where they can be reached, and every
+        # option's lock is part of the switch's.
+        switch_lock = os.path.join(
+            calkit.environments.get_env_lock_dir(), env_name, "switch.json"
+        )
+        try:
+            with open("dvc.lock") as f:
+                ran = switch_lock.replace(os.sep, "/") in f.read()
+        except OSError:
+            ran = False
+        try:
+            options = calkit.environments.get_switch_options(env_name, envs)
+        except ValueError as e:
+            raise_error(str(e))
+        for option in [] if ran else options:
+            option_env = calkit.environments.get_env(option, envs) or {}
+            option_lock = get_env_lock_fpath(
+                env=option_env, env_name=option, as_posix=False
+            )
+            if (
+                option_env.get("kind") != "system"
+                or not option_env.get("lock")
+                or not option_env.get("host")
+                or calkit.environments.env_is_local(option_env)
+                or (option_lock is not None and os.path.isfile(option_lock))
+            ):
+                continue
+            try:
+                check_environment(env_name=option, verbose=verbose)
+            except typer.Exit:
+                warn(
+                    f"Option '{option}' of '{env_name}' couldn't be locked "
+                    "from here, so it will be on its first check there"
+                )
+        try:
+            calkit.environments.write_switch_env_lock(
+                env_name, envs, relocked=None if ran else options
+            )
+            picked = calkit.environments.resolve_switch(env_name, envs)
+        except ValueError as e:
+            raise_error(str(e))
+        if picked is None:
+            warn(calkit.environments.describe_switch_no_match(env_name, env))
+            return None
+        if verbose:
+            typer.echo(f"Environment '{env_name}' picks '{picked}' here")
+        if env.get("lock"):
+            machine_env = calkit.environments.switch_machine_lock_env(env)
+            try:
+                mismatch = calkit.environments.gate_system_env_lock(
+                    env_name,
+                    machine_env,
+                    system_info=calkit.environments.picked_machine_info(
+                        picked,
+                        (calkit.environments.get_env(picked, envs) or {}),
+                        ck_info,
+                        lock=env.get("lock"),
+                    ),
+                )
+            except ValueError as e:
+                raise_error(f"Environment '{env_name}': {e}")
+            if mismatch:
+                warn(
+                    calkit.environments.describe_system_env_lock_mismatch(
+                        env_name, mismatch
+                    )
+                )
+        lock_fpath = check_environment(
+            env_name=picked, verbose=verbose, force=rebuild
+        )
+        calkit.environments.record_build_inputs(env_name, env)
+        return lock_fpath
     elif env["kind"] == "system":
         # Nothing is installed or built for a system env; checking it means
         # making sure the machine is as the project requires, then reading
@@ -647,7 +765,17 @@ def check_environment(
                 calkit.check_requirements(
                     requirements=env.get("requirements", [])
                 )
-                write_system_env_lock(env_name=env_name, env=env)
+                # A mismatch warns, and stages that need to run are
+                # skipped, or fail at the gate in 'xenv'
+                mismatch = calkit.environments.gate_system_env_lock(
+                    env_name, env
+                )
+                if mismatch:
+                    warn(
+                        calkit.environments.describe_system_env_lock_mismatch(
+                            env_name, mismatch
+                        )
+                    )
             except ValueError as e:
                 # A requirement that isn't met, or a property that can't be
                 # locked -- a misspelled one, or a tool that isn't
@@ -662,9 +790,9 @@ def check_environment(
             # from that machine, since those are the ones the results
             # depend on.
             import calkit.workspace as workspace
-            from calkit.dependencies import _is_interactive
+            from calkit.core import is_tty
 
-            interactive = _is_interactive()
+            interactive = is_tty()
             ck_info = calkit.load_calkit_info()
             try:
                 # Anything written as ${CK_SSH_HOST} is the first thing to
@@ -713,7 +841,12 @@ def check_environment(
                 )
                 system_info = None
                 if needs_system_info:
-                    system_info = workspace.remote_system_info(ws)
+                    system_info = workspace.remote_system_info(
+                        ws,
+                        apps=calkit.environments.lock_app_names(
+                            env.get("lock")
+                        ),
+                    )
                     # Before anything else is decided from it, so a
                     # mismatched machine is reported rather than measured
                     # and recorded as what results depend on
@@ -727,19 +860,22 @@ def check_environment(
                     system_info=system_info,
                     verbose=verbose,
                 )
-                # Returns None when the env locks nothing, so nothing is
-                # written for an env with nothing to record
-                write_system_env_lock(
-                    env_name=env_name,
-                    env=env,
-                    system_info=system_info,
+                mismatch = calkit.environments.gate_system_env_lock(
+                    env_name, env, system_info=system_info
                 )
+                if mismatch:
+                    warn(
+                        calkit.environments.describe_system_env_lock_mismatch(
+                            env_name, mismatch
+                        )
+                    )
             except ValueError as e:
                 raise_error(f"Environment '{env_name}': {e}")
     elif env["kind"] == "nix":
         check_nix_env(env=env, verbose=verbose)
     else:
         raise_error(f"Environment kind '{env['kind']}' not supported")
+    calkit.environments.record_build_inputs(env_name, env)
     return get_env_lock_fpath(env=env, env_name=env_name, as_posix=False)
 
 
@@ -1116,15 +1252,28 @@ def check_docker_env(
     quiet: Annotated[
         bool, typer.Option("--quiet", "-q", help="Be quiet.")
     ] = False,
+    rebuild: Annotated[
+        bool,
+        typer.Option(
+            "--rebuild",
+            help="Build the image from scratch, pulling its base image, "
+            "rather than reusing a cached or locked one.",
+        ),
+    ] = False,
 ) -> None:
     """Check that Docker environment is up-to-date."""
     from calkit import docker as ck_docker
+    from calkit.core import is_tty
     from calkit.environments import get_docker_arch
 
     if fpath is None and lock_fpath is None:
         raise_error(
             "Lock file output path must be provided if input Dockerfile is not"
         )
+    try:
+        ck_docker.ensure_ready(interactive=is_tty())
+    except ck_docker.DockerNotReadyError as e:
+        raise_error(str(e))
     outfile = open(os.devnull, "w") if quiet else None
     if fpath is not None:
         typer.echo(f"Reading Dockerfile from {fpath}", file=outfile)
@@ -1201,6 +1350,10 @@ def check_docker_env(
         )
         lock = None
         lock_is_current_arch = False
+    # Without a Dockerfile, rebuilding means pulling the image again
+    if rebuild:
+        lock = None
+        lock_is_current_arch = False
     # Work out where this image lives in a registry, so it can be pulled
     # instead of rebuilt, and pushed after being built. Only an image built
     # from a Dockerfile goes to the project's registry; one named directly
@@ -1350,10 +1503,14 @@ def check_docker_env(
                     "--push",
                     "-f",
                     dockerfile_name,
-                    ".",
                 ]
+                if rebuild:
+                    cmd += ["--no-cache", "--pull"]
+                cmd.append(".")
             else:
                 cmd = ["docker", "build", "-t", tag, "-f", dockerfile_name]
+                if rebuild:
+                    cmd += ["--no-cache", "--pull"]
                 build_platform = (
                     build_platforms[0] if build_platforms else platform
                 )
@@ -1792,21 +1949,26 @@ def check_venv(
     if lock_fpath is None:
         fname, ext = os.path.splitext(path)
         lock_fpath = fname + "-lock" + ext
-    lock_dir = os.path.dirname(lock_fpath)
+
+    def full(fpath: str) -> str:
+        return os.path.join(wdir or "", fpath)
+
+    lock_fpath_full = full(lock_fpath)
+    lock_dir = os.path.dirname(lock_fpath_full)
     if lock_dir:
         os.makedirs(lock_dir, exist_ok=True)
     # Use main lock file if exists, else try alternatives (including legacy)
     reqs_to_use = lock_fpath
     used_legacy_lock = None
-    if not os.path.isfile(lock_fpath):
+    if not os.path.isfile(lock_fpath_full):
         for alt_fpath in alt_lock_fpaths:
-            if os.path.isfile(alt_fpath):
+            if os.path.isfile(full(alt_fpath)):
                 reqs_to_use = alt_fpath
                 if verbose:
                     typer.echo(f"Using alternative lock file: {alt_fpath}")
                 break
         for legacy_fpath in alt_lock_fpaths_delete:
-            if os.path.isfile(legacy_fpath):
+            if os.path.isfile(full(legacy_fpath)):
                 reqs_to_use = legacy_fpath
                 used_legacy_lock = legacy_fpath
                 if verbose:
@@ -1814,20 +1976,89 @@ def check_venv(
                 break
     activate_cmd = calkit.environments.get_venv_activate_cmd(prefix)
 
+    def venv_python_version() -> str | None:
+        """The Python version a plain venv was created with."""
+        if _platform.system() == "Windows":
+            exe = os.path.join(prefix_full_path, "Scripts", "python.exe")
+        else:
+            exe = os.path.join(prefix_full_path, "bin", "python")
+        try:
+            return subprocess.check_output(
+                [
+                    exe,
+                    "-c",
+                    "import platform; print(platform.python_version())",
+                ],
+                text=True,
+            ).strip()
+        except (OSError, subprocess.CalledProcessError):
+            return None
+
+    def is_local(line: str) -> bool:
+        """Whether a frozen requirement names a path on this machine."""
+        line = line.strip()
+        if line.startswith(("-e ", "--editable")):
+            return re.match(r"^(-e|--editable)[\s=]+\w+\+", line) is None
+        return re.search(r"@\s*file:", line) is not None
+
+    recorded_hash = calkit.environments.read_env_spec_hash(lock_fpath, wdir)
+    spec_hash = calkit.environments.env_spec_hash(full(path), python=python)
+    # A lock resolved from the current spec is an input, not rewritten here
+    lock_is_current = (
+        os.path.isfile(lock_fpath_full) and recorded_hash == spec_hash
+    )
+
     def pip_install_and_freeze(reqs_arg: str) -> None:
         check_cmd = (
-            f"{activate_cmd} "
-            f"&& {pip_cmd} install {pip_install_args} {reqs_arg} "
-            f"&& {pip_freeze_cmd} > {lock_fpath} "
-            "&& deactivate"
+            f"{activate_cmd} && {pip_cmd} install {pip_install_args} "
+            f"{reqs_arg}"
         )
+        if not lock_is_current:
+            check_cmd += f" && {pip_freeze_cmd} > {lock_fpath}"
+        check_cmd += " && deactivate"
         if verbose:
             typer.echo(f"Running command: {check_cmd}")
+        try:
+            with open(lock_fpath_full, encoding="utf-8") as f:
+                lock_before = f.read()
+        except OSError:
+            lock_before = None
         subprocess.run(check_cmd, shell=True, cwd=wdir, check=True)
+        if lock_is_current:
+            return
+        # Local packages are installed from the spec, since their paths
+        # differ between machines
+        with open(lock_fpath_full, encoding="utf-8") as f:
+            frozen = f.read()
+        lock = "".join(
+            ln for ln in frozen.splitlines(keepends=True) if not is_local(ln)
+        )
+        if lock != frozen:
+            with open(lock_fpath_full, "w", encoding="utf-8") as f:
+                f.write(lock)
+        lock_changed = lock != lock_before
+        # All platforms are relocked together, so they agree; an existing
+        # lock that matches is adopted as is, and one with no record is
+        # only added to
+        spec_changed = recorded_hash != spec_hash
+        adopted = recorded_hash is None and not lock_changed
+        if (lock_changed or spec_changed) and not adopted:
+            calkit.environments.write_cross_platform_venv_locks(
+                spec_fpath=path,
+                lock_fpath=lock_fpath,
+                python_version=python or venv_python_version(),
+                wdir=wdir,
+                verbose=verbose,
+                relock=spec_changed and recorded_hash is not None,
+            )
+        # Last, so an interrupted relock isn't taken as current
+        calkit.environments.write_env_spec_hash(
+            lock_fpath, path, python=python, wdir=wdir
+        )
         # Delete legacy lock file after use
         if used_legacy_lock:
             try:
-                os.remove(used_legacy_lock)
+                os.remove(full(used_legacy_lock))
                 if verbose:
                     typer.echo(
                         "Deleted legacy lock file after use: "
@@ -1840,9 +2071,19 @@ def check_venv(
                         f"{used_legacy_lock}: {e}"
                     )
 
-    # If the lock file exists, try to install with that
+    # A lock resolved from an older spec would bring back what the spec no
+    # longer has, as would the env built from it, so both start over
     dep_file_txt = f"-r {path}"
-    if os.path.isfile(reqs_to_use):
+    if recorded_hash is not None and recorded_hash != spec_hash:
+        if verbose:
+            typer.echo(f"Rebuilding {kind} at {prefix} since its spec changed")
+        try:
+            shutil.rmtree(prefix_full_path)
+            create_venv()
+        except OSError as e:
+            warn(f"Failed to remove {kind} at {prefix}: {e}")
+    elif os.path.isfile(full(reqs_to_use)):
+        # If the lock file exists, try to install with that
         dep_file_txt += f" -r {reqs_to_use}"
     try:
         pip_install_and_freeze(dep_file_txt)
@@ -1861,6 +2102,14 @@ def check_venv(
             create_venv()
             pip_install_and_freeze(dep_file_txt)
         except (subprocess.CalledProcessError, OSError):
+            if lock_is_current:
+                raise_error(
+                    f"Failed to create {kind} at {prefix} from its lock file "
+                    f"({lock_fpath}), which matches the spec ({path}). "
+                    "Rebuilding from the spec would leave the environment "
+                    "out of sync with its lock; delete the lock file to "
+                    "re-resolve it, which reruns stages that depend on it"
+                )
             warn(
                 f"Failed to create environment from lock file ({reqs_to_use}); "
                 f"attempting rebuild from input file {path}"
@@ -1879,15 +2128,20 @@ def check_matlab_env(
         typer.Option("--name", "-n", help="Environment name in calkit.yaml."),
     ],
     output_fpath: Annotated[str, typer.Option("--output", "-o")],
+    rebuild: Annotated[
+        bool,
+        typer.Option("--rebuild", help="Rebuild the image from scratch."),
+    ] = False,
 ) -> None:
     """Check a MATLAB environment matches its spec and export a JSON lock
     file.
     """
     ck_info = calkit.load_calkit_info()
     environments = ck_info.get("environments", {})
-    if env_name not in environments:
+    found = calkit.environments.get_env(env_name, environments)
+    if found is None:
         raise_error(f"Environment '{env_name}' not found in calkit.yaml")
-    env = environments[env_name]
+    env = found
     if env.get("kind") != "matlab":
         raise_error(f"Environment '{env_name}' is not a MATLAB environment")
     if "version" not in env:
@@ -1913,6 +2167,7 @@ def check_matlab_env(
         fpath=dockerfile_fpath,
         lock_fpath=output_fpath,
         platform="linux/amd64",  # Only one available for now
+        rebuild=rebuild,
     )
 
 
@@ -1953,6 +2208,54 @@ def check_project_requirements(
     calkit.echo(message)
 
 
+@check_app.command(name="stage-runs")
+def check_stage_runs() -> None:
+    """Check each stage in dvc.lock matches the recorded run that made it.
+
+    A stage's entry in .calkit/stage-runs.json records a checksum of its
+    dvc.lock entry after it ran, so one that disagrees got its dvc.lock
+    entry some other way, e.g., 'dvc commit' after an output was edited, an
+    edit or merge of dvc.lock, or running it outside Calkit. This catches
+    mistakes and shortcuts, not forgery, since a matching entry can be
+    written by anyone.
+    """
+    try:
+        with open(calkit.STAGE_RUNS_FPATH) as f:
+            stage_runs = json.load(f)
+    except OSError:
+        stage_runs = {}
+    except json.JSONDecodeError as e:
+        raise_error(f"Can't read {calkit.STAGE_RUNS_FPATH}: {e}")
+    # By directory, for a subproject's stages
+    lock_stages = {None: calkit.dvc.read_lock_stages()}
+    problems = []
+    for name in sorted(set(lock_stages[None]) | set(stage_runs)):
+        lock_dir, lock_name = calkit.dvc.split_lock_stage_name(name)
+        if lock_dir not in lock_stages:
+            lock_stages[lock_dir] = calkit.dvc.read_lock_stages(lock_dir)
+        locked = lock_stages[lock_dir].get(lock_name)
+        # One no longer in dvc.lock has nothing to vouch for
+        if not isinstance(locked, dict):
+            continue
+        recorded = stage_runs.get(name)
+        if not isinstance(recorded, dict):
+            problems.append(f"Stage '{name}' has no recorded run")
+        elif recorded.get("dvc_lock") != calkit.dvc.stage_lock_md5(locked):
+            problems.append(
+                f"Stage '{name}' has changed in dvc.lock since its last "
+                "recorded run"
+            )
+    for problem in problems:
+        typer.echo(problem)
+    if problems:
+        raise_error(
+            f"{len(problems)} stage(s) in dvc.lock don't match a recorded "
+            f"run in {calkit.STAGE_RUNS_FPATH}; rerunning them with "
+            "'calkit run --force <stage>' records them"
+        )
+    typer.echo("Every stage in dvc.lock matches its recorded run")
+
+
 @check_app.command(name="env-vars")
 def check_env_vars(
     verbose: Annotated[

calkit/cli/delete.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import typer
+from typing_extensions import Annotated
 
 import calkit
 from calkit.cli import AliasGroup, raise_error
@@ -31,3 +32,27 @@ def delete_question(
     with open("calkit.yaml", "w") as f:
         ryaml.dump(ck_info, f)
     typer.echo(f"Removed question: {removed}")
+
+
+@delete_app.command(name="comment")
+def delete_comment(
+    path: Annotated[
+        str | None,
+        typer.Argument(help="File the thread is in, if not found by --id."),
+    ] = None,
+    id: Annotated[
+        str | None,
+        typer.Option(
+            "--id",
+            help="ID of the thread, which finds it in any of the project's documents.",
+        ),
+    ] = None,
+    line: Annotated[
+        int | None,
+        typer.Option("--line", "-l", help="Number of any line in the thread."),
+    ] = None,
+) -> None:
+    """Delete a review comment thread and its replies."""
+    from calkit.cli.latex import edit_comment
+
+    edit_comment(path, id, line, None)