dcc-mcp-premiere 0.2.0__tar.gz

dcc_mcp_premiere-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,36 @@
+name: CI
+
+on:
+  pull_request:
+  push:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  test:
+    name: ${{ matrix.os }} / Python ${{ matrix.python-version }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest, macos-latest]
+        python-version: ["3.9", "3.11", "3.12"]
+        exclude:
+          - os: windows-latest
+            python-version: "3.9"
+          - os: macos-latest
+            python-version: "3.9"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - run: python -m pip install -e ".[dev]"
+      - run: pytest
+      - run: ruff check src tests tools
+      - run: ruff format --check src tests tools
+      - run: python tools/lint_skills.py
+      - run: python -m build
+      - run: python -m twine check dist/*

dcc_mcp_premiere-0.2.0/.github/workflows/release.yml

@@ -0,0 +1,35 @@
+name: Release
+
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pull-requests: write
+  id-token: write
+
+jobs:
+  release-please:
+    runs-on: ubuntu-latest
+    outputs:
+      release_created: ${{ steps.release.outputs.release_created }}
+    steps:
+      - id: release
+        uses: googleapis/release-please-action@v4
+        with:
+          config-file: release-please-config.json
+          manifest-file: .release-please-manifest.json
+  publish:
+    needs: release-please
+    if: ${{ needs.release-please.outputs.release_created == 'true' }}
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions: {id-token: write, contents: read}
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with: {python-version: "3.12"}
+      - run: python -m pip install build && python -m build
+      - uses: pypa/gh-action-pypi-publish@release/v1

dcc_mcp_premiere-0.2.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.py[cod]
+.pytest_cache/
+.ruff_cache/
+*.egg-info/
+build/
+dist/
+.venv/

dcc_mcp_premiere-0.2.0/.release-please-manifest.json

@@ -0,0 +1 @@
+{".":"0.2.0"}

dcc_mcp_premiere-0.2.0/CHANGELOG.md

@@ -0,0 +1,22 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.2.0](https://github.com/dcc-mcp/dcc-mcp-premiere/compare/v0.1.0...v0.2.0) (2026-07-14)
+
+
+### Features
+
+* add Premiere MCP adapter ([0cbf195](https://github.com/dcc-mcp/dcc-mcp-premiere/commit/0cbf1957b69a0891e827686bf9027a5b7b335a23))
+
+
+### Bug Fixes
+
+* make release tests and UXP entry point robust ([f9729c4](https://github.com/dcc-mcp/dcc-mcp-premiere/commit/f9729c440d4019d6e13e5a50aeb40369dc0e2bc8))
+* use valid CI expression syntax ([3d5ba21](https://github.com/dcc-mcp/dcc-mcp-premiere/commit/3d5ba21ddfd294539d5bcee72a27fed79f60f0e8))
+
+## [0.1.0] - 2026-07-14
+
+### Added
+
+- Initial Premiere Pro MCP adapter with UXP bridge and typed project tools.

dcc_mcp_premiere-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dcc-mcp contributors
+
+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.

dcc_mcp_premiere-0.2.0/PKG-INFO

@@ -0,0 +1,42 @@
+Metadata-Version: 2.4
+Name: dcc-mcp-premiere
+Version: 0.2.0
+Summary: MCP adapter for Adobe Premiere Pro
+Project-URL: Homepage, https://github.com/dcc-mcp/dcc-mcp-premiere
+Project-URL: Repository, https://github.com/dcc-mcp/dcc-mcp-premiere
+Author-email: loonghao <hal.long@outlook.com>
+License: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.9
+Requires-Dist: dcc-mcp-core<1.0.0,>=0.19.13
+Provides-Extra: dev
+Requires-Dist: build>=1.2; extra == 'dev'
+Requires-Dist: pytest>=8; extra == 'dev'
+Requires-Dist: ruff>=0.8; extra == 'dev'
+Requires-Dist: twine>=6; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# dcc-mcp-premiere
+
+MCP adapter for Adobe Premiere Pro. It uses a bundled UXP panel as a typed, localhost-only bridge to Premiere's project APIs.
+
+```bash
+pip install dcc-mcp-premiere
+```
+
+Load the installed `dcc_mcp_premiere/premiere_uxp` folder with Adobe UXP Developer Tool in Premiere Pro 25.6 or later. The MCP endpoint defaults to `http://127.0.0.1:8765/mcp`.
+
+Set the same non-default `DCC_MCP_PREMIERE_BRIDGE_TOKEN` in the adapter environment and the UXP panel before production use.
+
+## Tools
+
+- `premiere-project.inspect_project`
+- `premiere-project.list_sequences`
+- `premiere-project.save_project`

dcc_mcp_premiere-0.2.0/README.md

@@ -0,0 +1,17 @@
+# dcc-mcp-premiere
+
+MCP adapter for Adobe Premiere Pro. It uses a bundled UXP panel as a typed, localhost-only bridge to Premiere's project APIs.
+
+```bash
+pip install dcc-mcp-premiere
+```
+
+Load the installed `dcc_mcp_premiere/premiere_uxp` folder with Adobe UXP Developer Tool in Premiere Pro 25.6 or later. The MCP endpoint defaults to `http://127.0.0.1:8765/mcp`.
+
+Set the same non-default `DCC_MCP_PREMIERE_BRIDGE_TOKEN` in the adapter environment and the UXP panel before production use.
+
+## Tools
+
+- `premiere-project.inspect_project`
+- `premiere-project.list_sequences`
+- `premiere-project.save_project`

dcc_mcp_premiere-0.2.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["hatchling>=1.26"]
+build-backend = "hatchling.build"
+
+[project]
+name = "dcc-mcp-premiere"
+version = "0.2.0"
+description = "MCP adapter for Adobe Premiere Pro"
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "loonghao", email = "hal.long@outlook.com" }]
+classifiers = ["Development Status :: 3 - Alpha", "License :: OSI Approved :: MIT License", "Programming Language :: Python :: 3", "Programming Language :: Python :: 3.9", "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12"]
+dependencies = ["dcc-mcp-core>=0.19.13,<1.0.0"]
+
+[project.urls]
+Homepage = "https://github.com/dcc-mcp/dcc-mcp-premiere"
+Repository = "https://github.com/dcc-mcp/dcc-mcp-premiere"
+
+[project.optional-dependencies]
+dev = ["build>=1.2", "pytest>=8", "ruff>=0.8", "twine>=6"]
+
+[project.entry-points."dcc_mcp.adapters"]
+premiere = "dcc_mcp_premiere:PremiereMcpServer"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/dcc_mcp_premiere"]
+artifacts = ["src/dcc_mcp_premiere/skills/**", "src/dcc_mcp_premiere/premiere_uxp/**"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.ruff]
+target-version = "py39"
+line-length = 100
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "B"]
+ignore = ["E501"]

dcc_mcp_premiere-0.2.0/release-please-config.json

@@ -0,0 +1 @@
+{"packages":{".":{"release-type":"python","package-name":"dcc-mcp-premiere","changelog-path":"CHANGELOG.md","include-component-in-tag":false,"extra-files":[{"type":"toml","path":"pyproject.toml","jsonpath":"$.project.version"},{"type":"generic","path":"src/dcc_mcp_premiere/__version__.py"}]}}}

dcc_mcp_premiere-0.2.0/src/dcc_mcp_premiere/__init__.py

@@ -0,0 +1,6 @@
+"""Adobe Premiere Pro MCP adapter."""
+
+from .__version__ import __version__
+from .server import PremiereMcpServer
+
+__all__ = ["PremiereMcpServer", "__version__"]

dcc_mcp_premiere-0.2.0/src/dcc_mcp_premiere/__version__.py

@@ -0,0 +1,3 @@
+"""Package version."""
+
+__version__ = "0.2.0"  # x-release-please-version

dcc_mcp_premiere-0.2.0/src/dcc_mcp_premiere/bridge.py

@@ -0,0 +1,132 @@
+"""Minimal localhost request broker shared by the MCP server and UXP panel."""
+
+from __future__ import annotations
+
+import json
+import os
+import queue
+import threading
+import uuid
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from typing import Any, Optional
+from urllib.request import Request, urlopen
+
+
+class BridgeBroker:
+    """Queue typed requests until the installed Adobe panel completes them."""
+
+    def __init__(self, prefix: str, default_port: int) -> None:
+        self._prefix = prefix
+        self._port = int(os.environ.get(f"{prefix}_BRIDGE_PORT", default_port))
+        self._token = os.environ.get(f"{prefix}_BRIDGE_TOKEN", "dev-token")
+        self._pending: queue.Queue[dict[str, Any]] = queue.Queue()
+        self._waiting: dict[str, tuple[threading.Event, dict[str, Any]]] = {}
+        self._lock = threading.Lock()
+        self._httpd: Optional[ThreadingHTTPServer] = None
+        self._thread: Optional[threading.Thread] = None
+        os.environ.setdefault(f"{prefix}_BRIDGE_URL", f"http://127.0.0.1:{self._port}")
+
+    def start(self) -> None:
+        if self._httpd is not None:
+            return
+        broker = self
+
+        class Handler(BaseHTTPRequestHandler):
+            def do_GET(self):  # noqa: N802
+                if self.path != "/next" or not self._authorized():
+                    return self._send(403, {"error": "forbidden"})
+                self._send(200, broker.next())
+
+            def do_POST(self):  # noqa: N802
+                if not self._authorized():
+                    return self._send(403, {"error": "forbidden"})
+                try:
+                    payload = json.loads(self.rfile.read(int(self.headers["Content-Length"])))
+                except (KeyError, ValueError, json.JSONDecodeError):
+                    return self._send(400, {"error": "invalid JSON"})
+                if self.path == "/call":
+                    try:
+                        return self._send(
+                            200, broker.submit(payload["action"], payload.get("params", {}))
+                        )
+                    except (KeyError, RuntimeError) as error:
+                        return self._send(503, {"error": str(error)})
+                if self.path == "/result":
+                    broker.resolve(
+                        payload.get("id", ""), payload.get("result"), payload.get("error")
+                    )
+                    return self._send(200, {"ok": True})
+                return self._send(404, {"error": "not found"})
+
+            def log_message(self, *_: Any) -> None:
+                return
+
+            def _authorized(self) -> bool:
+                return self.headers.get("X-DCC-MCP-Token") == broker._token
+
+            def _send(self, status: int, payload: dict[str, Any]) -> None:
+                body = json.dumps(payload).encode("utf-8")
+                self.send_response(status)
+                self.send_header("Content-Type", "application/json")
+                self.send_header("Content-Length", str(len(body)))
+                self.end_headers()
+                self.wfile.write(body)
+
+        self._httpd = ThreadingHTTPServer(("127.0.0.1", self._port), Handler)
+        self._thread = threading.Thread(target=self._httpd.serve_forever, daemon=True)
+        self._thread.start()
+
+    def stop(self) -> None:
+        if self._httpd is not None:
+            self._httpd.shutdown()
+            self._httpd.server_close()
+            self._httpd = None
+
+    def submit(self, action: str, params: dict[str, Any], timeout: int = 30) -> dict[str, Any]:
+        request_id = uuid.uuid4().hex
+        completed, result = threading.Event(), {}
+        with self._lock:
+            self._waiting[request_id] = (completed, result)
+        self._pending.put({"id": request_id, "action": action, "params": params})
+        if not completed.wait(timeout):
+            with self._lock:
+                self._waiting.pop(request_id, None)
+            raise RuntimeError("Adobe bridge did not respond; load the bundled panel")
+        if "error" in result:
+            raise RuntimeError(str(result["error"]))
+        return result.get("result", {})
+
+    def next(self) -> dict[str, Any]:
+        try:
+            return self._pending.get(timeout=25)
+        except queue.Empty:
+            return {"id": None}
+
+    def resolve(self, request_id: str, result: Any, error: Any) -> None:
+        with self._lock:
+            waiting = self._waiting.pop(request_id, None)
+        if waiting is None:
+            return
+        completed, payload = waiting
+        if error:
+            payload["error"] = error
+        else:
+            payload["result"] = result if isinstance(result, dict) else {"value": result}
+        completed.set()
+
+
+def call_bridge(prefix: str, action: str, params: dict[str, Any]) -> dict[str, Any]:
+    """Call a running adapter-local bridge from a skill subprocess."""
+    url = os.environ[f"{prefix}_BRIDGE_URL"].rstrip("/") + "/call"
+    token = os.environ.get(f"{prefix}_BRIDGE_TOKEN", "dev-token")
+    request = Request(
+        url,
+        data=json.dumps({"action": action, "params": params}).encode("utf-8"),
+        headers={"Content-Type": "application/json", "X-DCC-MCP-Token": token},
+        method="POST",
+    )
+    with urlopen(request, timeout=35) as response:  # noqa: S310 - loopback URL is adapter-owned.
+        payload = json.loads(response.read().decode("utf-8"))
+    if "error" in payload:
+        raise RuntimeError(payload["error"])
+    return payload

dcc_mcp_premiere-0.2.0/src/dcc_mcp_premiere/premiere_uxp/index.html

@@ -0,0 +1 @@
+<!doctype html><html><body><script src="index.js"></script>DCC MCP bridge connected.</body></html>

dcc_mcp_premiere-0.2.0/src/dcc_mcp_premiere/premiere_uxp/index.js

@@ -0,0 +1,25 @@
+const app = require("premierepro");
+const baseUrl = "http://127.0.0.1:47393";
+const token = "dev-token"; // Set the same value as DCC_MCP_PREMIERE_BRIDGE_TOKEN before production use.
+
+async function reply(id, result, error) {
+  await fetch(`${baseUrl}/result`, {method: "POST", headers: {"Content-Type": "application/json", "X-DCC-MCP-Token": token}, body: JSON.stringify({id, result, error})});
+}
+
+function project() { return app.project; }
+function dispatch(job) {
+  const current = project();
+  if (job.action === "inspect_project") return {project_name: current.name || null, active_sequence: current.activeSequence ? current.activeSequence.name : null};
+  if (job.action === "list_sequences") return {sequences: Array.from(current.sequences || []).map(sequence => ({name: sequence.name})), sequence_count: (current.sequences || []).length || 0};
+  if (job.action === "save_project") { current.save(); return {saved: true}; }
+  throw new Error(`Unsupported action: ${job.action}`);
+}
+
+async function poll() {
+  try {
+    const response = await fetch(`${baseUrl}/next`, {headers: {"X-DCC-MCP-Token": token}});
+    const job = await response.json();
+    if (job.id) { try { await reply(job.id, dispatch(job), null); } catch (error) { await reply(job.id, null, String(error)); } }
+  } finally { setTimeout(poll, 50); }
+}
+poll();

dcc_mcp_premiere-0.2.0/src/dcc_mcp_premiere/premiere_uxp/manifest.json

@@ -0,0 +1 @@
+{"id":"com.dccmcp.premiere","name":"DCC MCP Premiere Bridge","version":"0.1.0","manifestVersion":5,"host":[{"app":"premierepro","minVersion":"25.6.0"}],"requiredPermissions":{"network":{"domains":["http://127.0.0.1"]}},"entrypoints":[{"type":"panel","id":"dccMcp","label":"DCC MCP","main":"index.html"}]}

dcc_mcp_premiere-0.2.0/src/dcc_mcp_premiere/server.py

@@ -0,0 +1,57 @@
+"""Premiere Pro MCP server lifecycle."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Optional
+
+from dcc_mcp_core import DccServerOptions
+from dcc_mcp_core.server_base import DccServerBase
+
+from .__version__ import __version__
+from .bridge import BridgeBroker
+
+DEFAULT_PORT = 8765
+_server: Optional["PremiereMcpServer"] = None
+
+
+class PremiereMcpServer(DccServerBase):
+    """MCP server whose typed calls are completed by the UXP panel."""
+
+    def __init__(self, port: int = DEFAULT_PORT) -> None:
+        self.bridge = BridgeBroker("DCC_MCP_PREMIERE", 47393)
+        options = DccServerOptions.from_env(
+            "premiere",
+            Path(__file__).resolve().parent / "skills",
+            port=port,
+            server_name="dcc-mcp-premiere",
+            server_version=__version__,
+        )
+        super().__init__(options=options)
+
+    def start(self, **kwargs):
+        self.bridge.start()
+        return super().start(**kwargs)
+
+    def stop(self) -> None:
+        super().stop()
+        self.bridge.stop()
+
+
+def start_server(port: Optional[int] = None) -> PremiereMcpServer:
+    global _server
+    if _server is None or not _server.is_running:
+        _server = PremiereMcpServer(
+            port or int(os.environ.get("DCC_MCP_PREMIERE_PORT", DEFAULT_PORT))
+        )
+        _server.register_builtin_actions()
+        _server.start()
+    return _server
+
+
+def stop_server() -> None:
+    global _server
+    if _server is not None:
+        _server.stop()
+        _server = None

dcc_mcp_premiere-0.2.0/src/dcc_mcp_premiere/skills/premiere-project/SKILL.md

@@ -0,0 +1,20 @@
+---
+name: premiere-project
+description: >-
+  Host skill - inspect sequences and explicitly save the active Premiere project.
+  Use when working with Premiere projects. Not for raw JavaScript execution.
+license: MIT
+compatibility: "Premiere Pro 25.6+ UXP; dcc-mcp-core 0.19+"
+allowed-tools: Python
+metadata:
+  dcc-mcp:
+    dcc: premiere
+    version: "0.1.0"
+    layer: domain
+    stage: scene
+    search-hint: "premiere project sequence inspect save"
+    tags: "adobe, premiere, video, sequence"
+    tools: tools.yaml
+---
+
+# Premiere Project

dcc_mcp_premiere-0.2.0/src/dcc_mcp_premiere/skills/premiere-project/scripts/inspect_project.py

@@ -0,0 +1,16 @@
+from dcc_mcp_core.skill import skill_entry, skill_success
+
+from dcc_mcp_premiere.bridge import call_bridge
+
+
+@skill_entry
+def main(**_kwargs):
+    return skill_success(
+        "Premiere project inspected.", **call_bridge("DCC_MCP_PREMIERE", "inspect_project", {})
+    )
+
+
+if __name__ == "__main__":
+    from dcc_mcp_core.skill import run_main
+
+    run_main(main)

dcc_mcp_premiere-0.2.0/src/dcc_mcp_premiere/skills/premiere-project/scripts/list_sequences.py

@@ -0,0 +1,16 @@
+from dcc_mcp_core.skill import skill_entry, skill_success
+
+from dcc_mcp_premiere.bridge import call_bridge
+
+
+@skill_entry
+def main(**_kwargs):
+    return skill_success(
+        "Premiere sequences listed.", **call_bridge("DCC_MCP_PREMIERE", "list_sequences", {})
+    )
+
+
+if __name__ == "__main__":
+    from dcc_mcp_core.skill import run_main
+
+    run_main(main)

dcc_mcp_premiere-0.2.0/src/dcc_mcp_premiere/skills/premiere-project/scripts/save_project.py

@@ -0,0 +1,16 @@
+from dcc_mcp_core.skill import skill_entry, skill_success
+
+from dcc_mcp_premiere.bridge import call_bridge
+
+
+@skill_entry
+def main(**_kwargs):
+    return skill_success(
+        "Premiere project saved.", **call_bridge("DCC_MCP_PREMIERE", "save_project", {})
+    )
+
+
+if __name__ == "__main__":
+    from dcc_mcp_core.skill import run_main
+
+    run_main(main)

dcc_mcp_premiere-0.2.0/src/dcc_mcp_premiere/skills/premiere-project/tools.yaml

@@ -0,0 +1,31 @@
+tools:
+  - name: inspect_project
+    description: Return the active Premiere project and sequence metadata.
+    input_schema: {type: object, properties: {}}
+    read_only: true
+    destructive: false
+    idempotent: true
+    execution: sync
+    affinity: any
+    timeout_hint_secs: 30
+    source_file: scripts/inspect_project.py
+  - name: list_sequences
+    description: List sequences in the active Premiere project.
+    input_schema: {type: object, properties: {}}
+    read_only: true
+    destructive: false
+    idempotent: true
+    execution: sync
+    affinity: any
+    timeout_hint_secs: 30
+    source_file: scripts/list_sequences.py
+  - name: save_project
+    description: Save the current Premiere project through the loaded UXP panel.
+    input_schema: {type: object, properties: {}}
+    read_only: false
+    destructive: true
+    idempotent: false
+    execution: sync
+    affinity: any
+    timeout_hint_secs: 60
+    source_file: scripts/save_project.py

dcc_mcp_premiere-0.2.0/tests/test_bridge.py

@@ -0,0 +1,16 @@
+import threading
+
+from dcc_mcp_premiere.bridge import BridgeBroker
+
+
+def test_broker_delivers_and_resolves_a_typed_request():
+    broker = BridgeBroker("TEST_PREMIERE", 0)
+    result = {}
+    thread = threading.Thread(
+        target=lambda: result.setdefault("value", broker.submit("inspect_project", {}))
+    )
+    thread.start()
+    job = broker.next()
+    broker.resolve(job["id"], {"project_name": "demo"}, None)
+    thread.join(timeout=1)
+    assert result["value"] == {"project_name": "demo"}

dcc_mcp_premiere-0.2.0/tests/test_package.py

@@ -0,0 +1,17 @@
+import json
+from pathlib import Path
+
+from dcc_mcp_premiere import __version__
+
+
+def test_version_metadata_is_synchronized():
+    root = Path(__file__).parents[1]
+    assert f'version = "{__version__}"' in (root / "pyproject.toml").read_text(encoding="utf-8")
+    manifest = json.loads((root / ".release-please-manifest.json").read_text(encoding="utf-8"))
+    assert manifest["."] == __version__
+
+
+def test_uxp_panel_is_packaged_with_source():
+    panel = Path(__file__).parents[1] / "src" / "dcc_mcp_premiere" / "premiere_uxp"
+    assert (panel / "manifest.json").is_file()
+    assert (panel / "index.js").is_file()

dcc_mcp_premiere-0.2.0/tools/lint_skills.py

@@ -0,0 +1,8 @@
+from pathlib import Path
+
+from dcc_mcp_core import validate_skill
+
+skills_root = Path(__file__).parents[1] / "src" / "dcc_mcp_premiere" / "skills"
+reports = [validate_skill(str(path)) for path in skills_root.iterdir() if path.is_dir()]
+assert all(report.is_clean for report in reports), [report.issues for report in reports]
+print(f"validated {len(reports)} bundled skills")