krita-cli 1.0.0__py3-none-any.whl

krita_cli/commands/selection.py

@@ -0,0 +1,364 @@
+from __future__ import annotations
+
+from typing import Annotated, Any, cast
+
+import typer
+from rich.console import Console
+from typer import Context
+
+from krita_cli import _shared
+
+app = typer.Typer()
+console = Console()
+
+
+@app.command("select-rect")
+def select_rect(
+    ctx: Context,
+    x: int,
+    y: int,
+    width: int,
+    height: int,
+) -> None:
+    """Select a rectangular area."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.select_rect(x=x, y=y, width=width, height=height)
+        _shared._print_result(result, f"Selected rectangle {width}x{height} at ({x}, {y})")
+
+
+@app.command("select-ellipse")
+def select_ellipse(
+    ctx: Context,
+    cx: int,
+    cy: int,
+    rx: int,
+    ry: int,
+) -> None:
+    """Select an elliptical area."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.select_ellipse(cx=cx, cy=cy, rx=rx, ry=ry)
+        _shared._print_result(result, f"Selected ellipse at ({cx}, {cy}) with radii {rx}x{ry}")
+
+
+@app.command("select-polygon")
+def select_polygon(
+    ctx: Context,
+    points: list[str],
+) -> None:
+    """Select a polygonal area. Points as 'x,y' pairs (min 3)."""
+    parsed: list[list[int]] = []
+    for pt in points:
+        parts = pt.split(",")
+        if len(parts) != 2:
+            console.print(f"[red]Error:[/red] Invalid point format: {pt!r}. Use 'x,y'.")
+            raise typer.Exit(code=1)
+        try:
+            parsed.append([int(parts[0]), int(parts[1])])
+        except ValueError:
+            console.print(f"[red]Error:[/red] Invalid point coordinates: {pt!r}. Values must be integers.")
+            raise typer.Exit(code=1) from None
+
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.select_polygon(points=parsed)
+        _shared._print_result(result, f"Selected polygon with {len(parsed)} points")
+
+
+@app.command("select-area")
+def select_area_compat(
+    ctx: Context,
+    x: int,
+    y: int,
+    width: int,
+    height: int,
+) -> None:
+    """Select a rectangular area.
+
+    Deprecated: prefer `krita select-rect` instead. This alias will be
+    removed in a future release.
+    """
+    select_rect(ctx, x, y, width, height)
+
+
+@app.command("select-clear")
+def clear_selection(ctx: Context) -> None:
+    """Clear the content of the current selection."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.clear_selection()
+        _shared._print_result(result, "Cleared selection")
+
+
+@app.command("select-invert")
+def invert_selection(ctx: Context) -> None:
+    """Invert the current selection."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.invert_selection()
+        _shared._print_result(result, "Inverted selection")
+
+
+@app.command("select-fill")
+def fill_selection(ctx: Context) -> None:
+    """Fill the current selection with foreground color."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.fill_selection()
+        _shared._print_result(result, "Filled selection")
+
+
+@app.command("select-info")
+def selection_info(ctx: Context) -> None:
+    """Get information about the current selection."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.selection_info()
+        if result.get("has_selection"):
+            bounds_raw = result.get("bounds", {})
+            if not isinstance(bounds_raw, dict):
+                bounds_raw = {}
+            bounds = cast("dict[str, Any]", bounds_raw)
+            console.print(
+                f"[green]Active selection:[/green] x={bounds.get('x')}, y={bounds.get('y')}, "
+                f"w={bounds.get('width')}, h={bounds.get('height')}"
+            )
+        else:
+            console.print("[dim]No active selection[/dim]")
+
+
+@app.command("deselect")
+def deselect(ctx: Context) -> None:
+    """Remove the current selection."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.deselect()
+        _shared._print_result(result, "Deselected")
+
+
+@app.command("select-by-color")
+def select_by_color(
+    ctx: Context,
+    *,
+    x: Annotated[int | None, typer.Option("--x", "-x", help="X coordinate for magic wand (omit for global)")] = None,
+    y: Annotated[int | None, typer.Option("--y", "-y", help="Y coordinate for magic wand (omit for global)")] = None,
+    tolerance: Annotated[
+        float, typer.Option("--tolerance", "-t", help="Color tolerance (0.0-1.0)", min=0.0, max=1.0)
+    ] = 0.1,
+    contiguous: Annotated[
+        bool, typer.Option("--contiguous/--global", "-c/-g", help="Contiguous (magic wand) or global selection")
+    ] = True,
+) -> None:
+    """Select pixels by color similarity (magic wand or global)."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.select_by_color(x=x, y=y, tolerance=tolerance, contiguous=contiguous)
+        method = "Magic wand" if contiguous else "Global"
+        count = result.get("selected_count", 0)
+        _shared._print_result(result, f"{method} color selection: {count} pixels (tolerance={tolerance})")
+
+
+@app.command("select-by-alpha")
+def select_by_alpha(
+    ctx: Context,
+    min_alpha: Annotated[int, typer.Option("--min", help="Minimum alpha value (0-255)", min=0, max=255)] = 1,
+    max_alpha: Annotated[int, typer.Option("--max", help="Maximum alpha value (0-255)", min=0, max=255)] = 255,
+) -> None:
+    """Select pixels by alpha value range."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.select_by_alpha(min_alpha=min_alpha, max_alpha=max_alpha)
+        count = result.get("selected_count", 0)
+        _shared._print_result(result, f"Alpha selection: {count} pixels (alpha={min_alpha}-{max_alpha})")
+
+
+@app.command("transform-selection")
+def transform_selection(
+    ctx: Context,
+    dx: Annotated[int, typer.Option("--dx", help="Horizontal offset")] = 0,
+    dy: Annotated[int, typer.Option("--dy", help="Vertical offset")] = 0,
+    angle: Annotated[float, typer.Option("--angle", "-a", help="Rotation angle in degrees")] = 0.0,
+    scale_x: Annotated[float, typer.Option("--scale-x", help="Horizontal scale factor")] = 1.0,
+    scale_y: Annotated[float, typer.Option("--scale-y", help="Vertical scale factor")] = 1.0,
+) -> None:
+    """Transform the current selection (move, rotate, scale)."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.transform_selection(dx=dx, dy=dy, angle=angle, scale_x=scale_x, scale_y=scale_y)
+        _shared._print_result(result, f"Transformed selection (dx={dx}, dy={dy}, angle={angle}°)")
+
+
+@app.command("grow-selection")
+def grow_selection(
+    ctx: Context,
+    pixels: Annotated[int, typer.Argument(help="Pixels to grow")],
+) -> None:
+    """Grow the current selection outward."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.grow_selection(pixels)
+        _shared._print_result(result, f"Grew selection by {pixels}px")
+
+
+@app.command("shrink-selection")
+def shrink_selection(
+    ctx: Context,
+    pixels: Annotated[int, typer.Argument(help="Pixels to shrink")],
+) -> None:
+    """Shrink the current selection inward."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.shrink_selection(pixels)
+        _shared._print_result(result, f"Shrunk selection by {pixels}px")
+
+
+@app.command("border-selection")
+def border_selection(
+    ctx: Context,
+    pixels: Annotated[int, typer.Argument(help="Border width in pixels")],
+) -> None:
+    """Create a border selection around the current selection."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.border_selection(pixels)
+        _shared._print_result(result, f"Created {pixels}px border around selection")
+
+
+@app.command("save-selection")
+def save_selection(
+    ctx: Context,
+    path: Annotated[str, typer.Argument(help="Path to save selection mask (PNG)")],
+) -> None:
+    """Save current selection as a PNG mask image."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.save_selection(path=path)
+        _shared._print_result(result, f"Saved selection to {path}")
+
+
+@app.command("load-selection")
+def load_selection(
+    ctx: Context,
+    path: Annotated[str, typer.Argument(help="Path to selection mask (PNG)")],
+) -> None:
+    """Load selection from a PNG mask image (white=selected, black=unselected)."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.load_selection(path=path)
+        _shared._print_result(result, f"Loaded selection from {path}")
+
+
+@app.command("selection-stats")
+def selection_stats(ctx: Context) -> None:
+    """Get statistics about current selection (pixel count, centroid, bounding box)."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.selection_stats()
+        count = result.get("pixel_count", 0)
+        bbox_raw = result.get("bounding_box", {})
+        if not isinstance(bbox_raw, dict):
+            bbox_raw = {}
+        bbox = cast("dict[str, Any]", bbox_raw)
+
+        console.print("[green]Selection Statistics:[/green]")
+        console.print(f"  Pixel count: [bold]{count}[/bold]")
+        if bbox:
+            console.print(
+                f"  Bounding box: x={bbox.get('x', '?')}, y={bbox.get('y', '?')}, "
+                f"w={bbox.get('width', '?')}, h={bbox.get('height', '?')}"
+            )
+        centroid_raw = result.get("centroid", {})
+        if not isinstance(centroid_raw, dict):
+            centroid_raw = {}
+        centroid = cast("dict[str, Any]", centroid_raw)
+
+        if centroid:
+            console.print(f"  Centroid: ({centroid.get('x', '?')}, {centroid.get('y', '?')})")
+        area_pct = result.get("area_percentage")
+        if area_pct is not None:
+            pct = float(cast("Any", area_pct))
+            console.print(f"  Area: {pct:.1f}% of canvas")
+
+
+@app.command("save-channel")
+def save_channel(
+    ctx: Context,
+    name: Annotated[str, typer.Argument(help="Name for the selection channel")],
+) -> None:
+    """Save current selection as a named channel."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.save_selection_channel(name=name)
+        _shared._print_result(result, f"Saved selection channel '{name}'")
+
+
+@app.command("load-channel")
+def load_channel(
+    ctx: Context,
+    name: Annotated[str, typer.Argument(help="Name of the selection channel to load")],
+) -> None:
+    """Load a named selection channel."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.load_selection_channel(name=name)
+        _shared._print_result(result, f"Loaded selection channel '{name}'")
+
+
+@app.command("list-channels")
+def list_channels(ctx: Context) -> None:
+    """List all saved selection channels."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.list_selection_channels()
+        channels_raw = result.get("channels", [])
+        if not isinstance(channels_raw, list):
+            channels_raw = []
+        channels = cast("list[dict[str, Any]]", channels_raw)
+
+        count = result.get("count", 0)
+        if count == 0:
+            console.print("[dim]No saved selection channels[/dim]")
+        else:
+            console.print(f"[green]Selection Channels ({count}):[/green]")
+            for ch in channels:
+                console.print(f"  - [bold]{ch.get('name', '?')}[/bold]")
+
+
+@app.command("delete-channel")
+def delete_channel(
+    ctx: Context,
+    name: Annotated[str, typer.Argument(help="Name of the selection channel to delete")],
+) -> None:
+    """Delete a saved selection channel."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.delete_selection_channel(name=name)
+        _shared._print_result(result, f"Deleted selection channel '{name}'")
+
+
+@app.command("security-status")
+def security_status(ctx: Context) -> None:
+    """Show current security limits and usage."""
+    client = _shared._get_client(ctx)
+    with _shared._handle_errors():
+        result = client.get_security_status()
+        rl_raw = result.get("rate_limit", {})
+        if not isinstance(rl_raw, dict):
+            rl_raw = {}
+        rl = cast("dict[str, Any]", rl_raw)
+
+        payload_limit = result.get("payload_limit", 0)
+        if not isinstance(payload_limit, (int, float)):
+            payload_limit = 0
+
+        console.print("[green]Security Status:[/green]")
+        console.print(
+            f"  Rate limit: [dim]{rl.get('current_usage', 0)}/{rl.get('max_commands_per_minute', '?')} per minute[/dim]"
+        )
+        console.print(f"  Payload limit: [dim]{float(payload_limit) / (1024 * 1024):.0f}MB[/dim]")
+        console.print(f"  Batch limit: [dim]{result.get('batch_size_limit', '?')} commands[/dim]")
+        console.print(
+            f"  Max canvas: [dim]{result.get('max_canvas_dim', '?')}x{result.get('max_canvas_dim', '?')}[/dim]"
+        )
+        console.print(f"  Max layers: [dim]{result.get('max_layers', '?')}[/dim]")

krita_cli/commands/stroke.py

@@ -0,0 +1,101 @@
+"""Stroke-related CLI commands: stroke, fill, draw-shape."""
+
+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 stroke(
+    ctx: Context,
+    points: Annotated[list[str], typer.Argument(help="Points as 'x,y' pairs (need at least 2)")],
+    pressure: Annotated[float, typer.Option("--pressure", help="Brush pressure (0.0-1.0)")] = 1.0,
+    size: Annotated[int | None, typer.Option("--size", "-s", help="Brush size in pixels")] = None,
+    hardness: Annotated[float, typer.Option("--hardness", help="Stroke hardness (0.0-1.0)")] = 0.5,
+    opacity: Annotated[float, typer.Option("--opacity", "-o", help="Stroke opacity (0.0-1.0)")] = 1.0,
+) -> None:
+    """Paint a stroke through a series of points."""
+    parsed_points: list[list[int]] = []
+    for pt in points:
+        parts = pt.split(",")
+        if len(parts) != 2:
+            console.print(f"[red]Error:[/red] Invalid point format: {pt!r}. Use 'x,y'.")
+            raise typer.Exit(code=1)
+        try:
+            parsed_points.append([int(parts[0]), int(parts[1])])
+        except ValueError:
+            console.print(f"[red]Error:[/red] Invalid point coordinates: {pt!r}. Values must be integers.")
+            raise typer.Exit(code=1) from None
+
+    try:
+        client = _shared._get_client(ctx)
+        result = client.stroke(
+            points=parsed_points,
+            pressure=pressure,
+            size=size,
+            hardness=hardness,
+            opacity=opacity,
+        )
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)
+
+
+@app.command()
+def fill(
+    ctx: Context,
+    x: Annotated[int, typer.Argument(help="X coordinate")],
+    y: Annotated[int, typer.Argument(help="Y coordinate")],
+    radius: Annotated[int, typer.Option("--radius", "-r", help="Fill radius in pixels")] = 50,
+) -> None:
+    """Fill a circular area with the current color."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.fill(x=x, y=y, radius=radius)
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)
+
+
+@app.command("draw-shape")
+def draw_shape(
+    ctx: Context,
+    shape: Annotated[str, typer.Argument(help="Shape type: rectangle, ellipse, or line")],
+    x: Annotated[int, typer.Argument(help="X coordinate")],
+    y: Annotated[int, typer.Argument(help="Y coordinate")],
+    width: Annotated[int, typer.Option("--width", "-W", help="Width")] = 100,
+    height: Annotated[int, typer.Option("--height", "-H", help="Height")] = 100,
+    *,
+    fill: Annotated[bool, typer.Option("--fill/--no-fill", help="Fill the shape")] = True,
+    stroke: Annotated[bool, typer.Option("--stroke/--no-stroke", help="Draw outline")] = False,
+    x2: Annotated[int | None, typer.Option("--x2", help="End X for lines")] = None,
+    y2: Annotated[int | None, typer.Option("--y2", help="End Y for lines")] = None,
+) -> None:
+    """Draw a shape on the canvas."""
+    try:
+        client = _shared._get_client(ctx)
+        result = client.draw_shape(
+            shape=shape,
+            x=x,
+            y=y,
+            width=width,
+            height=height,
+            fill=fill,
+            stroke=stroke,
+            x2=x2,
+            y2=y2,
+        )
+        _shared._format_result(result)
+    except KritaError as exc:
+        _shared._handle_error(exc)

krita_cli/config_cmd.py

@@ -0,0 +1,68 @@
+"""Plugin configuration management.
+
+Provides functions to load, save, and modify plugin configuration stored in
+``~/.krita-cli/config.json``.  The plugin reads this file on startup so that
+CLI changes persist across Krita restarts.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+CONFIG_DIR = Path.home() / ".krita-cli"
+CONFIG_FILE = CONFIG_DIR / "config.json"
+
+DEFAULTS: dict[str, Any] = {
+    "port": 5678,
+    "canvas_output_dir": "~/krita-mcp-output",
+    "default_timeout": 30.0,
+    "export_timeout": 120.0,
+    "max_canvas_dim": 8192,
+    "max_batch_size": 50,
+    "max_layers": 100,
+    "max_commands_per_minute": 60,
+}
+
+
+def load_config() -> dict[str, Any]:
+    """Load plugin configuration from disk, falling back to defaults."""
+    if CONFIG_FILE.exists():
+        try:
+            return json.loads(CONFIG_FILE.read_text(encoding="utf-8"))
+        except json.JSONDecodeError:
+            # Config file is corrupted; fall back to defaults
+            return dict(DEFAULTS)
+    return dict(DEFAULTS)
+
+
+def save_config(config: dict[str, Any]) -> None:
+    """Persist *config* to disk, creating the config directory if needed."""
+    CONFIG_DIR.mkdir(parents=True, exist_ok=True)
+    CONFIG_FILE.write_text(json.dumps(config, indent=2), encoding="utf-8")
+
+
+def set_key(key: str, value: str) -> None:
+    """Set a single configuration *key* to *value* with type coercion.
+
+    Raises ``ValueError`` if *key* is not recognised.
+    """
+    if key not in DEFAULTS:
+        raise ValueError(f"Unknown config key: {key}")
+    config = load_config()
+    default = DEFAULTS[key]
+    if isinstance(default, int):
+        config[key] = int(value)
+    elif isinstance(default, float):
+        config[key] = float(value)
+    else:
+        config[key] = value
+    save_config(config)
+
+
+def reset_config() -> dict[str, Any]:
+    """Reset configuration to defaults and persist them."""
+    defaults = dict(DEFAULTS)
+    save_config(defaults)
+    return defaults