krita-cli 1.0.0__py3-none-any.whl

krita_cli/commands/file_ops.py

@@ -0,0 +1,27 @@
+"""File operation CLI commands: open-file."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from typer import Context
+
+from krita_cli import _shared
+from krita_client import KritaError
+
+app = typer.Typer()
+
+
+@app.command("open-file")
+def open_file(
+    ctx: Context,
+    path: Annotated[str, typer.Argument(help="Full file path to open")],
+) -> None:
+    """Open an existing file in Krita (.kra, .png, .jpg, etc)."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.open_file(path=path)
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)

krita_cli/commands/health.py

@@ -0,0 +1,32 @@
+"""Health check CLI command."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from typer import Context
+
+from krita_cli import _shared
+from krita_client import KritaError
+
+console = Console()
+
+app = typer.Typer()
+
+
+@app.command()
+def health(ctx: Context) -> None:
+    """Check if Krita is running with the MCP plugin active."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.health()
+        plugin = result.get("plugin", "unknown")
+        status = result.get("status", "unknown")
+        version = result.get("version", "unknown")
+        protocol_version = result.get("protocol_version", "unknown")
+        console.print(
+            f"[green]Krita is running.[/green] Plugin: [bold]{plugin}[/bold] "
+            f"v{version} (protocol v{protocol_version}, {status})"
+        )
+    except KritaError as exc:
+        _shared._handle_error(exc)

krita_cli/commands/history_cmd.py

@@ -0,0 +1,64 @@
+"""History command CLI subcommand."""
+
+from __future__ import annotations
+
+import json
+from typing import Annotated, Any, cast
+
+import typer
+from rich.console import Console
+from rich.table import Table
+from typer import Context
+
+from krita_cli import _shared
+from krita_client import KritaError
+
+console = Console()
+
+app = typer.Typer()
+
+
+@app.command()
+def history(
+    ctx: Context,
+    limit: Annotated[int, typer.Option("--limit", "-n", help="Number of history entries to show")] = 20,
+    as_json: Annotated[bool, typer.Option("--json", "-j", help="Output as raw JSON")] = False,  # noqa: FBT002
+) -> None:
+    """View recent command execution history."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.get_command_history(limit=limit)
+
+        if as_json:
+            console.print(json.dumps(result, indent=2, default=str))
+            return
+
+        records_raw = result.get("history", [])
+        if not isinstance(records_raw, list):
+            records_raw = []
+        records = cast("list[dict[str, Any]]", records_raw)
+
+        if not records:
+            console.print("[dim]No command history recorded.[/dim]")
+            return
+
+        table = Table(title=f"Command History ({len(records)} entries)")
+        table.add_column("#", style="dim")
+        table.add_column("Action")
+        table.add_column("Status")
+        table.add_column("Duration (ms)")
+        table.add_column("Error", style="red")
+
+        for i, rec in enumerate(records, 1):
+            table.add_row(
+                str(i),
+                rec.get("action", "?"),
+                rec.get("status", "?"),
+                f"{rec.get('duration_ms', 0):.1f}",
+                rec.get("error", "") or "",
+            )
+
+        console.print(table)
+
+    except KritaError as exc:
+        _shared._handle_error(exc)

krita_cli/commands/introspect.py

@@ -0,0 +1,46 @@
+"""Canvas introspection CLI commands: canvas-info, current-color, current-brush."""
+
+from __future__ import annotations
+
+import typer
+from typer import Context
+
+from krita_cli import _shared
+from krita_client import KritaError
+
+console = _shared.console
+
+app = typer.Typer()
+
+
+@app.command("canvas-info")
+def canvas_info(ctx: Context) -> None:
+    """Get information about the current canvas."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.get_canvas_info()
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)
+
+
+@app.command("current-color")
+def current_color(ctx: Context) -> None:
+    """Get the current foreground and background colors."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.get_current_color()
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)
+
+
+@app.command("current-brush")
+def current_brush(ctx: Context) -> None:
+    """Get the current brush preset and properties."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.get_current_brush()
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)

krita_cli/commands/layers.py

@@ -0,0 +1,112 @@
+"""Layer-related CLI commands."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from typer import Context
+
+from krita_cli import _shared
+from krita_client import KritaError
+
+app = typer.Typer()
+
+
+@app.command("list")
+def list_layers(ctx: Context) -> None:
+    """List all layers in the current document."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.list_layers()
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)
+
+
+@app.command("create")
+def create_layer(
+    ctx: Context,
+    name: Annotated[str, typer.Option("--name", "-n", help="Layer name")] = "New Layer",
+    layer_type: Annotated[str, typer.Option("--type", "-t", help="Layer type")] = "paintlayer",
+) -> None:
+    """Create a new layer in the current document."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.create_layer(name=name, layer_type=layer_type)
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)
+
+
+@app.command("select")
+def select_layer(
+    ctx: Context,
+    name: Annotated[str, typer.Argument(help="Layer name to select")],
+) -> None:
+    """Select a layer by name."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.select_layer(name=name)
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)
+
+
+@app.command("delete")
+def delete_layer(
+    ctx: Context,
+    name: Annotated[str, typer.Argument(help="Layer name to delete")],
+) -> None:
+    """Delete a layer by name."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.delete_layer(name=name)
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)
+
+
+@app.command("rename")
+def rename_layer(
+    ctx: Context,
+    old_name: Annotated[str, typer.Argument(help="Current layer name")],
+    new_name: Annotated[str, typer.Argument(help="New layer name")],
+) -> None:
+    """Rename a layer."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.rename_layer(old_name=old_name, new_name=new_name)
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)
+
+
+@app.command("set-opacity")
+def set_layer_opacity(
+    ctx: Context,
+    name: Annotated[str, typer.Argument(help="Layer name")],
+    opacity: Annotated[float, typer.Option("--opacity", "-o", help="Opacity (0.0 to 1.0)")] = 1.0,
+) -> None:
+    """Set the opacity of a layer."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.set_layer_opacity(name=name, opacity=opacity)
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)
+
+
+@app.command("set-visibility")
+def set_layer_visibility(
+    ctx: Context,
+    name: Annotated[str, typer.Argument(help="Layer name")],
+    visible: Annotated[bool, typer.Option("--visible/--hidden", "-v/-h", help="Layer visibility")] = True,
+) -> None:
+    """Toggle the visibility of a layer."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.set_layer_visibility(name=name, visible=visible)
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)

krita_cli/commands/navigation.py

@@ -0,0 +1,33 @@
+"""Navigation-related CLI commands: undo, redo."""
+
+from __future__ import annotations
+
+import typer
+from typer import Context
+
+from krita_cli import _shared
+from krita_client import KritaError
+
+app = typer.Typer()
+
+
+@app.command()
+def undo(ctx: Context) -> None:
+    """Undo the last action."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.undo()
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)
+
+
+@app.command()
+def redo(ctx: Context) -> None:
+    """Redo the last undone action."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.redo()
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)

krita_cli/commands/replay.py

@@ -0,0 +1,126 @@
+"""Replay command CLI subcommand."""
+
+from __future__ import annotations
+
+import json
+import pathlib
+import time
+from typing import Annotated, Any, cast
+
+import typer
+from rich.console import Console
+from typer import Context
+
+from krita_cli import _shared
+from krita_client import KritaError
+
+console = Console()
+
+app = typer.Typer()
+
+
+def _validate_records(records: list[dict]) -> None:
+    """Validate that all records have required 'action' field."""
+    for i, rec in enumerate(records, 1):
+        action = rec.get("action")
+        if not action:
+            console.print(f"  [red]#{i}: Missing 'action' field[/red]")
+            raise typer.Exit(code=1)
+
+
+def _execute_replay(
+    ctx: Context,
+    records: list[dict],
+    speed: float,
+) -> None:
+    """Execute recorded commands via the client."""
+    client = _shared._get_client(ctx)
+    ok_count = 0
+    err_count = 0
+
+    for i, rec in enumerate(records, 1):
+        action = rec.get("action")
+        params = rec.get("params", {})
+
+        if not action:
+            console.print(f"  [red]#{i}: Skipping — missing 'action'[/red]")
+            err_count += 1
+            continue
+
+        if speed > 0:
+            original_ms = rec.get("duration_ms", 0) / 1000.0
+            delay = original_ms / speed
+            if delay > 0:
+                time.sleep(delay)
+
+        try:
+            result = client.send_command(action, params)
+            if "error" in result:
+                err_raw = result.get("error", {})
+                if isinstance(err_raw, dict):
+                    err_dict = cast("dict[str, Any]", err_raw)
+                    err_msg = str(err_dict.get("message", str(err_raw)))
+                else:
+                    err_msg = str(err_raw)
+                console.print(f"  [red]#{i}: {action} — {err_msg}[/red]")
+                err_count += 1
+            else:
+                ok_count += 1
+        except KritaError as exc:
+            console.print(f"  [red]#{i}: {action} — {exc}[/red]")
+            err_count += 1
+
+    console.print(f"\nReplay complete: {ok_count} succeeded, {err_count} failed out of {len(records)}")
+
+
+@app.command()
+def replay(
+    ctx: Context,
+    file: Annotated[
+        str,
+        typer.Argument(help="JSON file with recorded commands"),
+    ],
+    speed: Annotated[
+        float,
+        typer.Option("--speed", "-s", help="Playback speed (0.0=instant, 1.0=original)"),
+    ] = 1.0,
+    dry_run: Annotated[  # noqa: FBT002
+        bool,
+        typer.Option("--dry-run", "-n", help="Validate without executing"),
+    ] = False,
+) -> None:
+    """Replay commands from a JSON file.
+
+    The JSON file should contain an array of command records from
+    'krita history --json', each with an "action" and optional "params" key.
+
+    Example:
+        krita history --json > history.json
+        krita replay history.json
+        krita replay history.json --speed 0.5
+        krita replay history.json --dry-run
+    """
+    path = pathlib.Path(file)
+    try:
+        records = json.loads(path.read_text())
+    except json.JSONDecodeError as exc:
+        console.print(f"[red]Error:[/red] Invalid JSON in {path}: {exc}")
+        raise typer.Exit(code=1) from exc
+    except OSError as exc:
+        console.print(f"[red]Error:[/red] Cannot read {path}: {exc}")
+        raise typer.Exit(code=1) from exc
+
+    if not isinstance(records, list):
+        console.print("[red]Error:[/red] JSON file must contain an array.")
+        raise typer.Exit(code=1)
+
+    if dry_run:
+        console.print(f"[dim]Dry run: validating {len(records)} records[/dim]")
+        _validate_records(records)
+        console.print(f"[green]All {len(records)} records are valid.[/green]")
+        return
+
+    try:
+        _execute_replay(ctx, records, speed)
+    except KritaError as exc:
+        _shared._handle_error(exc)

krita_cli/commands/rollback.py

@@ -0,0 +1,39 @@
+"""Rollback CLI command."""
+
+from __future__ import annotations
+
+from typing import Annotated
+
+import typer
+from rich.console import Console
+from typer import Context
+
+from krita_cli import _shared
+from krita_client import KritaError
+
+console = Console()
+
+app = typer.Typer()
+
+
+@app.command()
+def rollback(
+    ctx: Context,
+    batch_id: Annotated[str, typer.Argument(help="ID of the batch to roll back")],
+) -> None:
+    """Roll back a previously executed batch.
+
+    This restores the canvas to its state before the specified batch was executed.
+    Note that snapshots are kept in memory and are lost if the Krita plugin is restarted.
+    """
+    try:
+        client = _shared._get_client(ctx)
+        result = client.rollback(batch_id=batch_id)
+        status = result.get("status", "unknown")
+        msg = result.get("message", "")
+        if status == "ok":
+            console.print(f"[green]Rollback successful: {msg}[/green]")
+        else:
+            console.print(f"[red]Rollback failed: {msg}[/red]")
+    except KritaError as exc:
+        _shared._handle_error(exc)