videopython 0.49.0__tar.gz → 0.50.0__tar.gz

{videopython-0.49.0 → videopython-0.50.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: videopython
-Version: 0.49.0
+Version: 0.50.0
 Summary: Minimal video generation and processing library.
 Project-URL: Homepage, https://videopython.com
 Project-URL: Repository, https://github.com/bartwojtowicz/videopython/
@@ -38,6 +38,8 @@ Requires-Dist: torchaudio>=2.8.0; extra == 'ai'
 Requires-Dist: transformers>=5.2.0; extra == 'ai'
 Requires-Dist: transnetv2-pytorch>=1.0.5; extra == 'ai'
 Requires-Dist: ultralytics>=8.0.0; extra == 'ai'
+Provides-Extra: mcp
+Requires-Dist: mcp<2,>=1.27; extra == 'mcp'
 Description-Content-Type: text/markdown
 
 # videopython
@@ -56,11 +58,12 @@ Full documentation: [videopython.com](https://videopython.com)
 
 ```bash
 # Install FFmpeg first (macOS: brew install ffmpeg | Debian: apt-get install ffmpeg)
-pip install videopython          # core video/audio editing
-pip install "videopython[ai]"    # + ALL local AI features (GPU recommended)
+pip install videopython              # core video/audio editing
+pip install "videopython[ai]"        # + ALL local AI features (GPU recommended)
+pip install "videopython[ai,mcp]"    # + MCP server for agent-driven editing
 ```
 
-Python `>=3.11, <3.14`. AI features run locally — no cloud API keys required, but model weights are downloaded on first use.
+Python `>=3.11, <3.14`. AI features run locally — no cloud API keys required, but model weights are downloaded on first use. LLM-driven editing and scene captioning use a local [Ollama](https://ollama.com) server (`ollama pull gemma3:27b`).
 
 ## Quick Start
 
@@ -89,6 +92,23 @@ edit.run_to_file("output.mp4")   # streams ffmpeg decode → effects → encode
 
 `run_to_file()` streams ffmpeg decode → per-frame effects → encode, so memory stays bounded even for hour-long sources. If you need the frames back in memory, load the rendered file: `Video.from_path(str(edit.run_to_file("output.mp4")))`.
 
+### Automatic editing (local LLM)
+
+Give `AutoEditor` your clips and a brief; a local Ollama vision model selects and orders the shots, and you get back a runnable `VideoEdit`:
+
+```python
+from videopython.ai import AutoEditor, OllamaVisionLLM
+
+editor = AutoEditor(planner=OllamaVisionLLM(model="gemma3:27b"))  # ollama pull gemma3:27b
+edit = editor.edit(
+    ["clip_a.mp4", "clip_b.mp4", "clip_c.mp4"],
+    brief="A punchy 15-second teaser; lead with the most dynamic shot.",
+)
+edit.run_to_file("teaser.mp4")
+```
+
+The model picks scenes **by id** from a catalog built from scene detection + captions, so its temporal imprecision never reaches the render. See the [Automatic Editing Guide](https://videopython.com/guides/auto-editing/).
+
 ### AI generation
 
 ```python
@@ -102,7 +122,13 @@ video.add_audio(audio).save("ai_video.mp4")
 
 ## LLM & AI Agent Integration
 
-Every operation is a Pydantic model whose fields ARE the JSON wire format. `VideoEdit.json_schema()` returns a JSON Schema with a discriminated union over every LLM-exposed `Operation` (server-only ops like `image_overlay` are excluded by default) — pass it straight to Anthropic tool use, OpenAI function calling, or any structured-output API. Pass `strict=True` for a provider strict-mode grammar that prevents simple bound violations at decode time.
+Putting an LLM in the loop works three ways:
+
+1. **Bring your own LLM** — videopython gives your model the JSON Schema and a structured refine loop; your model authors the plans (details below).
+2. **`AutoEditor`** — a local Ollama vision model is the planner (see [Automatic editing](#automatic-editing-local-llm) above).
+3. **MCP server** — `videopython-mcp` exposes the pipeline as [Model Context Protocol](https://modelcontextprotocol.io) tools, so an agent like Claude drives editing with its own model. Install `[ai,mcp]`, run `videopython-mcp`, and point your MCP client at it. See the [MCP Server Guide](https://videopython.com/guides/mcp/).
+
+For mode 1: every operation is a Pydantic model whose fields ARE the JSON wire format. `VideoEdit.json_schema()` returns a JSON Schema with a discriminated union over every LLM-exposed `Operation` (server-only ops like `image_overlay` are excluded by default) — pass it straight to Anthropic tool use, OpenAI function calling, or any structured-output API. Pass `strict=True` for a provider strict-mode grammar that prevents simple bound violations at decode time.
 
 The plan parses permissively (shape only) and owns numeric bounds at validation, so a refine loop converges fast: `edit.check(meta)` collects **every** structured `PlanError` in one pass, `edit.repair(meta)` auto-clamps the mechanical violations (window/timestamp overruns, negatives) with a reported changelog, and `edit.normalize_dimensions(meta, target)` makes heterogeneous segments concat-compatible by construction. `edit.validate()` still raises a typed `PlanValidationError` (a `ValueError` with structured `.errors`) for the single-error path.
 
@@ -113,8 +139,10 @@ See the [LLM Integration Guide](https://videopython.com/guides/llm-integration/)
 - **`videopython.base`** — `Video`, `VideoMetadata`, `FrameIterator`, `Transcription`, and shared result types (`BoundingBox`, `FaceTrack`, `SceneBoundary`, ...). No AI dependencies.
 - **`videopython.audio`** — `Audio` with overlay, concat, normalize, time-stretch, silence detection, segment classification.
 - **`videopython.editing`** — `Operation`/`Effect` foundation, `VideoEdit` plan runner with JSON Schema + streaming execution. Transforms (resize, crop, fps, speed, freeze, silence removal; cutting is the segment's own start/end) and effects (blur, zoom, color grading, vignette, Ken Burns, fade, overlays, animated subtitles).
-- **`videopython.ai`** *(install with `[ai]`)* — generation (`TextToVideo`, `ImageToVideo`, `TextToImage`, `TextToSpeech`, `TextToMusic`), understanding (`AudioToText`, `AudioClassifier`, `SceneVLM`, `FaceTracker`, `ObjectDetector`, `SemanticSceneDetector`), the `FaceTrackingCrop` transform, the `ObjectDetectionOverlay` effect (per-frame bounding boxes + labels), and the full-pipeline `VideoAnalyzer`.
+- **`videopython.ai`** *(install with `[ai]`)* — generation (`TextToVideo`, `ImageToVideo`, `TextToImage`, `TextToSpeech`, `TextToMusic`), understanding (`AudioToText`, `AudioClassifier`, `SceneVLM`, `FaceTracker`, `ObjectDetector`, `SemanticSceneDetector`), the `FaceTrackingCrop` transform, the `ObjectDetectionOverlay` effect (per-frame bounding boxes + labels), and the full-pipeline `VideoAnalyzer`. Scene captioning and dub translation run on a local [Ollama](https://ollama.com) model.
+- **`videopython.ai.auto_edit`** — `AutoEditor` + `OllamaVisionLLM`: plan and render an edit from sources + a one-line brief, with a local LLM selecting scenes by id from an auto-built catalog.
 - **`videopython.ai.dubbing`** — `VideoDubber` for voice-cloned revoicing with timing sync.
+- **`videopython.mcp`** *(install with `[mcp]`)* — `videopython-mcp`, an MCP stdio server exposing the auto-edit pipeline (analyze → catalog → validate/repair/run) so an agent drives editing.
 
 ## Examples
 

{videopython-0.49.0 → videopython-0.50.0}/README.md

@@ -14,11 +14,12 @@ Full documentation: [videopython.com](https://videopython.com)
 
 ```bash
 # Install FFmpeg first (macOS: brew install ffmpeg | Debian: apt-get install ffmpeg)
-pip install videopython          # core video/audio editing
-pip install "videopython[ai]"    # + ALL local AI features (GPU recommended)
+pip install videopython              # core video/audio editing
+pip install "videopython[ai]"        # + ALL local AI features (GPU recommended)
+pip install "videopython[ai,mcp]"    # + MCP server for agent-driven editing
 ```
 
-Python `>=3.11, <3.14`. AI features run locally — no cloud API keys required, but model weights are downloaded on first use.
+Python `>=3.11, <3.14`. AI features run locally — no cloud API keys required, but model weights are downloaded on first use. LLM-driven editing and scene captioning use a local [Ollama](https://ollama.com) server (`ollama pull gemma3:27b`).
 
 ## Quick Start
 
@@ -47,6 +48,23 @@ edit.run_to_file("output.mp4")   # streams ffmpeg decode → effects → encode
 
 `run_to_file()` streams ffmpeg decode → per-frame effects → encode, so memory stays bounded even for hour-long sources. If you need the frames back in memory, load the rendered file: `Video.from_path(str(edit.run_to_file("output.mp4")))`.
 
+### Automatic editing (local LLM)
+
+Give `AutoEditor` your clips and a brief; a local Ollama vision model selects and orders the shots, and you get back a runnable `VideoEdit`:
+
+```python
+from videopython.ai import AutoEditor, OllamaVisionLLM
+
+editor = AutoEditor(planner=OllamaVisionLLM(model="gemma3:27b"))  # ollama pull gemma3:27b
+edit = editor.edit(
+    ["clip_a.mp4", "clip_b.mp4", "clip_c.mp4"],
+    brief="A punchy 15-second teaser; lead with the most dynamic shot.",
+)
+edit.run_to_file("teaser.mp4")
+```
+
+The model picks scenes **by id** from a catalog built from scene detection + captions, so its temporal imprecision never reaches the render. See the [Automatic Editing Guide](https://videopython.com/guides/auto-editing/).
+
 ### AI generation
 
 ```python
@@ -60,7 +78,13 @@ video.add_audio(audio).save("ai_video.mp4")
 
 ## LLM & AI Agent Integration
 
-Every operation is a Pydantic model whose fields ARE the JSON wire format. `VideoEdit.json_schema()` returns a JSON Schema with a discriminated union over every LLM-exposed `Operation` (server-only ops like `image_overlay` are excluded by default) — pass it straight to Anthropic tool use, OpenAI function calling, or any structured-output API. Pass `strict=True` for a provider strict-mode grammar that prevents simple bound violations at decode time.
+Putting an LLM in the loop works three ways:
+
+1. **Bring your own LLM** — videopython gives your model the JSON Schema and a structured refine loop; your model authors the plans (details below).
+2. **`AutoEditor`** — a local Ollama vision model is the planner (see [Automatic editing](#automatic-editing-local-llm) above).
+3. **MCP server** — `videopython-mcp` exposes the pipeline as [Model Context Protocol](https://modelcontextprotocol.io) tools, so an agent like Claude drives editing with its own model. Install `[ai,mcp]`, run `videopython-mcp`, and point your MCP client at it. See the [MCP Server Guide](https://videopython.com/guides/mcp/).
+
+For mode 1: every operation is a Pydantic model whose fields ARE the JSON wire format. `VideoEdit.json_schema()` returns a JSON Schema with a discriminated union over every LLM-exposed `Operation` (server-only ops like `image_overlay` are excluded by default) — pass it straight to Anthropic tool use, OpenAI function calling, or any structured-output API. Pass `strict=True` for a provider strict-mode grammar that prevents simple bound violations at decode time.
 
 The plan parses permissively (shape only) and owns numeric bounds at validation, so a refine loop converges fast: `edit.check(meta)` collects **every** structured `PlanError` in one pass, `edit.repair(meta)` auto-clamps the mechanical violations (window/timestamp overruns, negatives) with a reported changelog, and `edit.normalize_dimensions(meta, target)` makes heterogeneous segments concat-compatible by construction. `edit.validate()` still raises a typed `PlanValidationError` (a `ValueError` with structured `.errors`) for the single-error path.
 
@@ -71,8 +95,10 @@ See the [LLM Integration Guide](https://videopython.com/guides/llm-integration/)
 - **`videopython.base`** — `Video`, `VideoMetadata`, `FrameIterator`, `Transcription`, and shared result types (`BoundingBox`, `FaceTrack`, `SceneBoundary`, ...). No AI dependencies.
 - **`videopython.audio`** — `Audio` with overlay, concat, normalize, time-stretch, silence detection, segment classification.
 - **`videopython.editing`** — `Operation`/`Effect` foundation, `VideoEdit` plan runner with JSON Schema + streaming execution. Transforms (resize, crop, fps, speed, freeze, silence removal; cutting is the segment's own start/end) and effects (blur, zoom, color grading, vignette, Ken Burns, fade, overlays, animated subtitles).
-- **`videopython.ai`** *(install with `[ai]`)* — generation (`TextToVideo`, `ImageToVideo`, `TextToImage`, `TextToSpeech`, `TextToMusic`), understanding (`AudioToText`, `AudioClassifier`, `SceneVLM`, `FaceTracker`, `ObjectDetector`, `SemanticSceneDetector`), the `FaceTrackingCrop` transform, the `ObjectDetectionOverlay` effect (per-frame bounding boxes + labels), and the full-pipeline `VideoAnalyzer`.
+- **`videopython.ai`** *(install with `[ai]`)* — generation (`TextToVideo`, `ImageToVideo`, `TextToImage`, `TextToSpeech`, `TextToMusic`), understanding (`AudioToText`, `AudioClassifier`, `SceneVLM`, `FaceTracker`, `ObjectDetector`, `SemanticSceneDetector`), the `FaceTrackingCrop` transform, the `ObjectDetectionOverlay` effect (per-frame bounding boxes + labels), and the full-pipeline `VideoAnalyzer`. Scene captioning and dub translation run on a local [Ollama](https://ollama.com) model.
+- **`videopython.ai.auto_edit`** — `AutoEditor` + `OllamaVisionLLM`: plan and render an edit from sources + a one-line brief, with a local LLM selecting scenes by id from an auto-built catalog.
 - **`videopython.ai.dubbing`** — `VideoDubber` for voice-cloned revoicing with timing sync.
+- **`videopython.mcp`** *(install with `[mcp]`)* — `videopython-mcp`, an MCP stdio server exposing the auto-edit pipeline (analyze → catalog → validate/repair/run) so an agent drives editing.
 
 ## Examples
 

{videopython-0.49.0 → videopython-0.50.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "videopython"
-version = "0.49.0"
+version = "0.50.0"
 description = "Minimal video generation and processing library."
 authors = [
     { name = "Bartosz Wójtowicz", email = "bartoszwojtowicz@outlook.com" },
@@ -89,6 +89,11 @@ ai = [
     "torch>=2.8.0",
     "torchaudio>=2.8.0",
 ]
+# MCP server (videopython/mcp/). Pin <2 — v2 is pre-release/breaking.
+mcp = ["mcp>=1.27,<2"]
+
+[project.scripts]
+videopython-mcp = "videopython.mcp.server:main"
 
 [project.urls]
 Homepage = "https://videopython.com"
@@ -118,6 +123,7 @@ module = [
     "cv2", "cv2.*",
     "pyloudnorm", "pyloudnorm.*",
     "imagehash", "imagehash.*",
+    "mcp", "mcp.*",
 ]
 ignore_missing_imports = true
 

{videopython-0.49.0 → videopython-0.50.0}/src/videopython/ai/video_analysis/models.py

@@ -146,7 +146,7 @@ class VideoAnalysisConfig(BaseModel):
         VideoAnalysisConfig(
             analyzer_params={
                 "audio_to_text": {"model_name": "large"},
-                "scene_vlm": {"model": "llama3.2-vision"},
+                "scene_vlm": {"model": "gemma3:27b"},
             }
         )
     """

videopython-0.50.0/src/videopython/mcp/__init__.py

@@ -0,0 +1,6 @@
+"""videopython MCP server: the auto-edit primitives exposed as MCP tools.
+
+Run with the ``videopython-mcp`` console script (needs the ``[ai,mcp]`` extras).
+The MCP client's own model is the planner; this server only exposes the steps
+(analyze -> catalog -> validate/repair/run over an EditPlan by scene id).
+"""

videopython-0.50.0/src/videopython/mcp/server.py

@@ -0,0 +1,221 @@
+"""videopython MCP server (stdio): auto-edit primitives as MCP tools.
+
+The MCP client's model is the planner. These tools expose the steps it drives:
+analyze each source, build a keyframe catalog, then author an ``EditPlan`` that
+references catalog scenes by ``scene_id`` and validate / repair / run it. The
+server caches analyses + the catalog so the agent passes small payloads (scene
+ids), not whole analysis blobs.
+"""
+
+from __future__ import annotations
+
+import json
+import sys
+from contextlib import redirect_stdout
+from pathlib import Path
+from typing import TYPE_CHECKING, Any
+
+from mcp.server.fastmcp import FastMCP
+from mcp.types import ImageContent, TextContent
+from pydantic import ValidationError
+
+from videopython.ai._ollama import _encode_png_b64
+from videopython.ai.auto_edit import EditPlan, UnknownSceneIdsError, resolve_plan
+from videopython.ai.auto_edit import build_catalog as _build_scene_catalog
+from videopython.editing import VideoEdit
+
+if TYPE_CHECKING:
+    from videopython.ai.auto_edit import CatalogBundle
+    from videopython.ai.video_analysis import VideoAnalysis, VideoAnalyzer
+    from videopython.base import PlanError, PlanRepair
+
+mcp = FastMCP("videopython")
+
+# Session state for one stdio client (one process per client).
+_analyses: dict[str, VideoAnalysis] = {}
+_analyzer: VideoAnalyzer | None = None
+_bundle: CatalogBundle | None = None
+
+
+@mcp.tool()
+def analyze_video(path: str) -> dict[str, Any]:
+    """Analyze a source video (scenes, transcript, captions) and cache it for build_catalog.
+
+    Returns a short summary; call this once per source, then build_catalog.
+    """
+    # Heavy analyzer deps (e.g. transnetv2-pytorch) bare-print to stdout, which here is
+    # the stdio JSON-RPC channel; send that to stderr so the transport stays clean.
+    with redirect_stdout(sys.stderr):
+        analysis = _get_analyzer().analyze_path(path)
+    _analyses[str(Path(path))] = analysis
+    src = analysis.source
+    return {
+        "source": str(Path(path)),
+        "duration": src.duration,
+        "fps": src.fps,
+        "width": src.width,
+        "height": src.height,
+        "scenes": len(analysis.scenes.samples) if analysis.scenes else 0,
+    }
+
+
+@mcp.tool(structured_output=False)
+def build_catalog(sources: list[str] | None = None) -> list[TextContent | ImageContent]:
+    """Build the candidate-scene catalog from analyzed videos and cache it.
+
+    Returns the catalog as JSON text plus one keyframe image per scene (each
+    preceded by its scene id), so the model can see the footage. Pass ``sources``
+    to restrict to specific analyzed paths, or omit for all. Author the edit by
+    referencing the returned ``id`` values via the edit-plan schema resource.
+    """
+    global _bundle
+    analyses = _selected_analyses(sources)
+    if not analyses:
+        raise ValueError("No analyzed videos cached; call analyze_video first.")
+    _bundle = _build_scene_catalog(analyses)
+
+    blocks: list[TextContent | ImageContent] = [TextContent(type="text", text=_bundle.catalog.model_dump_json())]
+    for scene in _bundle.catalog.scenes:
+        frame = _bundle.keyframes.get(scene.id)
+        if frame is not None:
+            blocks.append(TextContent(type="text", text=f"scene {scene.id}:"))
+            blocks.append(ImageContent(type="image", data=_encode_png_b64(frame), mimeType="image/png"))
+    return blocks
+
+
+@mcp.tool()
+def validate_edit(plan: dict[str, Any]) -> dict[str, Any]:
+    """Validate an edit plan (an EditPlan referencing catalog scene ids).
+
+    Returns every problem at once as structured errors; ``valid`` is True when
+    the list is empty. A schema-invalid plan or an unknown scene id is reported
+    the same way (error ``code`` ``schema_invalid`` / ``unknown_scene_ids``).
+    """
+    edit, errors = _resolve(plan)
+    if edit is None:
+        return {"valid": False, "errors": errors}
+    errors = [_error_dict(e) for e in edit.check(_source_metadata(edit), context=_context())]
+    return {"valid": not errors, "errors": errors}
+
+
+@mcp.tool()
+def repair_edit(plan: dict[str, Any]) -> dict[str, Any]:
+    """Repair the mechanical issues in an edit plan and normalize segment dimensions.
+
+    Returns the resolved+repaired VideoEdit and a changelog, for inspection;
+    ``edit`` is None with structured ``errors`` if the plan does not resolve. The
+    returned ``edit`` is a concrete VideoEdit, not an EditPlan -- keep refining by
+    adjusting the original by-id plan, not by resubmitting this output. run_edit
+    applies the same repair before rendering.
+    """
+    edit, errors = _resolve(plan)
+    if edit is None:
+        return {"edit": None, "repairs": [], "errors": errors}
+    metadata = _source_metadata(edit)
+    context = _context()
+    edit, repairs = edit.repair(metadata, context=context, clamp_segment_end=True)
+    edit, dim_repairs = edit.normalize_dimensions(metadata, "largest", context=context)
+    return {"edit": edit.to_dict(), "repairs": [_repair_dict(r) for r in (*repairs, *dim_repairs)], "errors": []}
+
+
+@mcp.tool()
+def run_edit(plan: dict[str, Any], output_path: str) -> dict[str, Any]:
+    """Render an edit plan to an MP4 file (the path suffix is normalized to .mp4).
+
+    Resolves scene ids, repairs + normalizes, validates, then renders. If the
+    plan does not resolve or validation still fails, returns structured ``errors``
+    and ``output_path`` None instead of rendering.
+    """
+    edit, errors = _resolve(plan)
+    if edit is None:
+        return {"output_path": None, "errors": errors}
+    metadata = _source_metadata(edit)
+    context = _context()
+    edit, _ = edit.repair(metadata, context=context, clamp_segment_end=True)
+    edit, _ = edit.normalize_dimensions(metadata, "largest", context=context)
+    errors = [_error_dict(e) for e in edit.check(metadata, context=context)]
+    if errors:
+        return {"output_path": None, "errors": errors}
+    out = edit.run_to_file(output_path, context=context)
+    return {"output_path": str(out), "errors": []}
+
+
+@mcp.resource("schema://videopython/edit-plan", mime_type="application/json")
+def edit_plan_schema() -> str:
+    """JSON Schema for the edit plan an agent authors (references catalog scene ids)."""
+    return json.dumps(EditPlan.json_schema(strict=True))
+
+
+def _get_analyzer() -> VideoAnalyzer:
+    global _analyzer
+    if _analyzer is None:
+        from videopython.ai.video_analysis import VideoAnalyzer
+
+        _analyzer = VideoAnalyzer()
+    return _analyzer
+
+
+def _selected_analyses(sources: list[str] | None) -> list[VideoAnalysis]:
+    if sources is None:
+        return list(_analyses.values())
+    return [_analyses[str(Path(s))] for s in sources if str(Path(s)) in _analyses]
+
+
+def _resolve(plan: dict[str, Any]) -> tuple[VideoEdit | None, list[dict[str, Any]]]:
+    """Resolve a by-id plan, or return (None, structured errors) for the agent's plan mistakes."""
+    if _bundle is None:
+        raise ValueError("No catalog cached; call build_catalog first.")
+    try:
+        edit = resolve_plan(EditPlan.model_validate(plan), _bundle.catalog)
+    except ValidationError as exc:
+        detail = [{"loc": list(e["loc"]), "msg": e["msg"], "type": e["type"]} for e in exc.errors()]
+        return None, [{"code": "schema_invalid", "detail": detail, "message": str(exc)}]
+    except UnknownSceneIdsError as exc:
+        return None, [{"code": "unknown_scene_ids", "value": sorted(set(exc.ids)), "message": str(exc)}]
+    return edit, []
+
+
+def _source_metadata(edit: VideoEdit) -> dict[str, Any]:
+    from videopython.base.video import VideoMetadata
+
+    return {str(seg.source): VideoMetadata.from_path(seg.source) for seg in edit.segments}
+
+
+def _context() -> dict[str, Any] | None:
+    transcriptions: dict[str, Any] = {}
+    for analysis in _analyses.values():
+        src = analysis.source
+        if src.path is not None and analysis.audio is not None and analysis.audio.transcription is not None:
+            transcriptions[str(Path(src.path))] = analysis.audio.transcription
+    return {"transcription": transcriptions} if transcriptions else None
+
+
+def _error_dict(error: PlanError) -> dict[str, Any]:
+    return {
+        "code": error.code.value,
+        "location": error.location,
+        "op": error.op,
+        "field": error.field,
+        "value": error.value,
+        "limit": error.limit,
+        "detail": error.detail,
+        "message": error.to_prompt_line(),
+    }
+
+
+def _repair_dict(repair: PlanRepair) -> dict[str, Any]:
+    return {
+        "location": repair.location,
+        "field": repair.field,
+        "old": repair.old,
+        "new": repair.new,
+        "code": repair.code.value,
+    }
+
+
+def main() -> None:
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()