karni-cli 0.3.1__py3-none-any.whl

karni_cli/commands/doctor.py

@@ -0,0 +1,136 @@
+"""``karni doctor`` — a human-readable report on the environment karni sees.
+
+One line per fact: the project, how project commands would run (``.venv`` or
+a running compose service), Node/npm, the ``@karni/ui`` manifest behind
+``karni context``'s COMPONENTS/HOOKS, whether the agent adapters are fresh,
+and which history providers are installed / detect a store. It reports and
+never changes anything; the exit status is 0 unless the CLI itself fails.
+
+It may end with ONE tip (see :mod:`karni_cli.tips`); ``-q`` suppresses it.
+This is human output — never parse it; agents use ``karni context``.
+"""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+import typer
+
+from karni_cli import agent_data, tips
+from karni_cli import history as history_mod
+from karni_cli import project as project_mod
+from karni_cli.adapters import sync
+from karni_cli.commands.context import find_manifest
+from karni_cli.project import CliError, find_project
+
+_WIDTH = 12
+
+
+def _line(label: str, text: str) -> str:
+    return f"{label:<{_WIDTH}}{text}"
+
+
+def tool_version(name: str) -> str | None:
+    """``<name> --version`` output, or ``None`` when absent or failing."""
+    executable = shutil.which(name)
+    if executable is None:
+        return None
+    try:
+        proc = subprocess.run(
+            [executable, "--version"],
+            capture_output=True,
+            text=True,
+            timeout=10,
+            check=False,
+            stdin=subprocess.DEVNULL,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    out = proc.stdout.strip().splitlines()
+    return out[0] if proc.returncode == 0 and out else None
+
+
+def _display(path: Path, project: Path) -> str:
+    """``path`` relative to the project when it lives inside it, else as given.
+
+    The quickstart's layout keeps the venv one level above the project.
+    """
+    try:
+        return str(path.relative_to(project))
+    except ValueError:
+        return str(path)
+
+
+def _interpreter(project: Path, service: str) -> str:
+    python = project_mod.venv_python(project)
+    if python is not None:
+        return f"{_display(python, project)} (project commands run here)"
+    if project_mod.compose_service_running(project, service):
+        return f'docker compose service "{service}" (running)'
+    return (
+        "none — create .venv (python -m venv .venv && .venv/bin/pip install -e .), activate a "
+        "virtualenv with the project's dependencies, or start the stack (docker compose up -d)"
+    )
+
+
+def _node() -> str:
+    node = tool_version("node")
+    if node is None:
+        return "not found — needed for the frontend and `karni types`"
+    npm = tool_version("npm")
+    return f"{node} (npm {npm})" if npm else f"{node} (npm not found)"
+
+
+def _manifest(project: Path) -> str:
+    found = find_manifest(project, None)
+    if found is None:
+        return "@karni/ui manifest absent — `npm install` in frontend/ (COMPONENTS/HOOKS hidden)"
+    return f"@karni/ui manifest: {_display(found, project)}"
+
+
+def _adapters(project: Path) -> str:
+    try:
+        result = sync(project, agent_data.load(project), check=True)
+    except CliError as exc:
+        return f"cannot check: {exc}"
+    if result.stale:
+        return f"stale ({len(result.stale)} files) — run `karni rules sync`"
+    return f"up to date ({len(result.unchanged)} files)"
+
+
+def _history(project: Path) -> list[str]:
+    found = history_mod.discovered()
+    if found is None:
+        return ["unavailable (karni.agent.history not found)"]
+    detected = history_mod.detected_names(project)
+    lines = (
+        [f"{name}: store detected — `karni context --with-history FILE`" for name in detected]
+        if detected
+        else [f"no store detected (installed: {', '.join(found.names) or 'none'})"]
+    )
+    lines += [f"skipped provider {error}" for error in found.errors]
+    return lines
+
+
+def doctor(
+    service: str = typer.Option("django", "--service", envvar="KARNI_COMPOSE_SERVICE"),
+    quiet: bool = typer.Option(False, "--quiet", "-q", help="Do not print the optional tip."),
+) -> None:
+    project = find_project()
+    if project is None:
+        typer.echo(_line("project", "not found (no manage.py here or above)"))
+        typer.echo(_line("node", _node()))
+        return
+    typer.echo(_line("project", str(project)))
+    typer.echo(_line("interpreter", _interpreter(project, service)))
+    typer.echo(_line("node", _node()))
+    typer.echo(_line("ui", _manifest(project)))
+    typer.echo(_line("adapters", _adapters(project)))
+    for i, text in enumerate(_history(project)):
+        typer.echo(_line("history" if i == 0 else "", text))
+    tip = tips.history_tip(project, quiet=quiet)
+    if tip:
+        typer.echo("")
+        typer.echo(tip)

karni_cli/commands/explain.py

@@ -0,0 +1,60 @@
+"""``karni explain CODE`` — what an error code means and how to fix it, offline.
+
+    karni explain E104        a Karni error or system check (E/W codes)
+    karni explain C101        a karni command error (C codes)
+    karni explain PAY004      an installed module's code (asks the project interpreter)
+    karni explain K106        an agent rule (same as karni rules --explain K106)
+
+Works without Django and without a project; every error Karni prints starts
+with its code, so an agent can run this instead of searching the docs.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+
+import typer
+
+from karni_cli import agent_data
+from karni_cli.errorcodes import lookup
+from karni_cli.project import CliError, find_project
+from karni_cli.rules_render import render_explain
+
+_RULE = re.compile(r"^[KP]\d{3}$")
+
+
+def render_entry(entry: dict[str, str]) -> str:
+    return "\n".join(
+        [
+            f"{entry['code']}  {entry['title']}  ({entry['kind']})",
+            "",
+            f"Why:   {entry['why']}",
+            f"Fix:   {entry['fix']}",
+            f"From:  {entry['source']}",
+            f"Docs:  {entry['url']}",
+        ]
+    )
+
+
+def explain(
+    code: str = typer.Argument(..., help="An error code such as E104, W101, C101, PAY004 or K106."),
+    as_json: bool = typer.Option(False, "--json", help="Machine-readable output."),
+) -> None:
+    """Explain an error code: why Karni objects and the exact fix."""
+    wanted = code.strip().upper()
+    if _RULE.match(wanted):
+        rule = agent_data.load(find_project()).rule(wanted)
+        if rule is None:
+            raise CliError(f"No rule {wanted!r} — `karni rules` lists the codes.", code="C204")
+        typer.echo(json.dumps(rule, indent=2) if as_json else render_explain(rule))
+        return
+    entry = lookup(wanted)
+    if entry is None:
+        raise CliError(
+            f"Unknown code {code!r}. Codes look like E104, W101, C101, PAY004 or K106 and "
+            "start every Karni error message; a module's codes are found inside a project "
+            "that installs it. docs/errors.md lists every code.",
+            code="C204",
+        )
+    typer.echo(json.dumps(entry, indent=2) if as_json else render_entry(entry))

karni_cli/commands/make.py

@@ -0,0 +1,55 @@
+"""``karni make <type>`` — artisan-style generators (and the ``make:<type>`` aliases).
+
+Every generator writes project code only, never overwrites without
+``--force``, previews with ``--dry-run``, prints each created/modified file,
+and edits existing files only through marker comments or AST-located
+appends. ``karni make --list`` prints them all; the generators themselves
+live in :mod:`karni_cli.generators`.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from karni_cli.generators import GENERATORS
+
+make_app = typer.Typer(
+    help=(
+        "Generate project code: apps, models, viewsets, tasks, schedules, listeners, pages "
+        "... (`karni make --list`). Never overwrites without --force; --dry-run previews."
+    ),
+    no_args_is_help=False,
+    add_completion=False,
+)
+
+
+def list_text() -> str:
+    width = max(len(g.name) for g in GENERATORS) + 2
+    return "\n".join(f"{g.name:<{width}}{g.summary}" for g in GENERATORS)
+
+
+@make_app.callback(invoke_without_command=True)
+def make(
+    ctx: typer.Context,
+    list_: bool = typer.Option(
+        False, "--list", help="Print every generator with a one-line summary."
+    ),
+) -> None:
+    if ctx.invoked_subcommand is not None:
+        return
+    if list_:
+        typer.echo(list_text())
+        return
+    typer.echo(ctx.get_help())
+
+
+for _generator in GENERATORS:
+    make_app.command(_generator.name, short_help=_generator.summary)(_generator.command)
+
+
+def register_aliases(app: typer.Typer) -> None:
+    """``karni make:<type>`` — hidden Laravel-style aliases for every generator."""
+    for generator in GENERATORS:
+        app.command(f"make:{generator.name}", hidden=True, short_help=generator.summary)(
+            generator.command
+        )

karni_cli/commands/manage_passthrough.py

@@ -0,0 +1,28 @@
+"""``karni manage`` — raw ``manage.py`` passthrough in the project environment.
+
+The escape hatch for any Django/third-party management command without a
+dedicated runner. Put ``--`` before arguments that clash with this command's
+own options (``--docker``, ``--service``, ``--help``).
+"""
+
+from __future__ import annotations
+
+import typer
+
+from karni_cli import project as project_mod
+from karni_cli.project import require_project
+
+
+def manage(
+    args: list[str] | None = typer.Argument(
+        None, help="The manage.py command and its arguments, e.g. `showmigrations events`."
+    ),
+    docker: bool | None = typer.Option(None, "--docker/--no-docker"),
+    service: str = typer.Option("django", "--service", envvar="KARNI_COMPOSE_SERVICE"),
+) -> None:
+    """Run any management command — wraps `manage.py ARGS` (raw passthrough)."""
+    project = require_project()
+    proc = project_mod.run_manage(
+        project, list(args or []), docker=docker, service=service, capture=False, interactive=True
+    )
+    raise typer.Exit(proc.returncode)

karni_cli/commands/mcp.py

@@ -0,0 +1,20 @@
+"""``karni mcp`` — run the Karni MCP server on stdio (``pip install 'karni-cli[mcp]'``)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from karni_cli.project import find_project
+
+
+def mcp(
+    project: Path | None = typer.Option(
+        None, "--project", help="Project root (default: found from the working directory)."
+    ),
+) -> None:
+    from karni_cli.mcp_server import build_server  # lazy: the MCP SDK is an extra
+
+    root = project.resolve() if project is not None else find_project()
+    build_server(root).run()

karni_cli/commands/migrate.py

@@ -0,0 +1,23 @@
+"""``karni migrate`` — apply database migrations through the project interpreter."""
+
+from __future__ import annotations
+
+import typer
+
+from karni_cli import project as project_mod
+from karni_cli.project import require_project
+
+
+def migrate(
+    args: list[str] | None = typer.Argument(
+        None, help="Passed to manage.py migrate: [app_label] [migration_name] --plan --fake …"
+    ),
+    docker: bool | None = typer.Option(None, "--docker/--no-docker"),
+    service: str = typer.Option("django", "--service", envvar="KARNI_COMPOSE_SERVICE"),
+) -> None:
+    """Apply migrations — wraps `manage.py migrate [ARGS]`."""
+    project = require_project()
+    proc = project_mod.run_manage(
+        project, ["migrate", *(args or [])], docker=docker, service=service, capture=False
+    )
+    raise typer.Exit(proc.returncode)

karni_cli/commands/new.py

@@ -0,0 +1,106 @@
+"""``karni new <name>`` — scaffold a project from templates/project.
+
+The template carries no agent guidance files: they are generated afterwards
+by the same code as ``karni rules sync`` (AGENTS.md, CLAUDE.md, Cursor,
+Windsurf, Copilot, Cline, Aider, Junie adapters + slash commands).
+
+@karni/ui is resolved like the template: ``KARNI_UI_SRC`` > the monorepo
+checkout's ``packages/karni-ui`` > the npm release. A local source becomes
+``"@karni/ui": "file:<abs path>"`` in frontend/package.json (installed as a
+packed copy via the scaffold's ``.npmrc``), and its ``dist/`` is built here
+when missing — package.json ``exports`` point into dist/.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+
+from karni_cli import agent_data, scaffold
+from karni_cli.adapters import sync
+from karni_cli.brand import print_mark
+from karni_cli.scaffold import resolve_template, validate_name
+
+
+def write_agent_adapters(project: Path) -> int:
+    """Generate the agent adapter files into a freshly rendered project."""
+    result = sync(project, agent_data.load(project))
+    return len(result.written)
+
+
+def prepare_ui_source(source: Path) -> None:
+    """Make sure a local @karni/ui has the dist/ a ``file:`` install ships."""
+    rebuild = f"(cd {source} && npm install && npm run build)"
+    if not scaffold.ui_dist_missing(source):
+        if scaffold.ui_dist_stale(source):
+            typer.echo(
+                f"warning: {source}/dist is older than its sources — rebuild it with "
+                f"{rebuild} before `npm install` in frontend/.",
+                err=True,
+            )
+        return
+    typer.echo(f"Building @karni/ui in {source} (dist/ is missing; file: installs ship dist/)...")
+    failure = scaffold.build_ui_dist(source)
+    if failure is not None:
+        typer.echo(
+            f"warning: could not build @karni/ui: {failure}\n"
+            f"Build it yourself before `npm install` in frontend/: {rebuild}",
+            err=True,
+        )
+
+
+def _baseline_release() -> str:
+    """The newest release this karni-cli's changelog knows: what the scaffold is written for."""
+    from karni_cli.upgrades import changelog
+
+    try:
+        return changelog.newest_release(changelog.load())
+    except Exception:  # noqa: BLE001 - a missing changelog never blocks `karni new`
+        from karni_cli import __version__
+
+        return __version__
+
+
+def new(
+    name: str = typer.Argument(..., help="Project name (slug is derived from it)"),
+    output_dir: Path = typer.Option(Path("."), "--output-dir", "-o"),
+    domain: str = typer.Option("example.com", "--domain", help="Production domain for Caddy"),
+) -> None:
+    from cookiecutter.main import cookiecutter  # lazy: heavy import
+
+    slug = validate_name(name)
+    print_mark()
+    template = resolve_template()
+    ui_source = scaffold.resolve_ui_source()
+    if ui_source is not None:
+        prepare_ui_source(ui_source)
+    cookiecutter(
+        str(template),
+        no_input=True,
+        extra_context={
+            "project_name": name,
+            "domain": domain,
+            "karni_ui": (ui_spec := scaffold.ui_spec(ui_source, output_dir / slug)),
+            "karni_ui_mount": scaffold.ui_mount_target(ui_spec),
+            "karni_baseline": _baseline_release(),
+        },
+        output_dir=str(output_dir),
+    )
+    adapters = write_agent_adapters(output_dir / slug)
+    typer.echo(f"Created {output_dir / slug} ({adapters} agent adapter files)")
+    if ui_source is not None:
+        typer.echo(f"@karni/ui: {ui_spec} (local checkout)")
+    else:
+        typer.echo(
+            f"@karni/ui: {scaffold.UI_REGISTRY_SPEC} from npm — until it is published, "
+            "set KARNI_UI_SRC=/path/to/Karni/packages/karni-ui and re-run karni new."
+        )
+    typer.echo("Next steps:")
+    typer.echo(f"  cd {slug}")
+    typer.echo("  cp .env.example .env")
+    typer.echo("  docker compose up -d")
+    typer.echo(
+        "  (cd frontend && npm install)  # editor, lint, type-check and `karni check` on the host"
+    )
+    typer.echo("  karni check")

karni_cli/commands/routes.py

@@ -0,0 +1,20 @@
+"""``karni routes`` — every URL the project serves (``manage.py karni_routes``)."""
+
+from __future__ import annotations
+
+import typer
+
+from karni_cli import project as project_mod
+from karni_cli.project import require_project
+
+
+def routes(
+    as_json: bool = typer.Option(False, "--json", help="Print the routes as a JSON list."),
+    docker: bool | None = typer.Option(None, "--docker/--no-docker"),
+    service: str = typer.Option("django", "--service", envvar="KARNI_COMPOSE_SERVICE"),
+) -> None:
+    """List every URL: methods, name, view, model, access — wraps `manage.py karni_routes`."""
+    project = require_project()
+    args = ["karni_routes", *(["--json"] if as_json else [])]
+    proc = project_mod.run_manage(project, args, docker=docker, service=service, capture=False)
+    raise typer.Exit(proc.returncode)

karni_cli/commands/rules.py

@@ -0,0 +1,139 @@
+"""``karni rules`` — the conventions, file checks, and adapter sync.
+
+    karni rules                       conventions (code + one line each)
+    karni rules --explain K101        full statement, rationale, fix, enforcement
+    karni rules --procedure new-model the steps of a standard procedure
+    karni rules --check FILE...       static violations with fixes (exit 1 if any)
+    karni rules --json                the raw data (rules, procedures)
+    karni rules sync [--check] [--force]
+                                      regenerate AGENTS.md, CLAUDE.md, ... (CI: --check)
+
+Works without Django and, except ``sync``, without a project; inside one,
+``karni.rules.py`` overrides and ``.karni/modules/`` guidance apply.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import typer
+
+from karni_cli import agent_data
+from karni_cli.adapters import module_fragments, sync
+from karni_cli.project import CliError, find_project, require_project
+from karni_cli.rules_render import (
+    render_explain,
+    render_findings,
+    render_procedure,
+    render_prompts_doc,
+    render_rules,
+)
+
+rules_app = typer.Typer(
+    help="Karni's conventions for humans and AI agents (no Django needed).",
+    no_args_is_help=False,
+    add_completion=False,
+)
+
+
+def rules_text(project: Path | None) -> str:
+    data = agent_data.load(project)
+    return render_rules(data, module_fragments(project) if project else {})
+
+
+def check_text(paths: list[Path], project: Path | None) -> tuple[str, int]:
+    """Rendered findings and their count for ``paths``."""
+    missing = [str(p) for p in paths if not p.is_file()]
+    if missing:
+        raise CliError(f"No such file: {', '.join(missing)}", code="C010")
+    findings = agent_data.check(paths, project)
+    if not findings:
+        return f"ok: no violations in {len(paths)} file(s)", 0
+    return render_findings(findings), len(findings)
+
+
+@rules_app.callback(invoke_without_command=True)
+def rules(
+    ctx: typer.Context,
+    check: list[Path] | None = typer.Option(
+        None, "--check", help="Statically check FILE (repeatable); exit 1 on violations."
+    ),
+    explain: str | None = typer.Option(None, "--explain", help="Show one rule in full."),
+    procedure: str | None = typer.Option(None, "--procedure", help="Show a procedure's steps."),
+    as_json: bool = typer.Option(False, "--json", help="Machine-readable output."),
+    prompts_doc: bool = typer.Option(False, "--prompts-doc", hidden=True),
+) -> None:
+    if ctx.invoked_subcommand is not None:
+        return
+    project = find_project()
+    if check:
+        if as_json:
+            typer.echo(json.dumps(agent_data.check(list(check), project), indent=2))
+            return
+        text, count = check_text(list(check), project)
+        typer.echo(text)
+        raise typer.Exit(1 if count else 0)
+
+    data = agent_data.load(project)
+    if explain:
+        rule = data.rule(explain)
+        if rule is None:
+            raise CliError(f"No rule {explain!r} — `karni rules` lists the codes.", code="C204")
+        typer.echo(json.dumps(rule, indent=2) if as_json else render_explain(rule))
+        return
+    if procedure:
+        found = data.procedure(procedure)
+        if found is None:
+            names = ", ".join(p["name"] for p in data.procedures)
+            raise CliError(f"No procedure {procedure!r} (available: {names}).", code="C204")
+        typer.echo(json.dumps(found, indent=2) if as_json else render_procedure(found))
+        return
+    if prompts_doc:
+        typer.echo(render_prompts_doc(data))
+        return
+    if as_json:
+        typer.echo(json.dumps(data.raw, indent=2))
+        return
+    typer.echo(render_rules(data, module_fragments(project) if project else {}))
+
+
+@rules_app.command("sync")
+def sync_command(
+    check: bool = typer.Option(
+        False, "--check", help="Only compare; exit 1 if any adapter is stale (for CI)."
+    ),
+    force: bool = typer.Option(
+        False, "--force", help="Overwrite hand-written files (backed up under .karni/backup/)."
+    ),
+) -> None:
+    """Regenerate the agent adapter files from Karni's rule registry."""
+    project = require_project()
+    data = agent_data.load(project)
+    result = sync(project, data, check=check, force=force)
+    if check:
+        if result.stale:
+            for rel in result.stale:
+                typer.echo(f"stale: {rel}", err=True)
+            typer.echo("Agent adapters are stale — run `karni rules sync`.", err=True)
+            raise typer.Exit(1)
+        typer.echo(f"Agent adapters up to date ({len(result.unchanged)} files).")
+        return
+    for rel in result.backed_up:
+        typer.echo(f"backed up: {rel}")
+    for rel in result.written:
+        typer.echo(f"wrote {rel}")
+    for rel in result.removed:
+        typer.echo(f"removed {rel}")
+    if result.blocked:
+        for rel in result.blocked:
+            typer.echo(f"skipped {rel}: not generated by karni (hand-written?)", err=True)
+        typer.echo(
+            "Move project-specific guidance into karni.rules.py (`karni upgrade` does this "
+            "for Karni's old scaffold files), then re-run; or `--force` to overwrite with a "
+            "backup.",
+            err=True,
+        )
+        raise typer.Exit(1)
+    if not result.written and not result.removed:
+        typer.echo(f"Agent adapters up to date ({len(result.unchanged)} files).")

karni_cli/commands/run_tests.py

@@ -0,0 +1,38 @@
+"""``karni test`` — the project's test suite (pytest) through the project interpreter."""
+
+from __future__ import annotations
+
+import typer
+
+from karni_cli import project as project_mod
+from karni_cli.project import CliError, require_project
+
+
+def test(
+    args: list[str] | None = typer.Argument(
+        None, help="Passed to pytest: paths, -k EXPR, -x, --lf … (use -- before --help)."
+    ),
+    docker: bool | None = typer.Option(None, "--docker/--no-docker"),
+    service: str = typer.Option("django", "--service", envvar="KARNI_COMPOSE_SERVICE"),
+) -> None:
+    """Run the test suite — wraps `python -m pytest [ARGS]`."""
+    project = require_project()
+    probe = project_mod.run_python(
+        project, ["-c", "import pytest"], docker=docker, service=service, capture=True
+    )
+    if probe.returncode != 0 and "No module named" in (probe.stderr or ""):
+        raise CliError(
+            "pytest is not installed in the project interpreter, so `karni test` cannot run.\n"
+            "Install the project's dev group there: pip install pytest pytest-django "
+            "(or `uv sync`), then run karni test again.",
+            code="C011",
+        )
+    proc = project_mod.run_python(
+        project,
+        ["-m", "pytest", *(args or [])],
+        docker=docker,
+        service=service,
+        capture=False,
+        interactive=True,
+    )
+    raise typer.Exit(proc.returncode)

karni_cli/commands/schedule.py

@@ -0,0 +1,40 @@
+"""``karni schedule list|run`` — the merged beat schedules (``manage.py karni_schedules``)."""
+
+from __future__ import annotations
+
+import typer
+
+from karni_cli import project as project_mod
+from karni_cli.project import require_project
+
+schedule_app = typer.Typer(
+    help="Celery beat schedules — wraps `manage.py karni_schedules`.",
+    no_args_is_help=True,
+)
+
+
+@schedule_app.command("list")
+def list_schedules(
+    as_json: bool = typer.Option(False, "--json", help="Print the schedules as a JSON list."),
+    docker: bool | None = typer.Option(None, "--docker/--no-docker"),
+    service: str = typer.Option("django", "--service", envvar="KARNI_COMPOSE_SERVICE"),
+) -> None:
+    """List every schedule: name, task, timing, source — wraps `manage.py karni_schedules`."""
+    project = require_project()
+    args = ["karni_schedules", *(["--json"] if as_json else [])]
+    proc = project_mod.run_manage(project, args, docker=docker, service=service, capture=False)
+    raise typer.Exit(proc.returncode)
+
+
+@schedule_app.command("run")
+def run_schedule(
+    name: str = typer.Argument(..., help="The schedule name (see `karni schedule list`)."),
+    docker: bool | None = typer.Option(None, "--docker/--no-docker"),
+    service: str = typer.Option("django", "--service", envvar="KARNI_COMPOSE_SERVICE"),
+) -> None:
+    """Run one schedule's task now, synchronously — wraps `manage.py karni_schedules --run NAME`."""
+    project = require_project()
+    proc = project_mod.run_manage(
+        project, ["karni_schedules", "--run", name], docker=docker, service=service, capture=False
+    )
+    raise typer.Exit(proc.returncode)