krita-cli 1.0.0__py3-none-any.whl

krita_cli/history.py

@@ -0,0 +1,198 @@
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from krita_client import ClientConfig, KritaClient, KritaError
+
+SYSTEM_HISTORY_DIR = Path.home() / ".krita-cli"
+SYSTEM_HISTORY_FILE = SYSTEM_HISTORY_DIR / "history.log"
+
+
+class CommandHistory:
+    """Manages command history recording and replay."""
+
+    def __init__(self) -> None:
+        self._history: list[dict[str, Any]] = []
+        self._recording_enabled: bool = False
+        self._history_file: Path | None = None
+
+    def enable_recording(self, file_path: str | Path | None = None) -> None:
+        """Enable command recording, optionally persisting to a file."""
+        self._recording_enabled = True
+        self._history_file = Path(file_path) if file_path else None
+
+    def disable_recording(self) -> None:
+        """Disable command recording."""
+        self._recording_enabled = False
+
+    def is_recording(self) -> bool:
+        """Return whether recording is currently enabled."""
+        return self._recording_enabled
+
+    def _append_to_system_log(self, entry: dict[str, Any]) -> None:
+        """Append a command entry to the systemic history log (JSONL)."""
+        try:
+            SYSTEM_HISTORY_DIR.mkdir(parents=True, exist_ok=True)
+            log_entry = {
+                "timestamp": datetime.now(UTC).isoformat(),
+                **entry,
+            }
+            with SYSTEM_HISTORY_FILE.open("a", encoding="utf-8") as f:
+                f.write(json.dumps(log_entry) + "\n")
+        except Exception:
+            # Persistent logging should not crash the CLI if it fails (e.g. permission issues)
+            pass
+
+    def record_command(
+        self,
+        action: str,
+        params: dict[str, Any] | None,
+        result: dict[str, Any] | None,
+    ) -> None:
+        """Record a command invocation to the in-memory history."""
+        entry: dict[str, Any] = {
+            "action": action,
+            "params": params or {},
+            "result": result,
+        }
+        self._history.append(entry)
+        self._append_to_system_log(entry)
+
+        if self._recording_enabled and self._history_file is not None:
+            try:
+                self._history_file.parent.mkdir(parents=True, exist_ok=True)
+                self._history_file.write_text(json.dumps(self._history, indent=2))
+            except Exception:
+                # Persistent history write should not crash the CLI
+                pass
+
+    def get_history(self) -> list[dict[str, Any]]:
+        """Return the current command history."""
+        return list(self._history)
+
+    def clear_history(self) -> None:
+        """Clear the in-memory history."""
+        self._history.clear()
+
+    def load_history(self, file_path: str | Path) -> list[dict[str, Any]]:
+        """Load command history from a JSON file or JSONL log."""
+        path = Path(file_path)
+        if not path.exists():
+            return []
+
+        content = path.read_text(encoding="utf-8").strip()
+        if not content:
+            return []
+
+        # Try parsing as JSONL first (system log)
+        if content.startswith("{") and "\n" in content:
+            return [json.loads(line) for line in content.splitlines() if line.strip()]
+
+        # Fallback to standard JSON array
+        data = json.loads(content)
+        if not isinstance(data, list):
+            return []
+        return data
+
+    def rollback_batch(self, count: int, client: KritaClient) -> list[dict[str, Any]]:
+        """Rollback the last N operations by calling undo."""
+        results: list[dict[str, Any]] = []
+        for i in range(count):
+            try:
+                result = client.undo()
+                results.append({"action": "undo", "status": "ok", "iteration": i + 1, "result": result})
+            except KritaError as exc:
+                results.append({"action": "undo", "status": "error", "iteration": i + 1, "error": exc.message})
+        return results
+
+    def replay_commands(
+        self,
+        file_path: str | Path | None = None,
+        client: KritaClient | None = None,
+    ) -> list[dict[str, Any]]:
+        """Replay recorded commands against a Krita client.
+
+        If *file_path* is given, load history from that file.
+        Otherwise replay the in-memory history.
+
+        Returns a list of results (one per command).
+        """
+        commands = self.load_history(file_path) if file_path is not None else self.get_history()
+
+        if client is None:
+            client = KritaClient(ClientConfig())
+
+        results: list[dict[str, Any]] = []
+        for entry in commands:
+            action = entry["action"]
+            params = entry.get("params", {})
+            try:
+                result = client.send_command(action, params)
+                status = result.get("status", "ok")
+                results.append({"action": action, "status": status, "result": result})
+            except KritaError as exc:
+                results.append({"action": action, "status": "error", "error": exc.message})
+
+        return results
+
+
+# Module-level singleton for backward compatibility
+_history = CommandHistory()
+
+
+def enable_recording(file_path: str | Path | None = None) -> None:
+    """Enable command recording, optionally persisting to a file."""
+    _history.enable_recording(file_path)
+
+
+def disable_recording() -> None:
+    """Disable command recording."""
+    _history.disable_recording()
+
+
+def is_recording() -> bool:
+    """Return whether recording is currently enabled."""
+    return _history.is_recording()
+
+
+def record_command(
+    action: str,
+    params: dict[str, Any] | None,
+    result: dict[str, Any] | None,
+) -> None:
+    """Record a command invocation to the in-memory history."""
+    _history.record_command(action, params, result)
+
+
+def get_history() -> list[dict[str, Any]]:
+    """Return the current command history."""
+    return _history.get_history()
+
+
+def clear_history() -> None:
+    """Clear the in-memory history."""
+    _history.clear_history()
+
+
+def load_history(file_path: str | Path) -> list[dict[str, Any]]:
+    """Load command history from a JSON file."""
+    return _history.load_history(file_path)
+
+
+def replay_commands(
+    file_path: str | Path | None = None,
+    client: KritaClient | None = None,
+) -> list[dict[str, Any]]:
+    """Replay recorded commands against a Krita client."""
+    return _history.replay_commands(file_path=file_path, client=client)
+
+
+def rollback_batch(count: int, client: KritaClient) -> list[dict[str, Any]]:
+    """Rollback the last N operations by calling undo."""
+    return _history.rollback_batch(count, client)
+
+
+def get_system_log_path() -> Path:
+    """Return the path to the systemic history log."""
+    return SYSTEM_HISTORY_FILE

krita_cli-1.0.0.dist-info/METADATA

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: krita-cli
+Version: 1.0.0
+Summary: SOTA CLI + MCP server for programmatic painting in Krita
+Project-URL: Homepage, https://github.com/github/krita-cli
+Project-URL: Repository, https://github.com/github/krita-cli
+Project-URL: Issues, https://github.com/github/krita-cli/issues
+Project-URL: Changelog, https://github.com/github/krita-cli/blob/master/CHANGELOG.md
+Author: Krita MCP Contributors
+License-Expression: MIT
+License-File: LICENSE
+Keywords: ai,automation,claude,cli,fastmcp,krita,mcp,painting
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Multimedia :: Graphics :: Editors :: Raster-Based
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Requires-Dist: fastmcp>=3.1.0
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: rich>=13.0.0
+Requires-Dist: typer>=0.9.0
+Provides-Extra: dev
+Requires-Dist: beartype>=0.18.0; extra == 'dev'
+Provides-Extra: numpy
+Requires-Dist: numpy>=1.26.0; extra == 'numpy'
+Description-Content-Type: text/markdown
+
+# Krita MCP Server & CLI
+
+Let AI agents paint in [Krita](https://krita.org/) via the [Model Context Protocol](https://modelcontextprotocol.io/).
+
+This subproject provides the core implementation of the Krita-MCP ecosystem, including the FastMCP server, the `krita` CLI, and the high-performance Python plugin.
+
+## 🛠️ Components
+
+1. **Krita Plugin** (`krita-plugin/`) — A Python plugin for Krita that exposes a thread-safe HTTP server on `localhost:5678`.
+2. **MCP Server** (`src/krita_mcp/`) — A FastMCP server exposing 40+ painting and manipulation tools.
+3. **Krita CLI** (`src/krita_cli/`) — A Typer-based command line interface for human operators.
+4. **Krita Client** (`src/krita_client/`) — A reusable, fully-typed Python library for Krita automation.
+
+## 🚀 Setup
+
+### 1. Krita Plugin Installation
+Copy the contents of `krita-plugin/` to your Krita resources:
+- **Windows**: `%APPDATA%\krita\pykrita\`
+- **Linux**: `~/.local/share/krita/pykrita/`
+- **macOS**: `~/Library/Application Support/krita/pykrita/`
+
+Enable **"Krita MCP Bridge"** in Krita (Configure Krita → Python Plugin Manager) and restart.
+
+### 2. Environment Setup
+```bash
+# Install dependencies with uv
+uv sync
+```
+
+## 🔧 CLI Commands
+
+The `krita` CLI is grouped into logical subcommands:
+
+- **Painting**: `stroke`, `fill`, `clear`, `draw-shape`
+- **Layers**: `layers list`, `layers create`, `layers select`, `layers delete`
+- **Selection**: `selection select-rect`, `selection transform`, `selection save-channel`
+- **Canvas**: `canvas-info`, `current-color`, `current-brush`
+- **Session**: `history`, `replay`, `rollback`, `batch`
+- **System**: `health`, `config`, `capabilities`, `security-status`
+
+Run `uv run krita --help` for full details.
+
+## 🤖 MCP Server Tools (40 Total)
+
+The MCP server exposes a vast range of capabilities to AI agents:
+
+| Category | Key Tools |
+|----------|-----------|
+| **Core** | `krita_health`, `krita_new_canvas`, `krita_save`, `krita_open_file` |
+| **Painting** | `krita_stroke`, `krita_fill`, `krita_draw_shape`, `krita_set_color`, `krita_set_brush` |
+| **Selection** | `krita_select_rect`, `krita_select_ellipse`, `krita_select_polygon`, `krita_select_by_color`, `krita_select_by_alpha` |
+| **Selection Ops** | `krita_transform_selection`, `krita_grow_selection`, `krita_combine_selections`, `krita_invert_selection` |
+| **Persistence** | `krita_save_selection`, `krita_load_selection`, `krita_save_selection_channel`, `krita_list_selection_channels` |
+| **Automation** | `krita_batch`, `krita_rollback`, `krita_get_command_history` |
+| **Inspection** | `krita_get_canvas_info`, `krita_get_color_at`, `krita_selection_stats`, `krita_security_status` |
+
+## ⚡ Performance
+
+The plugin uses **numpy-accelerated** direct pixel manipulation for rendering. This ensures that strokes and shapes are rendered significantly faster than standard Python loops, especially on high-resolution canvases.
+
+## 🔒 Security
+
+Krita MCP includes a built-in security layer to protect your system:
+- **Path Sanitization**: Restricts file operations to allowed directories.
+- **Resource Limits**: Prevents OOM by limiting max canvas dimensions and layer counts.
+- **Rate Limiting**: Throttles rapid command execution.
+- **Security Tool**: `krita_security_status` allows agents to check active limits.
+
+## 📄 License
+MIT

krita_cli-1.0.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+krita_cli/__init__.py,sha256=TYbvkpB_Ps1X-ewTEVeBEQt8Ab5K6e7gyJVkKFB1K8I,106
+krita_cli/_shared.py,sha256=rZ_WvpHZxLAFlQIxaIvAmJFoh-gjjjX6OMb67s2adUM,3287
+krita_cli/app.py,sha256=BPOLTznFbgCzGllRm5SRlhV-LJtduBRSXe1ev4gkikQ,3760
+krita_cli/cli.py,sha256=1-2URcrjosJCe0tFAt_R6HXUhPDc2FNvFqf3_u-RJyE,904
+krita_cli/config_cmd.py,sha256=ql0fHc8Ve7ahQf59oNXpqsf5fdtil2mjLy2FI9orbGw,2013
+krita_cli/history.py,sha256=F0K_9739kGium7uqVUMQvRwWPOxT3Iw5lNk9JLlypzc,6722
+krita_cli/commands/__init__.py,sha256=ke2w9d8hQ7_h85DmKwvcVEiyLoMCvkTiKafzdMGlBjA,36
+krita_cli/commands/batch.py,sha256=PU1sHbC5X33NRHO7CBl03y2wwNtjmTr9iJErIfoQZ5w,3323
+krita_cli/commands/brush.py,sha256=gwJewjlVifcBGsl05bp8mbH5gGeDUkzuPanhgW_hF1A,1978
+krita_cli/commands/call.py,sha256=z4QGXeGbdOngxxrYCtlh5cdrPOfgya22za-P4yQcO6c,1352
+krita_cli/commands/canvas.py,sha256=ILBtjTrpO7eEbDsKN2KGr_WaRAJbsEhZqy4wPLj5qNw,2490
+krita_cli/commands/color.py,sha256=MAyZq8rZaZSPgd3x40NM2xCdcZRvw-JUei6Agep1cLs,1112
+krita_cli/commands/config.py,sha256=alVwNY4CQCQnJP4oJJdlCcTJZnnvV24w32m215YrTCE,1456
+krita_cli/commands/file_ops.py,sha256=qpg4GKdWFe1A0yY5KYmZcfRWpIpQayta4iF3e_3wYCM,651
+krita_cli/commands/health.py,sha256=08Adqh45c6u9d5YAOUNimHSCDX27zq5oGwju4Z8KHo4,911
+krita_cli/commands/history_cmd.py,sha256=tJaGKRu53gNlVgv3ER6HzuI_toUlHdbc648N5-StlDM,1835
+krita_cli/commands/introspect.py,sha256=BskBm3MpkmYdXTKwiLXRKcZd9WZzO1KYdZ1T1xwbPbc,1252
+krita_cli/commands/layers.py,sha256=hC6DLDoNEJohQWzOQBOWpnYpGvTLRpcMS_ZqPncIq6k,3334
+krita_cli/commands/navigation.py,sha256=fe5FPuF7AEDXop_kclBXodUtmgDSSD2GbK5cbCFGbik,756
+krita_cli/commands/replay.py,sha256=UD_Ui1JD89FGJ1sD0Lt1CxVb_2BdjQrHE5qMLlhReGg,3824
+krita_cli/commands/rollback.py,sha256=ljbREETPMuEO0mDiAK6b8XwRwlh0569dKRWcsREykRU,1081
+krita_cli/commands/selection.py,sha256=CQRT8K9CLLjWMeWzII6lIrLZJJCmnWbyYbDnEltKfEc,13338
+krita_cli/commands/stroke.py,sha256=xbDU6Bmq_S6ySk6KW1TZUhiwVYd9W0Cps6mIDb2mnkM,3550
+krita_client/__init__.py,sha256=RM4zCMP82QbKgTsXRQx-vSmXMGijvL0rYEVm_8a5-ws,1505
+krita_client/client.py,sha256=HUweZ6hXWDsTjlHPtVNT4YIx_6RflOMVyXZsKq2YdV4,25200
+krita_client/config.py,sha256=Kc8wX1cXZZxawGdD0zdCNaLpEdqiZSehIhIPnf7T1yU,1586
+krita_client/models.py,sha256=zCBF0WIvLhSXp1Hs4OB6RmApjCjDcmQOzgZfLHHSmsA,13647
+krita_client/schema.py,sha256=UCYoeoWeNGDPvCEukNVadXgRNYqIe9DI_nhEBLrrXPw,3816
+krita_mcp/__init__.py,sha256=dr6IyEhZXliSB7CxR6fI65RLwkc5gvtiVXwSa_kgqQ4,60
+krita_mcp/server.py,sha256=w-u1g68kQ1Wr3yuK0bL3eUZbv3dK5xinA6jYbmoKK50,33180
+krita_cli-1.0.0.dist-info/METADATA,sha256=dQMtXuAghQFEN397FKeGaeXD8aGdTHOPbYUL3A2hr50,4647
+krita_cli-1.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+krita_cli-1.0.0.dist-info/entry_points.txt,sha256=144liQ6zPDeWWSNFDnr3IEawJLZ1PWYX8eQAMtHtxbw,44
+krita_cli-1.0.0.dist-info/licenses/LICENSE,sha256=Btzdu2kIoMbdSp6OyCLupB1aRgpTCJ_szMimgEnpkkE,1056
+krita_cli-1.0.0.dist-info/RECORD,,

krita_cli-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

krita_cli-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+krita = krita_cli.cli:app

krita_cli-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

krita_client/__init__.py

@@ -0,0 +1,68 @@
+"""Krita MCP Client — Typed HTTP client for the Krita plugin.
+
+This package provides:
+- ``ClientConfig``: Configuration via pydantic-settings.
+- ``KritaClient``: Typed HTTP client with validated commands.
+- Pydantic models for all 14 command parameter sets.
+- OpenAPI schema generation.
+"""
+
+from __future__ import annotations
+
+from krita_client.client import (
+    KritaClient,
+    KritaCommandError,
+    KritaConnectionError,
+    KritaError,
+    KritaValidationError,
+)
+from krita_client.config import ClientConfig
+from krita_client.models import (
+    COMMAND_MODELS,
+    BatchCommand,
+    BatchParams,
+    ClearParams,
+    DrawShapeParams,
+    ErrorCode,
+    FillParams,
+    GetCanvasParams,
+    GetColorAtParams,
+    ListBrushesParams,
+    NewCanvasParams,
+    OpenFileParams,
+    RedoParams,
+    SaveParams,
+    SetBrushParams,
+    SetColorParams,
+    StrokeParams,
+    UndoParams,
+)
+from krita_client.schema import generate_openapi_schema
+
+__all__ = [
+    "COMMAND_MODELS",
+    "BatchCommand",
+    "BatchParams",
+    "ClearParams",
+    "ClientConfig",
+    "DrawShapeParams",
+    "ErrorCode",
+    "FillParams",
+    "GetCanvasParams",
+    "GetColorAtParams",
+    "KritaClient",
+    "KritaCommandError",
+    "KritaConnectionError",
+    "KritaError",
+    "KritaValidationError",
+    "ListBrushesParams",
+    "NewCanvasParams",
+    "OpenFileParams",
+    "RedoParams",
+    "SaveParams",
+    "SetBrushParams",
+    "SetColorParams",
+    "StrokeParams",
+    "UndoParams",
+    "generate_openapi_schema",
+]