pycforge-sdk 0.6.3__py3-none-any.whl

pycforge_sdk/gui/editor.py

@@ -0,0 +1,412 @@
+"""Explained project forms. Engine reference data supplies operation choices."""
+import copy
+import json
+from PySide6.QtCore import Signal, Qt
+from PySide6.QtWidgets import (QWidget, QVBoxLayout, QHBoxLayout, QFormLayout,
+    QTabWidget, QScrollArea, QLineEdit, QPlainTextEdit, QComboBox, QSpinBox,
+    QGroupBox, QListWidget, QSplitter, QDialog, QCheckBox)
+from ..project import parse
+from ..results import SDKError
+from .widgets import label, button
+from .dialogs import Dialog
+from .jobs import JobRunner
+
+
+class DraftDialog(Dialog):
+    close_pending = False
+    def reject(self):
+        if self.runner.busy:
+            self.close_pending = True
+            self.runner.cancel()
+            self.problem.setText("Canceling draft validation…")
+            return
+        super().reject()
+
+    def closeEvent(self, event):
+        event.ignore(); self.reject()
+
+
+def pointer(parts):
+    return "/" + "/".join(str(p).replace("~", "~0").replace("/", "~1") for p in parts)
+
+
+class ProjectEditor(QWidget):
+    changed = Signal()
+    source_requested = Signal(str)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.layout = QVBoxLayout(self)
+        self.layout.setContentsMargins(0, 0, 0, 0)
+        self.tabs = QTabWidget()
+        self.layout.addWidget(self.tabs)
+        self.fields = {}
+        self.draft = None
+        self.methods, self.operations = [], []
+        self.workbench = None
+
+    def load(self, document, *, methods=(), operations=(), workbench=None):
+        self.draft = copy.deepcopy(document)
+        self.methods, self.operations = methods, operations
+        self.workbench = workbench
+        self.fields = {}
+        while self.tabs.count():
+            page = self.tabs.widget(0); self.tabs.removeTab(0); page.deleteLater()
+        self.project_page()
+        self.function_page()
+        self.help_page()
+        self.fixtures_page()
+
+    def page(self, title, description):
+        body = QWidget(); layout = QVBoxLayout(body)
+        layout.addWidget(label(description, muted=True))
+        scroll = QScrollArea(); scroll.setWidgetResizable(True); scroll.setWidget(body)
+        self.tabs.addTab(scroll, title)
+        return layout, scroll
+
+    def get(self, parts):
+        value = self.draft
+        for part in parts: value = value[part]
+        return value
+
+    def put(self, parts, value):
+        target = self.draft
+        for part in parts[:-1]: target = target[part]
+        target[parts[-1]] = value
+        self.changed.emit()
+
+    def field(self, form, title, parts, description="", *, choices=None, multiline=False, page=None):
+        value = self.get(parts)
+        if choices:
+            edit = QComboBox()
+            for choice in choices: edit.addItem(str(choice), choice)
+            index = next((i for i in range(edit.count()) if type(edit.itemData(i)) is type(value) and edit.itemData(i) == value), -1)
+            if index < 0: edit.addItem(str(value), value); index = edit.count()-1
+            edit.setCurrentIndex(index)
+            edit.currentIndexChanged.connect(lambda _i: self.put(parts, edit.currentData()))
+        elif type(value) is int:
+            edit = QSpinBox(); edit.setRange(-2147483647, 2147483647); edit.setValue(value)
+            edit.valueChanged.connect(lambda v: self.put(parts, v))
+        elif multiline:
+            edit = QPlainTextEdit(str(value)); edit.setMinimumHeight(86); edit.setMaximumHeight(150)
+            edit.textChanged.connect(lambda: self.put(parts, edit.toPlainText()))
+        else:
+            edit = QLineEdit(str(value))
+            edit.textChanged.connect(lambda v: self.put(parts, v))
+        edit.setAccessibleName(title)
+        edit.setAccessibleDescription(description)
+        edit.setToolTip(description)
+        caption = label(title); caption.setBuddy(edit)
+        form.addRow(caption, edit)
+        if description:
+            hint = label(description, muted=True)
+            form.addRow("", hint)
+        self.fields[pointer(parts)] = (edit, page)
+        return edit
+
+    def reference(self, name):
+        return next((e for e in self.methods if e["id"].endswith("." + name)), {})
+
+    def profile(self):
+        schema = self.draft.get("declaration", {}).get("schema")
+        return next((p for p in (self.workbench or {}).get("profiles", []) if p["declaration_schema"] == schema), None)
+
+    def engine_field(self, form, definition, parts, page):
+        """Render inert field metadata; never import a renderer from the engine."""
+        title, kind = definition["title"], definition["kind"]
+        description = definition.get("description", "")
+        value = self.get(parts)
+        if kind == "boolean" and type(value) is bool:
+            control = QCheckBox(title); control.setChecked(value)
+            control.toggled.connect(lambda checked: self.put(parts, checked))
+            form.addRow(control)
+        elif kind == "json" or (kind != "choice" and type(value) is not str):
+            control = button("Edit value…", "details", lambda: self.edit_value(parts, title, control))
+            control.setToolTip(json.dumps(value, ensure_ascii=False))
+            form.addRow(label(title), control)
+        else:
+            options = definition.get("options", [])
+            control = self.field(form, title, parts, description,
+                choices=[o["value"] for o in options] if options else None,
+                multiline=kind == "multiline", page=page)
+            if isinstance(control, QComboBox):
+                for row in range(control.count()):
+                    option = next((o for o in options if o["value"] == control.itemData(row)), None)
+                    if option:
+                        control.setItemText(row, option["title"])
+                        control.setItemData(row, option.get("description", ""), Qt.ItemDataRole.ToolTipRole)
+            return control
+        control.setAccessibleName(title); control.setAccessibleDescription(description)
+        if description: form.addRow("", label(description, muted=True))
+        self.fields[pointer(parts)] = (control, page)
+        return control
+
+    def edit_value(self, parts, title, control):
+        dlg = Dialog(title, self)
+        dlg.body.addWidget(label("Edit this value as JSON. The connected engine validates its conversion meaning when you scan."))
+        source = QPlainTextEdit(json.dumps(self.get(parts), indent=2)); source.setAccessibleName(title)
+        dlg.body.addWidget(source, 1); problem = label(""); dlg.body.addWidget(problem)
+        def apply():
+            try:
+                if len(source.toPlainText().encode('utf-8')) > 256 * 1024:
+                    raise SDKError("SDK_LIMIT", "The value exceeds the editor size budget.")
+                value = parse(source.toPlainText())
+            except SDKError as exc:
+                problem.setText(str(exc)); return
+            self.put(parts, value); control.setToolTip(json.dumps(value, ensure_ascii=False)); dlg.accept()
+        row = QHBoxLayout(); row.addWidget(button("Apply", "check", apply)); row.addWidget(button("Cancel", "cancel", dlg.reject))
+        dlg.body.addLayout(row); dlg.resize(650, 440); dlg.exec()
+
+    def project_page(self):
+        layout, page = self.page("Project", "Give this conversion extension a clear identity. Changing any saved field requires fresh verification.")
+        form = QFormLayout(); layout.addLayout(form)
+        descriptions = {
+            "package_id": "Stable package identity, for example org.example.vectors.",
+            "namespace": "The name used in the editor after *import.",
+            "version": "The version you intend to package. Publishing remains your separate decision.",
+            "author": "The person or organization responsible for this extension.",
+            "description": "A short explanation of what this extension provides.",
+            "created": "Creation date recorded in the package metadata.", "license": "The license for your extension."}
+        profile = self.profile()
+        if profile:
+            for definition in profile["fields"]:
+                key = definition["name"]
+                if key in self.draft.get("declaration", {}):
+                    self.engine_field(form, definition, ["declaration", key], page)
+        else:
+            for key in ("package_id", "namespace", "version"):
+                if key in self.draft.get("declaration", {}):
+                    self.field(form, key.replace("_", " ").title(), ["declaration", key], descriptions[key], page=page)
+        for key in ("author", "description", "created", "license"):
+            self.field(form, key.title(), ["metadata", key], descriptions[key], multiline=key=="description", page=page)
+        layout.addWidget(button("Advanced project data…", "details", self.advanced,
+            "Edit the complete JSON project. Keep normal work in the explained forms."))
+        layout.addStretch()
+
+    def function_page(self):
+        layout, page = self.page("Functions", "Choose a function to explain its conversion contract. The connected engine defines the available operations.")
+        self.function_choice = QComboBox()
+        for f in self.draft.get("declaration", {}).get("functions", []):
+            self.function_choice.addItem(f.get("export", "Unnamed function"))
+        self.function_choice.setAccessibleName("Function")
+        layout.addWidget(self.function_choice)
+        self.function_holder = QWidget(); self.function_layout = QVBoxLayout(self.function_holder)
+        self.function_layout.setContentsMargins(0, 0, 0, 0)
+        layout.addWidget(self.function_holder); layout.addStretch()
+        self.function_tab = page
+        self.function_choice.currentIndexChanged.connect(self.show_function)
+        self.show_function(0)
+
+    def clear(self, layout, prefix):
+        for key in list(self.fields):
+            if key.startswith(prefix): del self.fields[key]
+        while layout.count():
+            item = layout.takeAt(0)
+            if item.widget(): item.widget().hide(); item.widget().deleteLater()
+
+    def show_function(self, index):
+        self.clear(self.function_layout, "/declaration/functions/")
+        functions = self.draft.get("declaration", {}).get("functions", [])
+        if not 0 <= index < len(functions): return
+        function = functions[index]
+        if self.workbench is not None:
+            self.show_engine_function(index, function)
+            return
+        array = self.draft["declaration"].get("schema", "").startswith("crucible.array-")
+        ref = self.reference("ArrayFunction" if array else "ScalarFunction")
+        params = {p["name"]: p for p in ref.get("parameters", [])}
+        body = QWidget(); form = QFormLayout(body); self.function_layout.addWidget(body)
+        for key in ("operation_id", "export", "operation", "summary") if array else ("operation_id", "export", "native_symbol", "summary"):
+            if key not in function: continue
+            choices = [o["id"] for o in self.operations] if key == "operation" else None
+            control = self.field(form, {"operation_id": "Stable identity", "export": "Editor name", "operation": "Operation", "native_symbol": "Native symbol", "summary": "Summary"}[key],
+                       ["declaration", "functions", index, key], params.get(key, {}).get("description", ""),
+                       choices=choices, multiline=key=="summary", page=self.function_tab)
+            if key == "summary": control.setMaximumHeight(96)
+            if key == "operation" and isinstance(control, QComboBox):
+                for row in range(control.count()):
+                    choice = next((o for o in self.operations if o["id"] == control.itemData(row)), None)
+                    if choice: control.setItemText(row, choice["title"])
+        if array:
+            self.contract = label("")
+            self.function_layout.addWidget(self.contract)
+            def explain():
+                value = function.get("operation")
+                operation = next((o for o in self.operations if o["id"] == value), {})
+                signature = operation.get("signature", "").replace("function(", function.get("export", "function") + "(", 1)
+                self.contract.setText(signature + "\n" + operation.get("description", "") +
+                    "\nThe engine owns array type, storage and cleanup.")
+            field = self.fields.get(pointer(["declaration", "functions", index, "operation"]))
+            if field and isinstance(field[0], QComboBox): field[0].currentIndexChanged.connect(explain)
+            explain()
+        else:
+            advanced = QGroupBox("More contract settings")
+            advanced.setCheckable(True); advanced.setChecked(False)
+            outer = QVBoxLayout(advanced); details = QWidget(); detail_form = QFormLayout(details)
+            outer.addWidget(details); details.setVisible(False); advanced.toggled.connect(details.setVisible)
+            for key, value in function.items():
+                if key in ("operation_id", "export", "native_symbol", "summary"): continue
+                if isinstance(value, (dict, list)):
+                    detail_form.addRow(label(key.title() + ": " + json.dumps(value)),
+                                       button("Edit data…", "details", self.advanced))
+                else:
+                    self.field(detail_form, key.replace("_", " ").title(), ["declaration", "functions", index, key],
+                               params.get(key, {}).get("description", ""), choices=params.get(key, {}).get("choices"), page=self.function_tab)
+            self.function_layout.addWidget(advanced)
+
+    def show_engine_function(self, index, function):
+        profile = self.profile()
+        if profile is None:
+            self.function_layout.addWidget(label("The engine does not advertise a form for this declaration. Use Advanced project data, then Scan to check it."))
+            return
+        self.function_layout.addWidget(label(profile.get("description", ""), muted=True))
+        body = QWidget(); form = QFormLayout(body); self.function_layout.addWidget(body)
+        advanced = QGroupBox("More contract settings"); advanced.setCheckable(True); advanced.setChecked(False)
+        outer = QVBoxLayout(advanced); details = QWidget(); detail_form = QFormLayout(details)
+        outer.addWidget(details); details.hide(); advanced.toggled.connect(details.setVisible)
+        has_advanced = False
+        for definition in profile["function_fields"]:
+            key = definition["name"]
+            if key not in function: continue
+            is_advanced = definition.get("advanced", False)
+            has_advanced |= is_advanced
+            self.engine_field(detail_form if is_advanced else form, definition,
+                              ["declaration", "functions", index, key], self.function_tab)
+        if has_advanced: self.function_layout.addWidget(advanced)
+        else: advanced.deleteLater()
+        self.contract = label(""); self.function_layout.addWidget(self.contract)
+        operation_field = profile.get("operation_field", "")
+        definition = next((f for f in profile["function_fields"] if f["name"] == operation_field), {})
+        def explain():
+            option = next((o for o in definition.get("options", []) if o["value"] == function.get(operation_field)), {})
+            signature = option.get("signature", "").replace("function(", function.get("export", "function") + "(", 1)
+            self.contract.setText("\n".join(part for part in (signature, option.get("description", ""), profile.get("contract_note", "")) if part))
+        selected = self.fields.get(pointer(["declaration", "functions", index, operation_field]))
+        if selected and isinstance(selected[0], QComboBox): selected[0].currentIndexChanged.connect(explain)
+        explain()
+
+    def help_page(self):
+        layout, page = self.page("Help", "Write the offline manual that ships inside the extension. Scanner findings take you directly to unfinished fields.")
+        self.help_tab = page
+        doc = self.draft.get("documentation")
+        if not isinstance(doc, dict):
+            layout.addWidget(label("This project needs Help fields. Choose Tools → Add missing Help fields, then fill in your explanations.")); return
+        form = QFormLayout(); layout.addLayout(form)
+        for key in ("overview", "usage", "limitations", "release_notes"):
+            if key in doc:
+                self.field(form, key.replace("_", " ").title(), ["documentation", key], multiline=True, page=page)
+        self.help_choice = QComboBox()
+        for name in doc.get("functions", {}): self.help_choice.addItem(name)
+        self.help_choice.setAccessibleName("Documented function")
+        layout.addWidget(label("Function explanations")); layout.addWidget(self.help_choice)
+        self.help_holder = QWidget(); self.help_layout = QVBoxLayout(self.help_holder)
+        self.help_layout.setContentsMargins(0, 0, 0, 0)
+        layout.addWidget(self.help_holder)
+        self.help_choice.currentTextChanged.connect(self.show_function_help)
+        self.show_function_help(self.help_choice.currentText())
+        constants = doc.get("constants", {})
+        if constants:
+            cform = QFormLayout(); layout.addLayout(cform)
+            for key in constants:
+                self.field(cform, "Constant: " + key, ["documentation", "constants", key], multiline=True, page=page)
+        layout.addStretch()
+
+    def show_function_help(self, name):
+        self.clear(self.help_layout, "/documentation/functions/")
+        function = self.draft.get("documentation", {}).get("functions", {}).get(name)
+        if not isinstance(function, dict): return
+        body = QWidget(); form = QFormLayout(body); self.help_layout.addWidget(body)
+        prefix = ["documentation", "functions", name]
+        for i, value in enumerate(function.get("parameters", [])):
+            self.field(form, f"Parameter {i+1}", prefix + ["parameters", i], multiline=True, page=self.help_tab)
+        for key in ("returns", "details", "example"):
+            if key not in function: continue
+            choices = [c["name"] for c in self.draft["cases"] if c["expect"]["kind"] == "run"] if key == "example" else None
+            self.field(form, "Native example" if key == "example" else key.title(), prefix+[key],
+                       "Choose a passing native fixture containing this function." if key=="example" else "",
+                       choices=choices, multiline=key != "example", page=self.help_tab)
+
+    def fixtures_page(self):
+        layout, page = self.page("Fixtures", "Expected results are your reference. Verify compiles and runs every native fixture, and checks every expected conversion rejection.")
+        self.fixture_tab = page
+        self.fixture_choice = QComboBox()
+        for case in self.draft.get("cases", []): self.fixture_choice.addItem(case["name"])
+        self.fixture_choice.setAccessibleName("Fixture")
+        layout.addWidget(self.fixture_choice)
+        self.fixture_holder = QWidget(); self.fixture_layout = QVBoxLayout(self.fixture_holder)
+        self.fixture_layout.setContentsMargins(0, 0, 0, 0)
+        layout.addWidget(self.fixture_holder); layout.addStretch()
+        self.fixture_choice.currentIndexChanged.connect(self.show_fixture)
+        self.show_fixture(0)
+
+    def show_fixture(self, index):
+        self.clear(self.fixture_layout, "/cases/")
+        cases = self.draft.get("cases", [])
+        if not 0 <= index < len(cases): return
+        case = cases[index]
+        body = QWidget(); form = QFormLayout(body); self.fixture_layout.addWidget(body)
+        self.fixture_layout.addWidget(label("Source: " + case["file"] + "\nExpected kind: " + case["expect"]["kind"]))
+        self.fixture_layout.addWidget(button("Edit fixture source…", "go-to-source", lambda: self.source_requested.emit(case["file"])))
+        for key in case["expect"]:
+            if key == "kind": continue
+            self.field(form, "Expected " + key.replace("_", " "), ["cases", index, "expect", key],
+                       multiline=key in ("stdout", "stderr"), page=self.fixture_tab)
+
+    def focus_path(self, path):
+        parts = [p.replace("~1", "/").replace("~0", "~") for p in path.split("/")[1:]]
+        if len(parts) >= 3 and parts[:2] == ["documentation", "functions"] and hasattr(self, "help_choice"):
+            self.help_choice.setCurrentText(parts[2])
+        if len(parts) >= 3 and parts[:2] == ["declaration", "functions"] and parts[2].isdigit():
+            self.function_choice.setCurrentIndex(int(parts[2]))
+        if len(parts) >= 2 and parts[0] == "cases" and parts[1].isdigit():
+            self.fixture_choice.setCurrentIndex(int(parts[1]))
+        target = self.fields.get(path)
+        if target:
+            widget, page = target
+            self.tabs.setCurrentWidget(page)
+            ancestor = widget.parentWidget()
+            while ancestor and ancestor is not page:
+                if isinstance(ancestor, QGroupBox) and ancestor.isCheckable(): ancestor.setChecked(True)
+                ancestor = ancestor.parentWidget()
+            widget.setFocus(); page.ensureWidgetVisible(widget)
+            return True
+        if parts and parts[0] == "cases":
+            self.tabs.setCurrentWidget(self.fixture_tab); self.fixture_choice.setFocus(); return True
+        if parts[:2] == ["declaration", "functions"]:
+            self.tabs.setCurrentWidget(self.function_tab); self.function_choice.setFocus(); return True
+        if parts and parts[0] == "documentation":
+            self.tabs.setCurrentWidget(self.help_tab); return True
+        if parts and parts[0] == "metadata":
+            self.tabs.setCurrentIndex(0); return True
+        return False
+
+    def advanced(self):
+        dlg = DraftDialog("Advanced project data", self)
+        dlg.body.addWidget(label("Edit declaration details or fixture definitions as JSON. The scanner checks the saved result through the selected engine. New fixture files must already exist in the project."))
+        source = QPlainTextEdit(json.dumps(self.draft, indent=2)); source.setAccessibleName("Project JSON")
+        dlg.body.addWidget(source, 1)
+        problem = label(""); dlg.problem = problem; dlg.body.addWidget(problem)
+        dlg.runner = JobRunner(dlg)
+        # Validate JSON before accepting. Engine validation remains in Scan.
+        def apply():
+            try:
+                draft = parse(source.toPlainText())
+                if type(draft) is not dict or not {"declaration", "metadata", "cases"} <= draft.keys():
+                    raise SDKError("SDK_PROJECT", "Keep the project declaration, metadata and cases.")
+            except (SDKError, TypeError, ValueError) as exc:
+                problem.setText(str(exc)); return
+            source.setReadOnly(True); apply_button.setEnabled(False)
+            dlg.runner.start(self.configuration, "validate_project", (self.directory, draft),
+                             {"expected_sha256": self.expected_sha256})
+        def validated(method, result, revision):
+            source.setReadOnly(False); apply_button.setEnabled(True)
+            if dlg.close_pending:
+                dlg.reject(); return
+            if result["status"] != "succeeded":
+                problem.setText("\n".join(d["message"] for d in result["diagnostics"])); return
+            self.load(result["data"]["document"], methods=self.methods, operations=self.operations, workbench=self.workbench)
+            self.changed.emit(); dlg.accept()
+        dlg.runner.finished.connect(validated)
+        row = QHBoxLayout(); apply_button = button("Apply draft", "check", apply)
+        row.addWidget(apply_button); row.addWidget(button("Cancel", "cancel", dlg.reject))
+        dlg.body.addLayout(row); dlg.resize(900, 650); dlg.exec()

pycforge_sdk/gui/help/index.html

@@ -0,0 +1,9 @@
+<!doctype html><html lang="en"><head><meta charset="utf-8"><title>PyCForge SDK — Getting started</title></head><body>
+<h1>PyCForge SDK</h1><p>Create conversion extensions using the installed PyCForge engine. This short guide is available before an engine is connected.</p>
+<h2>Find PyCForge</h2><p>The startup panel searches your saved connection and common Python installations. Choose among several engines, or use Locate PyCForge if it cannot be found. Select the installation, Python environment, installed Crucible support folder or Python interpreter. The custom picker has drive shortcuts. A source folder alone needs a working installed engine.</p>
+<p>Continue offline opens local projects and any cached reference. Engine and tools exposes advanced interpreter and compiler settings. This Python selects the SDK interpreter; Refresh checks it. PyCForge’s About → Distribution → SDK Python shows its exact interpreter.</p>
+<h2>Learn from your engine</h2><p>After connection, the Help topic selector offers the SDK guide and conversion-import manuals supplied by PyCForge’s Crucible folder. Authoring forms, operation choices and starter projects also come from that installation. Refresh after updating PyCForge. Cached guides remain readable offline; their engine and connection state are displayed above.</p>
+<h2>Author and check</h2><p>Choose New or Open, edit the declaration and Help, save, then Scan. Verify fixtures explicitly converts, compiles and runs the saved examples. <b>Ready to package</b> means the current saved project matches passing evidence for its declared fixtures and recorded environment. Package and registration are separate actions. Changes to projects or tools require fresh verification.</p>
+<h2>Recovery</h2><p>Activity contains diagnostics. Unsaved edits and outside file changes clear readiness. A failed refresh preserves compatible cached reference; it cannot authorize execution. Closing during work requests cancellation and waits for the worker. Windows direct-process termination does not supervise arbitrary descendant process trees.</p>
+<h2>Keyboard</h2><p>Ctrl+N: New; Ctrl+O: Open; Ctrl+S: Save; F5: Scan; F6: Verify fixtures; Ctrl+B: Package; F1: Help.</p>
+</body></html>

pycforge_sdk/gui/identity.py

@@ -0,0 +1,139 @@
+"""SDK-only copper accents over the preserved PyCForge presentation layer."""
+from pathlib import Path
+from PySide6.QtCore import Qt, QSize
+from PySide6.QtGui import QIcon
+from PySide6.QtWidgets import QFrame, QHBoxLayout, QLabel, QSizePolicy, QVBoxLayout
+
+
+COPPER = "#D99B6B"
+COPPER_BRIGHT = "#F0BB91"
+COPPER_SURFACE = "#3B3028"
+
+# Applied to SDK windows, never to QApplication or the shared visual modules.
+# Brand emphasis is separate from success/warning/error status colors.
+SDK_QSS = """
+QFrame#SDKEngineLink {
+    background: #262D34; border: 1px solid #4C5965;
+    border-left: 4px solid #D99B6B; border-radius: 6px;
+}
+QLabel#SDKConnectionTitle { color: #E0E5E9; font-size: 15px; font-weight: 700; }
+QLabel#SDKConnectionTag { color: #F0BB91; font-size: 11px; font-weight: 700; }
+QLabel#SDKWelcomeTitle { color: #F0BB91; font-size: 24px; font-weight: 600; }
+QLabel#SDKConnectionPath { color: #A7B4BE; }
+QWidget#SDKConnectionSettings { border: none; }
+QDialog#SDKStartup { background: #1B2127; }
+QFrame#SDKBrand {
+    background: #262D34;
+    border: 1px solid #4C5965;
+    border-top: 2px solid #D99B6B;
+    border-radius: 5px;
+}
+QLabel#SDKProductName { color: #E0E5E9; font-size: 16px; font-weight: 700; }
+QLabel#SDKBadge {
+    color: #F0BB91; background: #3B3028;
+    border: 1px solid #A5714C; border-radius: 4px;
+    font-weight: 700; padding: 3px 6px;
+}
+QLabel#SDKBrandCaption { color: #A7B4BE; font-size: 11px; }
+QListWidget#DocumentList:focus { border-color: #D99B6B; border-bottom-color: #D99B6B; }
+QListWidget#DocumentList::item:selected {
+    color: #F0BB91; background: #3B3028;
+    border: 1px solid #A5714C; border-left: 3px solid #D99B6B;
+}
+QListWidget#DocumentList::item:selected:hover { background: #49382B; }
+QTabBar::tab:selected, QTabBar::tab:hover:enabled {
+    border-bottom: 2px solid #D99B6B;
+}
+QMenuBar::item:selected, QMenuBar::item:pressed { border-bottom: 2px solid #D99B6B; }
+QMenu#PyCForgeMenu::item:selected:enabled {
+    background: #3B3028; border-left: 3px solid #D99B6B;
+}
+QMenu#PyCForgeMenu::item:pressed:enabled {
+    background: #49382B; border-left: 3px solid #D99B6B; border-bottom: 2px solid #D99B6B;
+}
+QPushButton[sdkAccent="true"]:enabled, QToolButton[sdkAccent="true"]:enabled {
+    color: #F0BB91; border-bottom: 2px solid #D99B6B;
+}
+QPushButton[sdkAccent="true"]:hover:enabled, QToolButton[sdkAccent="true"]:hover:enabled {
+    background: #3B3028; border-color: #D99B6B;
+}
+QPushButton[sdkAccent="true"]:pressed:enabled, QToolButton[sdkAccent="true"]:pressed:enabled {
+    background: #49382B; border-color: #F0BB91;
+}
+QPushButton[sdkAccent="true"]:disabled, QToolButton[sdkAccent="true"]:disabled {
+    color: #95A1AB; background: #262D34;
+    border-color: #4C5965; border-bottom: 1px solid #4C5965;
+}
+QLineEdit:focus, QPlainTextEdit:focus, QComboBox:focus,
+QPushButton[sdkAccent="true"]:focus, QToolButton[sdkAccent="true"]:focus {
+    border-color: #D99B6B;
+}
+QFrame#DialogTitleBar { border-bottom: 2px solid #D99B6B; }
+QProgressBar::chunk { background: #87502D; }
+"""
+
+
+class PathLabel(QLabel):
+    """An exact path in the tooltip, elided in layouts instead of widening them."""
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.full_text = ""
+        self.setObjectName("SDKConnectionPath")
+        self.setTextFormat(Qt.TextFormat.PlainText)
+        self.setMinimumWidth(0)
+        self.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred)
+
+    def setText(self, text):
+        self.full_text = text
+        self.setToolTip(text)
+        self.setAccessibleDescription(text)
+        self._elide()
+
+    def _elide(self):
+        super().setText(self.fontMetrics().elidedText(self.full_text, Qt.TextElideMode.ElideMiddle, max(0, self.width())))
+
+    def resizeEvent(self, event):
+        super().resizeEvent(event)
+        self._elide()
+
+    def minimumSizeHint(self):
+        return QSize(0, self.fontMetrics().height() + 4)
+
+
+def sdk_icon():
+    """The original code-bracket mark used by the approved SDK banner."""
+    return QIcon(str(Path(__file__).with_name("resources") / "sdk-mark.png"))
+
+
+def sdk_badge(parent=None):
+    badge = QLabel("SDK", parent)
+    badge.setObjectName("SDKBadge")
+    badge.setAccessibleName("PyCForge SDK")
+    badge.setAlignment(Qt.AlignmentFlag.AlignCenter)
+    badge.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
+    return badge
+
+
+def brand_panel(parent=None):
+    panel = QFrame(parent)
+    panel.setObjectName("SDKBrand")
+    panel.setAccessibleName("PyCForge SDK — conversion extensions")
+    layout = QVBoxLayout(panel)
+    layout.setContentsMargins(10, 10, 10, 10)
+    layout.setSpacing(6)
+    row = QHBoxLayout()
+    row.setSpacing(6)
+    mark = QLabel()
+    mark.setFixedSize(28, 28)
+    mark.setPixmap(sdk_icon().pixmap(mark.size(), panel.devicePixelRatioF()))
+    row.addWidget(mark)
+    name = QLabel("PyCForge")
+    name.setObjectName("SDKProductName")
+    row.addWidget(name)
+    row.addWidget(sdk_badge(panel))
+    row.addStretch(1)
+    layout.addLayout(row)
+    caption = QLabel("Conversion extensions")
+    caption.setObjectName("SDKBrandCaption")
+    layout.addWidget(caption)
+    return panel