velune-cli 1.0.0__py3-none-any.whl

velune/cli/modes.py

@@ -0,0 +1,86 @@
+from dataclasses import dataclass
+from enum import Enum
+
+
+class SessionMode(Enum):
+    NORMAL  = "normal"
+    OPTIMUS = "optimus"
+    GODLY   = "godly"
+
+
+@dataclass
+class ModeConfig:
+    mode: SessionMode
+    council_tier: str           # "instant" | "minimal" | "standard" | "full" | "auto"
+    context_compression: bool   # compress context before each call
+    max_context_tokens: int     # hard cap on context sent per call
+    temperature: float
+    retrieval_depth: int        # how many memory + repo chunks to pull
+    use_fastest_model: bool     # optimus: pick smallest capable model
+    use_largest_model: bool     # godly: pick largest available model
+    disable_critics: bool       # optimus: skip critic agents
+    description: str
+    prompt_color: str           # Rich color for prompt badge
+
+
+MODE_CONFIGS: dict[SessionMode, ModeConfig] = {
+    SessionMode.NORMAL: ModeConfig(
+        mode=SessionMode.NORMAL,
+        council_tier="auto",
+        context_compression=False,
+        max_context_tokens=16384,
+        temperature=0.3,
+        retrieval_depth=8,
+        use_fastest_model=False,
+        use_largest_model=False,
+        disable_critics=False,
+        description="Balanced — auto-selects council tier per task",
+        prompt_color="cyan",
+    ),
+    SessionMode.OPTIMUS: ModeConfig(
+        mode=SessionMode.OPTIMUS,
+        council_tier="instant",
+        context_compression=True,
+        max_context_tokens=4096,
+        temperature=0.1,
+        retrieval_depth=3,
+        use_fastest_model=True,
+        use_largest_model=False,
+        disable_critics=True,
+        description="Speed mode — smallest model, compressed context, instant tier",
+        prompt_color="yellow",
+    ),
+    SessionMode.GODLY: ModeConfig(
+        mode=SessionMode.GODLY,
+        council_tier="full",
+        context_compression=False,
+        max_context_tokens=128000,
+        temperature=0.5,
+        retrieval_depth=20,
+        use_fastest_model=False,
+        use_largest_model=True,
+        disable_critics=False,
+        description="Maximum — largest model, full context, complete council",
+        prompt_color="magenta",
+    ),
+}
+
+
+class ModeManager:
+    def __init__(self) -> None:
+        self._active = SessionMode.NORMAL
+
+    @property
+    def current(self) -> SessionMode:
+        return self._active
+
+    @property
+    def config(self) -> ModeConfig:
+        return MODE_CONFIGS[self._active]
+
+    def set_mode(self, mode: SessionMode) -> ModeConfig:
+        self._active = mode
+        return self.config
+
+    def is_normal(self) -> bool:
+        return self._active == SessionMode.NORMAL

velune/cli/pull_ui.py

@@ -0,0 +1,118 @@
+"""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,81 @@
+"""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)