velune-cli 0.9.0__py3-none-any.whl

velune/cli/pull_ui.py

@@ -0,0 +1,123 @@
+"""Interactive model browser TUI for /pull — select a model to download."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.application import Application
+from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import Layout
+from prompt_toolkit.layout.containers import Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+
+from velune.providers.ollama_manager import RECOMMENDED_MODELS
+
+if TYPE_CHECKING:
+    from rich.console import Console
+
+_SKILL_STYLES: dict[str, str] = {
+    "coding": "fg:ansigreen",
+    "reasoning": "fg:ansimagenta",
+    "embedding": "fg:ansicyan",
+    "general": "fg:ansibrightblack",
+}
+
+
+async def run_pull_ui(
+    local_models: list[str],
+    hardware_ram_gb: float,
+    console: Console,
+) -> str | None:
+    """Show the interactive model browser and return the chosen model_id, or None."""
+
+    selected_idx = [0]
+    result: list[str | None] = [None]
+
+    def _fits(model: dict) -> bool:
+        try:
+            needed = float(model["ram_needed"].replace(" GB", "").strip())
+            return hardware_ram_gb >= needed
+        except Exception:
+            return True
+
+    def render_list() -> FormattedText:
+        lines: list[tuple[str, str]] = []
+        lines.append(("bold", "  Available models to pull\n"))
+        lines.append(("fg:ansibrightblack", "  ↑↓ navigate · Enter pull · Esc cancel\n\n"))
+        lines.append(("fg:ansibrightblack", f"  Your RAM: {hardware_ram_gb:.0f} GB\n\n"))
+
+        for i, model in enumerate(RECOMMENDED_MODELS):
+            is_active = i == selected_idx[0]
+            prefix = "❯ " if is_active else "  "
+            row_style = "bold fg:cyan" if is_active else ""
+            model_id = model["model_id"]
+            is_local = any(
+                m == model_id or m.split(":")[0] == model_id.split(":")[0] and m == model_id
+                for m in local_models
+            )
+            fits = _fits(model)
+            skill = model.get("skill", "general")
+            skill_style = _SKILL_STYLES.get(skill, "fg:ansibrightblack")
+
+            if is_local:
+                status = "  ✓ installed"
+                status_style = "fg:ansigreen"
+            elif not fits:
+                status = "  needs more RAM"
+                status_style = "fg:ansibrightblack"
+            else:
+                status = ""
+                status_style = ""
+
+            lines.append(
+                (
+                    row_style,
+                    f"  {prefix}{model_id:<34} {model['size_gb']:4.1f} GB  ",
+                )
+            )
+            lines.append((skill_style, f"[{skill}]"))
+            if status:
+                lines.append((status_style, status))
+            lines.append(("", "\n"))
+
+            if is_active:
+                lines.append(("fg:ansibrightblack", f"         {model['description']}\n"))
+                lines.append(
+                    ("fg:ansibrightblack", f"         RAM needed: {model['ram_needed']}\n")
+                )
+
+        return FormattedText(lines)
+
+    kb = KeyBindings()
+
+    @kb.add("up")
+    def _up(event) -> None:
+        selected_idx[0] = (selected_idx[0] - 1) % len(RECOMMENDED_MODELS)
+
+    @kb.add("down")
+    def _down(event) -> None:
+        selected_idx[0] = (selected_idx[0] + 1) % len(RECOMMENDED_MODELS)
+
+    @kb.add("enter")
+    def _select(event) -> None:
+        result[0] = RECOMMENDED_MODELS[selected_idx[0]]["model_id"]
+        event.app.exit()
+
+    @kb.add("escape")
+    @kb.add("c-c")
+    def _cancel(event) -> None:
+        event.app.exit()
+
+    app = Application(
+        layout=Layout(
+            Window(
+                content=FormattedTextControl(render_list, focusable=True),
+            )
+        ),
+        key_bindings=kb,
+        full_screen=False,
+        mouse_support=False,
+    )
+    await app.run_async()
+    return result[0]

velune/cli/registry.py

@@ -0,0 +1,80 @@
+"""CLI command discovery and registration."""
+
+from __future__ import annotations
+
+import importlib
+from collections.abc import Sequence
+from importlib.metadata import EntryPoint, entry_points
+from types import ModuleType
+
+import typer
+
+from velune.cli.commands import (
+    ask_command,
+    chat_command,
+    config_cmd,
+    daemon_cmd,
+    doctor_cmd,
+    init_command,
+    mcp_cmd,
+    mcp_serve,
+    memory_cmd,
+    models_cmd,
+    run_command,
+    setup_command,
+    workspace_cmd,
+)
+from velune.kernel.registry import ServiceContainer
+
+BUILTIN_COMMAND_MODULES: Sequence[str] = (
+    "velune.cli.commands.ask",
+    "velune.cli.commands.chat",
+    "velune.cli.commands.run",
+    "velune.cli.commands.models",
+    "velune.cli.commands.workspace",
+    "velune.cli.commands.memory",
+    "velune.cli.commands.config",
+    "velune.cli.commands.daemon",
+    "velune.cli.commands.doctor",
+    "velune.cli.commands.mcp",
+)
+
+
+def discover_builtin_modules() -> list[ModuleType]:
+    """Import and return built-in command modules."""
+
+    modules: list[ModuleType] = []
+    for module_name in BUILTIN_COMMAND_MODULES:
+        modules.append(importlib.import_module(module_name))
+    return modules
+
+
+def discover_plugin_entry_points(group: str = "velune.commands") -> list[EntryPoint]:
+    """Return third-party command extension entry points."""
+
+    return list(entry_points(group=group))
+
+
+def register_commands(app: typer.Typer, container: ServiceContainer) -> None:
+    """Attach all built-in and plugin command groups to the app."""
+
+    app.command(name="ask")(ask_command)
+    app.command(name="chat")(chat_command)
+    app.command(name="init")(init_command)
+    app.command(name="run")(run_command)
+    app.command(name="setup")(setup_command)
+    app.command(name="mcp-serve")(mcp_serve)
+    app.add_typer(models_cmd, name="models")
+    app.add_typer(workspace_cmd, name="workspace")
+    app.add_typer(memory_cmd, name="memory")
+    app.add_typer(config_cmd, name="config")
+    app.add_typer(daemon_cmd, name="daemon")
+    app.add_typer(doctor_cmd, name="doctor")
+    app.add_typer(mcp_cmd, name="mcp")
+
+    for entry_point in discover_plugin_entry_points():
+        loaded = entry_point.load()
+        if hasattr(loaded, "register"):
+            loaded.register(app=app, container=container)
+        elif callable(loaded):
+            loaded(app=app, container=container)

velune/cli/rendering/__init__.py

@@ -0,0 +1,5 @@
+"""CLI rendering helpers."""
+
+from velune.cli.rendering.markdown import CustomMarkdown, MarkdownStreamBuffer
+
+__all__ = ["CustomMarkdown", "MarkdownStreamBuffer"]

velune/cli/rendering/error_panel.py

@@ -0,0 +1,79 @@
+"""Rich error panel renderer for structured VeluneError display."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+if TYPE_CHECKING:
+    from velune.core.errors.catalog import VeluneError
+
+_BUG_REPORT_URL = "https://github.com/velune-ai/velune/issues"
+
+
+def render_error(error: VeluneError) -> Panel:
+    """Build a Rich Panel for a VeluneError with cause and fix sections."""
+    body = Text()
+
+    cause = error.get_cause()
+    if cause:
+        body.append("Cause\n", style="bold white")
+        body.append(f"  {cause}\n", style="dim white")
+
+    if error.fix:
+        body.append("\nFix\n", style="bold white")
+        for step in error.fix:
+            body.append(f"  • {step}\n", style="dim white")
+
+    if error.docs_url:
+        body.append(f"\n  docs → {error.docs_url}", style="blue underline")
+
+    detail = error.get_detail()
+    if detail and detail != error.title:
+        body.append("\n\n  Detail: ", style="dim")
+        body.append(detail, style="dim white")
+
+    body.append("\n\n  Use --verbose for full stack trace.", style="dim")
+
+    return Panel(
+        body,
+        title=f"[bold red]Error:[/bold red] {error.title}",
+        border_style="red",
+        padding=(1, 2),
+    )
+
+
+def render_unexpected_error(exc: Exception) -> Panel:
+    """Build a Rich Panel for an unrecognised exception."""
+    body = Text()
+    body.append(
+        "An unexpected error occurred.\n\n",
+        style="dim white",
+    )
+    body.append(f"  {type(exc).__name__}: ", style="dim white")
+    body.append(f"{exc}\n", style="white")
+
+    body.append("\nWhat to do\n", style="bold white")
+    body.append("  • Use --verbose to see the full stack trace\n", style="dim white")
+    body.append(f"  • Report the issue at {_BUG_REPORT_URL}\n", style="dim white")
+    body.append("  • Include the --verbose output in your report\n", style="dim white")
+
+    return Panel(
+        body,
+        title="[bold red]Unexpected Error[/bold red]",
+        border_style="red",
+        padding=(1, 2),
+    )
+
+
+def print_error(error: VeluneError, console: Console | None = None) -> None:
+    """Convenience wrapper: render and print a VeluneError to the given console."""
+    (console or Console()).print(render_error(error))
+
+
+def print_unexpected_error(exc: Exception, console: Console | None = None) -> None:
+    """Convenience wrapper: render and print an unexpected exception."""
+    (console or Console()).print(render_unexpected_error(exc))

velune/cli/rendering/markdown.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from rich.console import Console, ConsoleOptions, RenderResult
+from rich.markdown import CodeBlock, Markdown
+from rich.syntax import Syntax
+
+
+class CustomCodeBlock(CodeBlock):
+    """A code block with syntax highlighting and line numbers for blocks >5 lines."""
+
+    def __rich_console__(self, console: Console, options: ConsoleOptions) -> RenderResult:
+        code = str(self.text).rstrip()
+        line_count = len(code.splitlines())
+        line_numbers = line_count > 5
+        syntax = Syntax(
+            code,
+            self.lexer_name,
+            theme="monokai",
+            word_wrap=True,
+            line_numbers=line_numbers,
+            padding=1,
+        )
+        yield syntax
+
+
+class CustomMarkdown(Markdown):
+    """Custom Markdown renderer that overrides CodeBlock element handling."""
+
+    elements = Markdown.elements.copy()
+    elements["fence"] = CustomCodeBlock
+    elements["code_block"] = CustomCodeBlock
+
+    def __init__(self, markup: str, code_theme: str = "monokai", **kwargs) -> None:
+        super().__init__(markup, code_theme=code_theme, **kwargs)
+
+
+class MarkdownStreamBuffer:
+    """Buffer that accumulates chunks of Markdown, handles split fences, and returns clean renderables."""
+
+    def __init__(self) -> None:
+        self._buffer = ""
+
+    def append(self, text: str) -> None:
+        self._buffer += text
+
+    @property
+    def raw_content(self) -> str:
+        return self._buffer
+
+    def get_renderable(self) -> CustomMarkdown:
+        content = self._buffer
+
+        # Clean up split code fences at the end of the buffer to prevent flicker/incorrect rendering.
+        # If it ends with incomplete backticks on a new line (e.g. \n` or \n``)
+        # or just starts with incomplete backticks if buffer is very short
+        if content.endswith("\n`"):
+            content = content[:-2]
+        elif content.endswith("\n``"):
+            content = content[:-3]
+        elif content == "`" or content == "``":
+            content = ""
+
+        return CustomMarkdown(content)