superqode 2.4.20__tar.gz → 2.4.22__tar.gz

{superqode-2.4.20 → superqode-2.4.22}/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.4.22] - 2026-09-27
+
+### Added
+
+- Canonical local provider order: Ollama -> LM Studio -> llama.cpp -> SGLang ->
+  vLLM -> MLX.
+- `superqode local install` / `:local install` with plan -> confirm -> run ->
+  verify flow (model weights remain a separate step).
+- Missing local runtimes route to an install card in the TUI.
+- LM Studio headless-first install plus PATH resolution via
+  `runtime_executable`.
+- Optional isolated uv venvs for SGLang and vLLM under
+  `~/.superqode/runtimes/`.
+- Compact CONNECT and LOCAL provider pickers.
+
+### Changed
+
+- Remove stale LM Studio copy that still pointed at `npx lmstudio install-cli`
+  or "open the app first" after the CLI-missing early return; messaging now
+  matches the headless `install_plan` / `:local install` path.
+- Clarify that SGLang and vLLM use install and printed next steps rather than
+  `:local serve`.
+
 ## [2.4.20] - 2026-09-27
 
 ### Added

{superqode-2.4.20 → superqode-2.4.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: superqode
-Version: 2.4.20
+Version: 2.4.22
 Summary: The harness layer for coding agents
 Author-email: Shashi Jagtap <info@super-agentic.ai>
 Maintainer-email: Shashi Jagtap <info@super-agentic.ai>

{superqode-2.4.20 → superqode-2.4.22}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "superqode"
-version = "2.4.20"
+version = "2.4.22"
 description = "The harness layer for coding agents"
 readme = "README.md"
 license = "Apache-2.0"

{superqode-2.4.20 → superqode-2.4.22}/src/superqode/__init__.py

@@ -38,7 +38,7 @@ __all__ = [
     "sidebar",
 ]
 
-__version__ = "2.4.20"
+__version__ = "2.4.22"
 
 # Stable, lightweight public extension surface.  Importing this package does
 # not discover or execute third-party extensions; discovery happens only when

{superqode-2.4.20 → superqode-2.4.22}/src/superqode/agent_output.py

@@ -31,12 +31,14 @@ from rich.console import Group
 from rich.box import ROUNDED, HEAVY, DOUBLE
 from rich.table import Table
 
+import superqode.code_theme  # noqa: F401  (registers the "superqode" Pygments style)
+
 
 # ============================================================================
 # THEME - Vibrant SuperQode Colors
 # ============================================================================
 
-COLORS = {
+_COLOR_DEFAULTS = {
     # Primary gradient
     "purple": "#a855f7",
     "magenta": "#d946ef",
@@ -69,11 +71,79 @@ COLORS = {
     "border_active": "#a855f7",
 }
 
-# Rainbow gradient for special effects
-RAINBOW = ["#ef4444", "#f97316", "#eab308", "#22c55e", "#06b6d4", "#3b82f6", "#8b5cf6", "#ec4899"]
+# Static key -> live THEME key. Status roles (success/error/warning/info)
+# follow the active theme so agent output matches :theme.
+_COLOR_THEME_KEYS = {
+    "purple": "purple",
+    "magenta": "magenta",
+    "pink": "pink",
+    "rose": "rose",
+    "orange": "orange",
+    "gold": "gold",
+    "cyan": "cyan",
+    "teal": "teal",
+    "green": "green",
+    "blue": "blue",
+    "success": "success",
+    "error": "error",
+    "warning": "warning",
+    "info": "cyan",
+    "bg_dark": "bg",
+    "bg_surface": "surface",
+    "bg_elevated": "surface2",
+    "bg_thinking": "surface",
+    "bg_response": "surface",
+    "text": "text",
+    "text_muted": "muted",
+    "text_dim": "dim",
+    "border": "border",
+    "border_active": "border_active",
+}
+
+
+class _LiveColors(dict):
+    """Dict that resolves each color from the live THEME on every access."""
+
+    def __getitem__(self, key):
+        try:
+            from superqode.app.constants import THEME as _LIVE
+
+            theme_key = _COLOR_THEME_KEYS.get(key)
+            if theme_key and theme_key in _LIVE:
+                return _LIVE[theme_key]
+        except Exception:
+            pass
+        return super().__getitem__(key)
+
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+
+COLORS = _LiveColors(_COLOR_DEFAULTS)
+
+
+# Gradient helpers follow the live theme: header/footer rules blend the
+# theme's accent roles instead of hardcoding brand hexes.
+def _theme_gradient() -> list:
+    return [COLORS["purple"], COLORS["magenta"], COLORS["pink"], COLORS["orange"], COLORS["rose"]]
+
 
-# Gradient for response header
-RESPONSE_GRADIENT = ["#a855f7", "#c026d3", "#d946ef", "#ec4899", "#f43f5e"]
+class _LiveGradient(list):
+    def __len__(self):
+        return len(_theme_gradient())
+
+    def __getitem__(self, index):
+        return _theme_gradient()[index]
+
+    def __iter__(self):
+        return iter(_theme_gradient())
+
+
+RAINBOW = _LiveGradient()
+RESPONSE_GRADIENT = _LiveGradient()
 
 
 # ============================================================================
@@ -253,7 +323,7 @@ def render_thinking_line(line: ThinkingLine, index: int) -> Text:
     color = COLORS["text_dim"] if index % 2 == 0 else COLORS["text_muted"]
 
     # Icon
-    result.append(f"  {line.icon} ", style=COLORS["cyan"])
+    result.append(f"  {line.icon} ", style=COLORS["pink"])
 
     # Text (truncate if too long)
     text = line.text[:100] + "..." if len(line.text) > 100 else line.text
@@ -286,7 +356,7 @@ def render_thinking_section(lines: List[ThinkingLine], collapsed: bool = False)
 
     return Panel(
         content,
-        title=f"[bold {COLORS['cyan']}]💭 Thinking ({len(lines)} steps)[/]",
+        title=f"[bold {COLORS['pink']}]💭 Thinking ({len(lines)} steps)[/]",
         subtitle="[dim]Ctrl+T to toggle[/]",
         border_style=COLORS["border"],
         box=ROUNDED,
@@ -294,16 +364,42 @@ def render_thinking_section(lines: List[ThinkingLine], collapsed: bool = False)
     )
 
 
+def _code_theme_name() -> str:
+    """Pygments style matching the active TUI theme."""
+    try:
+        from superqode.app.theme_bridge import active_theme_name
+    except Exception:
+        return "superqode"
+    return {
+        "superqode": "superqode",
+        "tokyonight": "github-dark",
+        "dracula": "dracula",
+        "nord": "nord",
+        "monokai": "monokai",
+        "gruvbox": "gruvbox-dark",
+        "high-contrast": "github-dark",
+    }.get(active_theme_name(), "superqode")
+
+
+def _code_background() -> str:
+    try:
+        from superqode.app.constants import THEME as _LIVE
+
+        return _LIVE.get("code_bg", _LIVE.get("bg", "#0f0a1a"))
+    except Exception:
+        return "#0f0a1a"
+
+
 def render_code_block(block: CodeBlock) -> Panel:
     """Render a beautiful code block with syntax highlighting."""
-    # Create syntax highlighted code
+    # Syntax style and background follow the active theme.
     syntax = Syntax(
         block.code,
         block.language,
-        theme="monokai",
+        theme=_code_theme_name(),
         line_numbers=True,
         word_wrap=True,
-        background_color="#000000",
+        background_color=_code_background(),
     )
 
     # Language badge
@@ -326,14 +422,14 @@ def render_code_block(block: CodeBlock) -> Panel:
     }
     icon = lang_icons.get(block.language.lower(), "📄")
 
-    title = f"[bold {COLORS['green']}]{icon} {block.language.upper()}[/]"
+    title = f"[bold {COLORS['orange']}]{icon} {block.language.upper()}[/]"
     if block.filename:
         title += f" [dim]({block.filename})[/]"
 
     return Panel(
         syntax,
         title=title,
-        border_style=COLORS["green"],
+        border_style=COLORS["purple"],
         box=ROUNDED,
         padding=(0, 1),
     )
@@ -352,10 +448,10 @@ def render_response_header(agent_name: str = "Agent") -> Text:
     result.append("\n")
 
     # Agent name with sparkles
-    result.append("  🤖 ", style=COLORS["gold"])
+    result.append("  🤖 ", style=COLORS["orange"])
     result.append(agent_name.upper(), style=f"bold {COLORS['purple']}")
     result.append(" Response ", style=f"bold {COLORS['magenta']}")
-    result.append("🤖\n", style=COLORS["gold"])
+    result.append("🤖\n", style=COLORS["pink"])
 
     # Another gradient line
     for i, char in enumerate(line_chars):
@@ -402,13 +498,13 @@ def render_bullet_point(text: str, index: int, width: int = 80) -> Text:
 
     result = Text()
 
-    # Rotating colors for bullets
+    # Rotating colors for bullets (brand only)
     bullet_colors = [
         COLORS["purple"],
         COLORS["pink"],
-        COLORS["cyan"],
-        COLORS["green"],
+        COLORS["magenta"],
         COLORS["orange"],
+        COLORS["rose"],
     ]
     color = bullet_colors[index % len(bullet_colors)]
 
@@ -443,7 +539,7 @@ def render_response_footer(duration: float = 0) -> Text:
     result.append("\n")
 
     # Stats
-    result.append("  🎯 ", style=COLORS["green"])
+    result.append("  🎯 ", style=COLORS["orange"])
     result.append("Response complete", style=COLORS["text_muted"])
 
     if duration > 0:
@@ -702,7 +798,7 @@ def create_simple_response_panel(text: str, agent_name: str = "Agent") -> Panel:
     content = Text()
 
     # Add sparkle decoration
-    content.append("✨ ", style=COLORS["gold"])
+    content.append("✨ ", style=COLORS["pink"])
 
     # Format the text nicely
     lines = text.strip().split("\n")

{superqode-2.4.20 → superqode-2.4.22}/src/superqode/agent_stream.py

@@ -26,18 +26,57 @@ from time import monotonic
 # THEME & COLORS (SuperQode style)
 # ============================================================================
 
-STREAM_COLORS = {
+_STREAM_COLOR_DEFAULTS = {
     "message": "#a855f7",  # Purple - agent messages
     "thought": "#ec4899",  # Pink - thinking
     "tool": "#f97316",  # Orange - tool calls
-    "plan": "#06b6d4",  # Cyan - plan updates
-    "success": "#22c55e",  # Green - completed
-    "error": "#ef4444",  # Red - errors
-    "warning": "#f59e0b",  # Amber - warnings
+    "plan": "#d946ef",  # Magenta - plan updates
+    "success": "#f97316",  # Orange - completed
+    "error": "#fb7185",  # Rose - errors
+    "warning": "#f97316",  # Orange - warnings
     "pending": "#a1a1aa",  # Gray - pending
-    "progress": "#3b82f6",  # Blue - in progress
+    "progress": "#ec4899",  # Pink - in progress
 }
 
+# Semantic role -> live THEME key (synced by theme_bridge.apply_theme).
+# Status roles (success/error/warning/pending) intentionally follow the
+# active theme's semantics so nord/monokai/etc. render natively.
+_STREAM_COLOR_THEME_KEYS = {
+    "message": "purple",
+    "thought": "pink",
+    "tool": "orange",
+    "plan": "magenta",
+    "success": "success",
+    "error": "error",
+    "warning": "warning",
+    "pending": "muted",
+    "progress": "cyan",
+}
+
+
+class _LiveStreamColors(dict):
+    """Dict that resolves each color from the live THEME on every access."""
+
+    def __getitem__(self, key):
+        try:
+            from superqode.app.constants import THEME as _LIVE
+
+            theme_key = _STREAM_COLOR_THEME_KEYS.get(key)
+            if theme_key and theme_key in _LIVE:
+                return _LIVE[theme_key]
+        except Exception:
+            pass
+        return super().__getitem__(key)
+
+    def get(self, key, default=None):
+        try:
+            return self[key]
+        except KeyError:
+            return default
+
+
+STREAM_COLORS = _LiveStreamColors(_STREAM_COLOR_DEFAULTS)
+
 STREAM_ICONS = {
     "message": "💬",
     "thought": "💭",

{superqode-2.4.20 → superqode-2.4.22}/src/superqode/app/constants.py

@@ -778,6 +778,7 @@ COMMANDS = [
     ":local doctor",
     ":local guardrails",
     ":local setup",
+    ":local install",
     ":local init",
     ":local build",
     ":local packs",

{superqode-2.4.20 → superqode-2.4.22}/src/superqode/app/mixins/agent_run.py

@@ -1357,7 +1357,7 @@ class AgentRunMixin:
                 if provider == "ollama":
                     log.add_info("   Run: ollama serve")
                 elif provider == "lmstudio":
-                    log.add_info("   Open LM Studio and start the local server")
+                    log.add_info("   Run: superqode local serve lmstudio (or open the desktop app)")
                 elif provider == "vllm":
                     log.add_info(
                         "   Start vLLM server: python -m vllm.entrypoints.openai.api_server --model <model>"

{superqode-2.4.20 → superqode-2.4.22}/src/superqode/app/mixins/build_harness.py

@@ -69,7 +69,42 @@ class BuildHarnessMixin:
 
     def _harness_import_picker(self, log: ConversationLog) -> None:
         """Offer to turn existing repository agent config into a HarnessSpec."""
+        # File discovery (rglob over .cursor/rules etc.) can block the UI
+        # thread on large repos, so scan in a worker with progress output.
+        log.add_info("Scanning for importable agent config…")
+        runner = getattr(self, "run_worker", None)
+        if callable(runner):
+            try:
+                import asyncio as _asyncio_check
+
+                _asyncio_check.get_running_loop()
+            except RuntimeError:
+                runner = None
+        if callable(runner):
+            try:
+                runner(self._harness_import_scan(log))
+                return
+            except Exception:
+                pass
         found = discover_importable()
+        self._show_import_scan_result(log, found)
+
+    async def _blocking_discover_importable(self):
+        """Run filesystem discovery off the UI thread."""
+        import asyncio as _asyncio
+
+        try:
+            return await _asyncio.to_thread(discover_importable)
+        except Exception:
+            return discover_importable()
+
+    async def _harness_import_scan(self, log: ConversationLog) -> None:
+        """Worker: discover importables then render the picker."""
+        found = await self._blocking_discover_importable()
+        self._show_import_scan_result(log, found)
+
+    def _show_import_scan_result(self, log: ConversationLog, found) -> None:
+        """Render the empty-state or the picker for scan results."""
         if not found:
             t = Text()
             t.append("\n  ◈ ", style=f"bold {THEME['purple']}")
@@ -143,7 +178,43 @@ class BuildHarnessMixin:
             return
         path, label, kind = found[index]
         self._awaiting_harness_import = False
-
+        log.add_info(f"Importing {label}…")
+
+        async def _work() -> None:
+            import asyncio as _asyncio
+
+            try:
+                spec, note = await _asyncio.to_thread(self._build_spec_from_import, path, kind)
+                output = HARNESS_OUTPUT_DIR / f"{spec.name}.yaml"
+                from superqode.harness.loader import save_harness_spec
+
+                if output.exists():
+                    log.add_error(
+                        f"Refusing to overwrite existing harness: {output}. "
+                        "Rename it or choose a different harness name first."
+                    )
+                    return
+                written = await _asyncio.to_thread(save_harness_spec, spec, output)
+            except Exception as exc:  # noqa: BLE001 - surface import failures in the TUI
+                log.add_error(f"Could not import {label}: {exc}")
+                return
+            self._show_import_success(log, spec, note, written)
+
+        runner = getattr(self, "run_worker", None)
+        if callable(runner):
+            try:
+                import asyncio as _asyncio_check
+
+                _asyncio_check.get_running_loop()
+            except RuntimeError:
+                runner = None
+        if callable(runner):
+            try:
+                runner(_work())
+                return
+            except Exception:
+                pass
+        # No worker (unit tests): run synchronously.
         try:
             spec, note = self._build_spec_from_import(path, kind)
             output = HARNESS_OUTPUT_DIR / f"{spec.name}.yaml"
@@ -159,7 +230,9 @@ class BuildHarnessMixin:
         except Exception as exc:  # noqa: BLE001 - surface import failures in the TUI
             log.add_error(f"Could not import {label}: {exc}")
             return
+        self._show_import_success(log, spec, note, written)
 
+    def _show_import_success(self, log: ConversationLog, spec, note: str, written) -> None:
         t = Text()
         t.append("\n  ✓ ", style=f"bold {THEME['success']}")
         t.append(f"Imported {label}\n\n", style=f"bold {THEME['text']}")

{superqode-2.4.20 → superqode-2.4.22}/src/superqode/app/mixins/commands_impl.py

@@ -4012,6 +4012,13 @@ class CommandImplMixin:
         subargs = parts[1].strip() if len(parts) > 1 else ""
         if not sub:
             sub = "status"
+        if sub != "wizard":
+            cancel = getattr(self, "_cancel_harness_wizard", None)
+            if callable(cancel):
+                try:
+                    cancel()
+                except Exception:
+                    pass
 
         try:
             from superqode.harness import (

{superqode-2.4.20 → superqode-2.4.22}/src/superqode/app/mixins/connect.py

@@ -1462,6 +1462,13 @@ class ConnectMixin:
         flow so a later Core switch does not inherit KEY_MODELS / persist.
         """
         self._reset_connect_selection_states()
+        if profile.connector != "harness-wizard":
+            cancel = getattr(self, "_cancel_harness_wizard", None)
+            if callable(cancel):
+                try:
+                    cancel()
+                except Exception:
+                    pass
         self._open_connect_screen(log)
         conn = profile.connector
         if conn not in {"byok", "local", "key-harness"}:
@@ -2750,6 +2757,12 @@ class ConnectMixin:
 
         provider = normalize_provider_id(provider)
         model = normalize_model_for_provider(provider, model)
+        cancel = getattr(self, "_cancel_harness_wizard", None)
+        if callable(cancel):
+            try:
+                cancel()
+            except Exception:
+                pass
         if self._redirect_harness_only_provider(provider, log):
             return
         self._clear_acp_extra_env()

{superqode-2.4.20 → superqode-2.4.22}/src/superqode/app/mixins/helper_exit_lifecycle.py

@@ -86,6 +86,12 @@ class HelperExitLifecycleMixin:
         would otherwise inherit.
         """
         self._clear_sidebar_session_files()
+        cancel = getattr(self, "_cancel_harness_wizard", None)
+        if callable(cancel):
+            try:
+                cancel()
+            except Exception:
+                pass
         pure = getattr(self, "_pure_mode", None)
         if pure is not None:
             try:
@@ -162,6 +168,12 @@ class HelperExitLifecycleMixin:
         )
 
     def _go_home(self, log: ConversationLog):
+        cancel = getattr(self, "_cancel_harness_wizard", None)
+        if callable(cancel):
+            try:
+                cancel()
+            except Exception:
+                pass
         # First, cancel any running agent process
         if self._agent_process is not None:
             self._cancel_requested = True

{superqode-2.4.20 → superqode-2.4.22}/src/superqode/app/mixins/helper_wizard.py

@@ -11,8 +11,28 @@ from superqode.app.constants import (
 class HelperWizardMixin:
     """Harness wizard flow state and prompts."""
 
+    def _cancel_harness_wizard(self, log=None, *, announce: bool = False) -> bool:
+        """Invalidate wizard work and return whether a wizard was active."""
+        was_active = bool(
+            getattr(self, "_awaiting_harness_wizard", False)
+            or getattr(self, "_harness_wizard_finishing", False)
+        )
+        # Workers cannot safely be interrupted during a file write. A generation
+        # token prevents an obsolete completion from repainting or loading itself.
+        self._harness_wizard_generation = getattr(self, "_harness_wizard_generation", 0) + 1
+        self._awaiting_harness_wizard = False
+        self._harness_wizard_finishing = False
+        self._harness_wizard_state = None
+        if was_active and announce and log is not None:
+            try:
+                log.add_info("Harness wizard cancelled.")
+            except Exception:
+                pass
+        return was_active
+
     def _start_harness_wizard_flow(self, log) -> None:
         """Start the step-by-step HarnessSpec wizard in the TUI."""
+        self._cancel_harness_wizard()
         self._awaiting_harness_wizard = True
         self._harness_wizard_state = {
             "step": "name",
@@ -78,28 +98,81 @@ class HelperWizardMixin:
             self._render_harness_wizard_step(log)
             return
 
+        # Building + saving + loading touches the filesystem and the harness
+        # machinery; do it in a worker so the TUI never freezes on Enter.
+        # Snapshot + clear state first so typed input is normal chat again.
+        self._awaiting_harness_wizard = False
+        self._harness_wizard_finishing = True
+        self._harness_wizard_state = None
+        generation = getattr(self, "_harness_wizard_generation", 0)
+        log.add_info(f"Creating harness at {output}…")
+        runner = getattr(self, "run_worker", None)
+        if callable(runner):
+            try:
+                import asyncio as _asyncio_check
+
+                _asyncio_check.get_running_loop()
+            except RuntimeError:
+                runner = None
+        if callable(runner):
+            try:
+                runner(
+                    self._finish_harness_wizard_worker(
+                        answers_kwargs, output, load_after_write, log, generation
+                    )
+                )
+                return
+            except Exception:
+                pass
         try:
-            from superqode.harness import (
-                WizardAnswers,
-                build_wizard_spec,
-                explain_harness,
-                render_explanation,
-                save_harness_spec,
-            )
-
-            answers = WizardAnswers(**answers_kwargs)
-            spec = build_wizard_spec(answers)
-            path = save_harness_spec(spec, output)
-            (Path(".agents") / "skills").mkdir(parents=True, exist_ok=True)
-            (Path(".agents") / "roles").mkdir(parents=True, exist_ok=True)
-        except Exception as exc:
+            result = self._run_harness_wizard_finish(answers_kwargs, output, load_after_write, None)
+        except Exception as exc:  # noqa: BLE001 - synchronous fallback must surface failures
+            self._harness_wizard_finishing = False
             log.add_error(f"Could not create harness: {exc}")
-            self._awaiting_harness_wizard = False
-            self._harness_wizard_state = None
             return
+        if result is not None and generation == getattr(self, "_harness_wizard_generation", 0):
+            self._harness_wizard_finishing = False
+            self._show_harness_wizard_result(log, *result)
 
-        self._awaiting_harness_wizard = False
-        self._harness_wizard_state = None
+    async def _finish_harness_wizard_worker(
+        self, answers_kwargs, output, load_after_write, log, generation
+    ) -> None:
+        import asyncio as _asyncio
+
+        try:
+            result = await _asyncio.to_thread(
+                self._run_harness_wizard_finish, answers_kwargs, output, load_after_write, None
+            )
+        except Exception as exc:  # noqa: BLE001 - worker failures still surface
+            if generation == getattr(self, "_harness_wizard_generation", 0):
+                self._harness_wizard_finishing = False
+                log.add_error(f"Could not create harness: {exc}")
+            return
+        if result is None:
+            return
+        if generation != getattr(self, "_harness_wizard_generation", 0):
+            return
+        self._harness_wizard_finishing = False
+        spec, path, answers, load = result
+        self._show_harness_wizard_result(log, spec, path, answers, load)
+
+    def _run_harness_wizard_finish(self, answers_kwargs, output, load_after_write, log):
+        """Blocking build step. Returns (spec, path, answers, load) or None."""
+        from superqode.harness import (
+            WizardAnswers,
+            build_wizard_spec,
+            save_harness_spec,
+        )
+
+        answers = WizardAnswers(**answers_kwargs)
+        spec = build_wizard_spec(answers)
+        path = save_harness_spec(spec, output)
+        (Path(".agents") / "skills").mkdir(parents=True, exist_ok=True)
+        (Path(".agents") / "roles").mkdir(parents=True, exist_ok=True)
+        return spec, path, answers, load_after_write
+
+    def _show_harness_wizard_result(self, log, spec, path, answers, load_after_write) -> None:
+        from superqode.harness import explain_harness, render_explanation
 
         t = Text()
         t.append("\n  ▣ ", style=f"bold {THEME['purple']}")