krita-cli 1.0.0__tar.gz

krita_cli-1.0.0/.github/skills/krita-mcp.md

@@ -0,0 +1,151 @@
+# Krita MCP — Skill Reference
+
+## What is this?
+
+A **SOTA CLI + MCP server** for programmatic painting in Krita. Two interfaces, one core:
+- **CLI**: `krita stroke --points 100,100 200,200` — direct command-line control
+- **MCP**: FastMCP server — for AI agents to paint programmatically
+
+Both talk to a Krita plugin via HTTP on localhost:5678.
+
+## Quick Start
+
+### Prerequisites
+- Python 3.12+
+- Krita installed with MCP plugin enabled
+- `uv` package manager
+
+### Setup
+```bash
+uv sync
+# Copy plugin to Krita's plugin directory
+# Enable in Krita: Settings → Configure Krita → Python Plugin Manager
+# Start Krita with plugin enabled
+```
+
+### CLI Usage
+```bash
+# Check Krita is running
+krita health
+
+# Create a canvas
+krita canvas new-canvas --width 1920 --height 1080
+
+# Set color and draw
+krita color set-color --color "#ff0000"
+krita stroke stroke "0,0" "100,100" "200,50"
+
+# Select and draw within bounds
+krita selection select-rect --x 10 --y 10 --width 100 --height 100
+krita stroke stroke "0,0" "200,200"  # clipped to selection
+
+# Export canvas
+krita canvas get-canvas --filename output.png
+```
+
+### MCP Usage
+
+Connect an MCP client (Claude, etc.) to `http://localhost:5678`. Available tools:
+
+| Tool | Description |
+|------|-------------|
+| `krita_health` | Check Krita + plugin status |
+| `krita_new_canvas` | Create canvas (width, height, bg color) |
+| `krita_set_color` | Set foreground color (hex) |
+| `krita_set_brush` | Set brush preset/size/opacity |
+| `krita_stroke` | Paint stroke through [x, y] points |
+| `krita_fill` | Fill circular area |
+| `krita_draw_shape` | Draw rectangle/ellipse/line |
+| `krita_get_canvas` | Export canvas to PNG |
+| `krita_save` | Save canvas to file |
+| `krita_undo` / `krita_redo` | Undo/redo |
+| `krita_clear` | Clear canvas |
+| `krita_get_color_at` | Eyedropper |
+| `krita_list_brushes` | List brush presets |
+| `krita_open_file` | Open existing file |
+| `krita_batch` | Execute multiple commands sequentially |
+| `krita_rollback` | Roll back a batch operation by batch ID |
+| `krita_select_rect` | Select a rectangular area |
+| `krita_select_ellipse` | Select an elliptical area |
+| `krita_select_polygon` | Select a polygonal area |
+| `krita_selection_info` | Get current selection bounds |
+| `krita_invert_selection` | Invert the current selection |
+| `krita_clear_selection` | Clear selection contents |
+| `krita_fill_selection` | Fill selection with foreground color |
+| `krita_deselect` | Remove current selection |
+| `krita_transform_selection` | Move/rotate/scale selection |
+| `krita_grow_selection` | Grow selection by N pixels |
+| `krita_shrink_selection` | Shrink selection by N pixels |
+| `krita_border_selection` | Create border around selection |
+| `krita_get_capabilities` | Get detected API capabilities |
+| `krita_security_status` | Get security limits and usage |
+| `krita_list_tools` | List all available MCP tools |
+
+## Agent Workflow
+
+### Painting a simple shape
+1. `krita_new_canvas(width=800, height=600)` — create canvas
+2. `krita_set_color(color="#ff0000")` — set color
+3. `krita_stroke(points=[[100,100],[200,100],[150,200]])` — draw triangle
+4. `krita_get_canvas(filename="result.png")` — export result
+
+### Painting within a selection
+1. `krita_new_canvas(width=800, height=600)`
+2. `krita_select_rect(x=50, y=50, width=200, height=200)` — create selection
+3. `krita_set_color(color="#00ff00")`
+4. `krita_stroke(points=[[0,0],[400,400]])` — clipped to selection
+5. `krita_deselect()` — remove selection
+6. `krita_get_canvas(filename="clipped.png")`
+
+### Batch operations
+1. `krita_batch(commands=[{"action":"set_color","params":{"color":"#ff0000"}},{"action":"stroke","params":{"points":[[0,0],[100,100]]}}])`
+2. `krita_rollback(batch_id="...")` — if something went wrong
+
+### Iterative painting
+1. `krita_new_canvas()` → `krita_stroke()` → `krita_get_canvas()` — see result
+2. Analyze result, adjust parameters
+3. `krita_stroke()` with new points → `krita_get_canvas()` — iterate
+4. `krita_save(path="final.png")` when satisfied
+
+## Security Limits
+
+| Limit | Default |
+|-------|---------|
+| Rate limit | 60 commands/minute |
+| Max payload | 10 MB |
+| Max batch size | 50 commands |
+| Max canvas | 8192×8192 |
+| Max layers | 100 |
+
+Check current status: `krita selection security-status`
+
+## Command Groups
+
+| Group | Commands |
+|-------|----------|
+| `krita canvas` | new-canvas, get-canvas, save, clear |
+| `krita color` | set-color, get-color-at |
+| `krita brush` | set-brush, list-brushes |
+| `krita stroke` | stroke, fill, draw-shape |
+| `krita navigation` | undo, redo |
+| `krita file` | open-file |
+| `krita selection` | select-rect, select-ellipse, select-polygon, selection-info, transform-selection, grow-selection, shrink-selection, border-selection, select-clear, select-invert, select-fill, deselect, security-status |
+| `krita history` | history |
+| `krita introspect` | canvas-info, current-color, current-brush |
+| `krita replay` | replay |
+
+## Error Handling
+
+All commands return structured errors:
+```json
+{"code": "NO_ACTIVE_DOCUMENT", "message": "...", "recoverable": true}
+```
+
+CLI shows: `[red]Error: ...[/red]` with hints for recovery.
+
+## Protocol
+
+- HTTP POST to `localhost:5678` with `{"action": "...", "params": {...}}`
+- Health check: GET `localhost:5678/health`
+- Default timeout: 30s (120s for export/save)
+- Protocol version included in health response

krita_cli-1.0.0/.github/workflows/ci.yml

@@ -0,0 +1,113 @@
+name: CI
+
+on:
+  push:
+    branches: [main, master]
+    tags: ["v*"]
+  pull_request:
+    branches: [main, master]
+  workflow_dispatch:
+
+env:
+  UV_VERSION: "latest"
+  PYTHON_VERSION: "3.12"
+
+jobs:
+  lint:
+    name: Lint (ruff)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          version: ${{ env.UV_VERSION }}
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - run: uv sync --frozen
+      - run: uv run ruff check src/ tests/
+      - run: uv run ruff format --check src/ tests/
+
+  typecheck:
+    name: Type Check (ty)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          version: ${{ env.UV_VERSION }}
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ env.PYTHON_VERSION }}
+      - run: uv sync --frozen
+      - run: uv run ty check src/ types/
+
+  test:
+    name: All Tests
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: ["3.12", "3.13"]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          version: ${{ env.UV_VERSION }}
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: uv sync --frozen
+      - run: uv run pytest tests/ -v --cov=src --cov-fail-under=95
+
+  build:
+    name: Build Package
+    runs-on: ubuntu-latest
+    needs: [lint, typecheck, test]
+    steps:
+      - uses: actions/checkout@v4
+      - uses: astral-sh/setup-uv@v5
+        with:
+          version: ${{ env.UV_VERSION }}
+      - run: uv build
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish-pypi:
+    name: Publish to PyPI
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: [build]
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/krita-cli
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+  publish-conda:
+    name: Publish to Conda
+    if: startsWith(github.ref, 'refs/tags/v')
+    needs: [build]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Set up Conda
+        uses: conda-incubator/setup-miniconda@v3
+        with:
+          auto-update-conda: true
+          python-version: 3.12
+          channels: conda-forge,defaults
+      - name: Build and Upload to Anaconda
+        shell: bash -l {0}
+        run: |
+          conda install -y anaconda-client conda-build
+          conda build conda-recipe/ --output-folder dist/conda
+          anaconda -t ${{ secrets.ANACONDA_API_TOKEN }} upload dist/conda/noarch/krita-cli-*.tar.bz2 --force

krita_cli-1.0.0/.gitignore

@@ -0,0 +1,40 @@
+.venv/
+__pycache__/
+*.pyc
+.env
+
+# Build artifacts
+dist/
+build/
+*.egg-info/
+*.egg
+
+# Testing
+.pytest_cache/
+.coverage
+htmlcov/
+.mutmut-cache
+.hypothesis/
+
+# Tooling caches
+.ruff_cache/
+.ty_cache/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Project
+logs/
+pytest-of-*/
+.swarm/
+.gemini/
+.geminiignore
+history.log
+refactor_plugin.py

krita_cli-1.0.0/.pre-commit-config.yaml

@@ -0,0 +1,17 @@
+repos:
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.15.9
+    hooks:
+      - id: ruff
+        args: [--fix, --exit-non-zero-on-fix]
+      - id: ruff-format
+
+  - repo: local
+    hooks:
+      - id: ty
+        name: ty type check
+        entry: uv run ty check src/ types/
+        language: system
+        types: [python]
+        pass_filenames: false
+        require_serial: true

krita_cli-1.0.0/.python-version

@@ -0,0 +1 @@
+3.12

krita_cli-1.0.0/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_cli-1.0.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,70 @@
+# 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/SECRETS.md

@@ -0,0 +1,28 @@
+# Required Repository Secrets
+
+The following secrets must be configured in GitHub → Settings → Secrets and variables → Actions:
+
+| Secret | Description | How to Create |
+|--------|-------------|---------------|
+| `GH_TOKEN` | GitHub Personal Access Token with `repo` scope | GitHub → Settings → Developer settings → Personal access tokens → Fine-grained tokens |
+| `PYPI_TOKEN` | PyPI API token for publishing packages | https://pypi.org/manage/account/token/ → Create token |
+
+## Creating GH_TOKEN
+
+1. Go to https://github.com/settings/tokens
+2. Create a fine-grained token with:
+   - Repository access: This repository only
+   - Permissions: Contents (read/write), Pull requests (read/write), Workflows (read/write)
+3. Copy the token and add it as `GH_TOKEN` in repo secrets
+
+## Creating PYPI_TOKEN
+
+1. Go to https://pypi.org/manage/account/
+2. Scroll to "API tokens" section
+3. Click "Add API token"
+4. Set scope to "Entire account" or "Specific project" (if krita-cli exists)
+5. Copy the token and add it as `PYPI_TOKEN` in repo secrets
+
+## Verifying Secrets
+
+After adding secrets, the CI release workflow will use them automatically when pushing to master with a conventional commit that triggers a release.

krita_cli-1.0.0/benchmarks/test_rendering.py

@@ -0,0 +1,67 @@
+"""Performance benchmarks for krita_client and plugin rendering."""
+
+from __future__ import annotations
+
+import importlib.util
+import time
+from pathlib import Path
+
+
+def _get_plugin_class() -> type:
+    """Import the plugin module via file path (not a pip-installable package)."""
+    plugin_path = Path(__file__).parent.parent / "krita-plugin" / "kritamcp" / "__init__.py"
+    spec = importlib.util.spec_from_file_location("kritamcp", plugin_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)  # type: ignore[union-attr]
+    return module.KritaMCPExtension  # type: ignore[no-any-return]
+
+
+def benchmark_stroke_rendering_python() -> float:
+    """Benchmark pure Python stroke rendering."""
+    plugin_cls = _get_plugin_class()
+
+    pixels = bytearray(255 * 255 * 4)
+    w, h = 255, 255
+    points = [[i * 10, i * 10] for i in range(25)]
+    radius = 20
+    hardness = 0.5
+    opacity = 1.0
+    r, g, b = 255, 0, 0
+
+    start = time.perf_counter()
+    plugin_cls._draw_stroke_python(pixels, w, h, points, radius, hardness, opacity, r, g, b)
+    return time.perf_counter() - start
+
+
+def benchmark_stroke_rendering_numpy() -> float:
+    """Benchmark numpy-accelerated stroke rendering."""
+    try:
+        import numpy as np  # noqa: F401, PLC0415
+    except ImportError:
+        return 0.0
+
+    plugin_cls = _get_plugin_class()
+
+    pixels = bytearray(255 * 255 * 4)
+    w, h = 255, 255
+    points = [[i * 10, i * 10] for i in range(25)]
+    radius = 20
+    hardness = 0.5
+    opacity = 1.0
+    r, g, b = 255, 0, 0
+
+    start = time.perf_counter()
+    plugin_cls._draw_stroke_numpy(pixels, w, h, points, radius, hardness, opacity, r, g, b)
+    return time.perf_counter() - start
+
+
+if __name__ == "__main__":
+    python_time = benchmark_stroke_rendering_python()
+    numpy_time = benchmark_stroke_rendering_numpy()
+
+    print(f"Python stroke rendering: {python_time:.4f}s")
+    if numpy_time > 0:
+        print(f"Numpy stroke rendering:  {numpy_time:.4f}s")
+        print(f"Speedup: {python_time / numpy_time:.1f}x")
+    else:
+        print("Numpy not available — skipping numpy benchmark")

krita_cli-1.0.0/conda-recipe/meta.yaml

@@ -0,0 +1,48 @@
+{% set name = 'krita-cli' %}
+{% set version = '1.0.0' %}
+
+package:
+  name: {{ name|lower }}
+  version: {{ version }}
+
+source:
+  path: ..
+
+build:
+  number: 0
+  script: {{ PYTHON }} -m pip install . --no-deps -vv
+  entry_points:
+    - krita = krita_cli.cli:app
+
+requirements:
+  host:
+    - python >=3.12
+    - pip
+    - hatchling
+  run:
+    - python >=3.12
+    - fastmcp >=3.1.0
+    - httpx >=0.28.1
+    - pydantic >=2.12.5
+    - pydantic-settings >=2.0.0
+    - rich >=13.0.0
+    - typer >=0.9.0
+
+test:
+  commands:
+    - krita --help
+
+about:
+  home: https://github.com/edithatogo/krita-cli
+  license: MIT
+  license_file: LICENSE
+  summary: SOTA CLI + MCP server for programmatic painting in Krita
+  description: |
+    Krita CLI provides a bridge between AI agents, developers, and the Krita desktop application.
+    It enables real-time painting, canvas manipulation, and workflow automation.
+  dev_url: https://github.com/edithatogo/krita-cli
+  doc_url: https://github.com/edithatogo/krita-cli
+
+extra:
+  recipe-maintainers:
+    - edithatogo

krita_cli-1.0.0/conductor/archive/cli_command_grouping_20260406/index.md

@@ -0,0 +1,5 @@
+# Track cli_command_grouping_20260406 Context
+
+- [Specification](./spec.md)
+- [Implementation Plan](./plan.md)
+- [Metadata](./metadata.json)

krita_cli-1.0.0/conductor/archive/cli_command_grouping_20260406/metadata.json

@@ -0,0 +1,7 @@
+{
+  "track_id": "cli_command_grouping_20260406",
+  "created_at": "2026-04-06",
+  "status": "pending",
+  "phase": "12",
+  "priority": "medium"
+}