velune-cli 1.0.0__py3-none-any.whl

velune/__init__.py

@@ -0,0 +1,5 @@
+"""Velune package metadata."""
+
+__version__ = "1.0.0"
+
+__all__ = ["__version__"]

velune/__main__.py

@@ -0,0 +1,6 @@
+"""Module entry point for `python -m velune`."""
+
+from velune.main import app
+
+if __name__ == "__main__":
+    app()

velune/cli/__init__.py

@@ -0,0 +1,5 @@
+"""CLI entry points."""
+
+from velune.cli.main import app
+
+__all__ = ["app"]

velune/cli/app.py

@@ -0,0 +1,212 @@
+"""Typer application factory for Velune."""
+
+from __future__ import annotations
+
+import sys
+import time
+
+if sys.platform == "win32":
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+        sys.stderr.reconfigure(encoding="utf-8")
+    except Exception:
+        pass
+
+import logging
+
+# Suppress all internal Velune logs from showing in terminal.
+# Users see Rich output only — not raw Python logs. This MUST run before
+# any velune.* modules are imported so their module-level loggers inherit
+# these levels before producing any output.
+logging.getLogger("velune").setLevel(logging.WARNING)
+logging.getLogger("qdrant_client").setLevel(logging.WARNING)
+logging.getLogger("httpx").setLevel(logging.WARNING)
+logging.getLogger("httpcore").setLevel(logging.WARNING)
+logging.getLogger("uvicorn").setLevel(logging.WARNING)
+logging.getLogger("asyncio").setLevel(logging.WARNING)
+
+# Suppress the root logger from printing INFO/DEBUG to stderr.
+logging.getLogger().setLevel(logging.WARNING)
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.live import Live
+from rich.panel import Panel
+from rich.text import Text
+
+from velune import __version__
+from velune.cli.context import CLIContext
+from velune.cli.registry import register_commands
+from velune.core.runtime import build_runtime
+from velune.kernel.registry import ServiceContainer
+
+
+def _startup_frames(workspace: Path, config_path: Path | None) -> list[Panel]:
+    banner = """
+██╗   ██╗███████╗██╗     ██╗   ██╗███╗   ██╗███████╗
+██║   ██║██╔════╝██║     ██║   ██║████╗  ██║██╔════╝
+██║   ██║█████╗  ██║     ██║   ██║██╔██╗ ██║█████╗
+╚██╗ ██╔╝██╔══╝  ██║     ██║   ██║██║╚██╗██║██╔══╝
+ ╚████╔╝ ███████╗███████╗╚██████╔╝██║ ╚████║███████╗
+  ╚═══╝  ╚══════╝╚══════╝ ╚═════╝ ╚═╝  ╚═══╝╚══════╝
+""".strip("\n")
+
+    frames: list[Panel] = []
+    lines = banner.splitlines()
+    for index in range(1, len(lines) + 1):
+        body = "\n".join(lines[:index])
+        if index == len(lines):
+            body += "\n\n[bold cyan]Welcome to Velune CLI![/bold cyan]\n[dim]v" + __version__ + "[/dim]\n\n[bold]What would you like to build today?[/bold]"
+        frames.append(
+            Panel(
+                Text.from_markup(body),
+                title="Velune",
+                border_style="cyan",
+                padding=(1, 2),
+            )
+        )
+
+    frames.append(
+        Panel(
+            Text.from_markup(
+                "[bold cyan]Welcome to Velune CLI![/bold cyan]\n"
+                f"[dim]v{__version__}[/dim]\n\n"
+                "[bold]What would you like to build today?[/bold]"
+            ),
+            title="Velune",
+            border_style="cyan",
+            padding=(1, 2),
+        )
+    )
+    return frames
+
+
+def _check_ollama_live() -> bool:
+    try:
+        import httpx
+        r = httpx.get("http://localhost:11434/api/tags", timeout=2)
+        return r.status_code == 200
+    except Exception:
+        return False
+
+
+def _show_startup_animation(console: Console, workspace: Path, config_path: Path | None) -> None:
+    """Show startup animation only in interactive TTY sessions."""
+    import sys
+    if not sys.stdout.isatty():
+        return  # Skip animation in CI, piped output, --quiet mode
+
+    frames = _startup_frames(workspace, config_path)
+    with Live(frames[0], console=console, refresh_per_second=12, transient=True) as live:
+        for frame in frames[1:]:
+            live.update(frame)
+            time.sleep(0.08)  # Acceptable: sync context, interactive only
+
+
+def create_app() -> typer.Typer:
+    """Create the root Typer application."""
+
+    app = typer.Typer(
+        name="velune",
+        help="Terminal-first cognitive AI orchestration system",
+        no_args_is_help=False,
+        add_completion=True,
+        rich_markup_mode="rich",
+    )
+
+    @app.callback(invoke_without_command=True)
+    def main(
+        ctx: typer.Context,
+        workspace: Path = typer.Option(Path.cwd(), "--workspace", "-w", help="Workspace root"),
+        config_path: Path | None = typer.Option(None, "--config", "-c", help="Explicit velune.toml path"),
+        verbose: bool = typer.Option(False, "--verbose", "-v", help="Enable debug logging"),
+        version: bool = typer.Option(False, "--version", help="Show version and exit"),
+        json_mode: bool = typer.Option(False, "--json", help="Enable machine-readable JSON output mode"),
+        yes: bool = typer.Option(False, "--yes", "-y", help="Auto-accept all file changes without prompting"),
+    ) -> None:
+        """Initialize process-wide runtime state for every CLI invocation."""
+
+        if version:
+            if json_mode:
+                import json
+                print(json.dumps({"version": __version__}))
+            else:
+                Console().print(f"Velune v{__version__}")
+            raise typer.Exit()
+
+        # Developers can opt into full internal logs with --verbose/-v.
+        if verbose:
+            logging.getLogger("velune").setLevel(logging.DEBUG)
+        else:
+            logging.getLogger("velune").setLevel(logging.WARNING)
+
+        if yes:
+            from velune.execution.diff_preview import configure as _configure_diff
+            _configure_diff(auto_accept=True)
+
+        try:
+            runtime = build_runtime(workspace=workspace, config_path=config_path, verbose=verbose)
+        except Exception as e:
+            if json_mode:
+                import json
+                print(json.dumps({"error": f"Velune failed to start: {e}"}))
+            else:
+                Console().print(
+                    f"[bold red]Velune failed to start:[/bold red] {e}\n"
+                    "Run [bold cyan]`velune doctor check`[/bold cyan] to diagnose the issue."
+                )
+            raise typer.Exit(1)
+
+        runtime.container.register_instance("runtime.auto_accept", yes)
+
+        ctx.obj = CLIContext(
+            workspace=workspace,
+            config_path=config_path,
+            verbose=verbose,
+            runtime=runtime,
+            json_mode=json_mode,
+            yes=yes,
+        )
+
+        if ctx.invoked_subcommand is None:
+            if json_mode:
+                import json
+                print(json.dumps({
+                    "status": "ready",
+                    "workspace": str(workspace),
+                    "config_path": str(config_path) if config_path else None,
+                    "version": __version__
+                }))
+            else:
+                from velune.providers.keystore import list_configured_providers
+                configured = list_configured_providers()
+                ollama_live = _check_ollama_live()
+
+                if not configured and not ollama_live:
+                    runtime.console.print(Panel(
+                        "[yellow]No AI providers configured.[/yellow]\n"
+                        "[dim]Velune needs at least one provider to work.[/dim]",
+                        border_style="yellow",
+                    ))
+                    run_now = typer.confirm("Run setup now?", default=True)
+                    if run_now:
+                        from velune.cli.commands.setup import run_setup_wizard
+                        run_setup_wizard()
+                    else:
+                        runtime.console.print(
+                            "[dim]Run `velune setup` any time to configure providers.[/dim]"
+                        )
+                    # NO EXIT HERE — fall through to REPL regardless. The only
+                    # ways out of Velune are /exit, /quit, or Ctrl+C twice.
+
+                _show_startup_animation(runtime.console, workspace, config_path)
+                from velune.cli.repl import run_repl
+                run_repl(runtime)
+
+    register_commands(app, ServiceContainer())
+    return app
+
+
+app = create_app()

velune/cli/autocomplete.py

@@ -0,0 +1,76 @@
+from prompt_toolkit.completion import Completer, Completion
+from prompt_toolkit.document import Document
+
+SLASH_COMMANDS: list[tuple[str, str]] = [
+    ("ask",         "Send a prompt to the active model"),
+    ("run",         "Execute a task through the council"),
+    ("council",     "Force full council on a task"),
+    ("model",       "Switch the active model interactively"),
+    ("models",      "List all available models"),
+    ("mode",        "Show current session mode and settings"),
+    ("optimus",     "Switch to speed mode — smallest model, instant tier"),
+    ("godly",       "Switch to max power mode — largest model, full council"),
+    ("normal",      "Return to balanced normal mode"),
+    ("setup",       "Configure API provider keys"),
+    ("memory",      "Inspect memory tiers and session stats"),
+    ("session",     "Save, list, resume, or export sessions"),
+    ("usage",       "Show token usage and cost for this session"),
+    ("context",     "Show context window usage"),
+    ("diff",        "Show pending file changes as unified diff"),
+    ("doctor",      "Run environment health checks"),
+    ("help",        "Show all available commands"),
+    ("clear",       "Clear screen and conversation context"),
+    ("exit",        "Exit the Velune session"),
+    ("councilmodel","Assign specific models to council agent roles"),
+    ("cm",          "Assign specific models to council agent roles"),
+    ("roles",       "Show council role assignments table"),
+    ("pull",        "Download an Ollama model interactively"),
+    ("download",    "Download an Ollama model interactively"),
+    ("get",         "Download an Ollama model interactively"),
+    ("delete",      "Delete a locally installed Ollama model"),
+    ("remove",      "Delete a locally installed Ollama model"),
+    ("rm",          "Delete a locally installed Ollama model"),
+]
+
+_MODEL_PREFIX = "/model "
+
+
+class SlashCompleter(Completer):
+    def __init__(
+        self,
+        extra_commands: list[tuple[str, str]] | None = None,
+        model_ids: list[str] | None = None,
+    ) -> None:
+        self._commands = SLASH_COMMANDS.copy()
+        if extra_commands:
+            self._commands.extend(extra_commands)
+        self._model_ids: list[str] = model_ids or []
+
+    def get_completions(self, document: Document, complete_event):
+        text = document.text_before_cursor
+
+        if not text.startswith("/"):
+            return
+
+        # "/model <partial>" → complete model IDs
+        if text.startswith(_MODEL_PREFIX):
+            partial = text[len(_MODEL_PREFIX):]
+            for mid in self._model_ids:
+                if mid.startswith(partial):
+                    yield Completion(
+                        text=mid,
+                        start_position=-len(partial),
+                        display=mid,
+                    )
+            return
+
+        # "/<partial>" → complete command names
+        word = text[1:]
+        for cmd_name, description in self._commands:
+            if cmd_name.startswith(word.lower()):
+                yield Completion(
+                    text=cmd_name,
+                    start_position=-len(word),
+                    display=f"/{cmd_name}",
+                    display_meta=description,
+                )

velune/cli/banner.py

@@ -0,0 +1,98 @@
+from rich.console import Console, Group
+from rich.panel import Panel
+from rich.text import Text
+
+_TIER_COLORS: dict[str, str] = {
+    "critical": "red",
+    "low":      "red",
+    "marginal": "yellow",
+    "capable":  "green",
+    "powerful": "green",
+    "elite":    "cyan",
+}
+
+
+def render_startup_banner(
+    console: Console,
+    hardware_profile,
+    configured_providers: list[str],
+    ollama_live: bool,
+    workspace_name: str,
+    active_model_id: str | None,
+    version: str = "0.1.0",
+    project_type_name: str | None = None,
+) -> None:
+    # Header
+    header = Text()
+    header.append("velune ", style="bold cyan")
+    header.append(f"v{version}", style="dim")
+    header.append("  ·  ", style="dim")
+    header.append(workspace_name, style="bold white")
+
+    # Hardware
+    tier = hardware_profile.tier.value
+    color = _TIER_COLORS.get(tier, "white")
+    vram_gb = hardware_profile.vram_total_gb
+    gpu_part = (
+        f"{hardware_profile.gpu_name} ({vram_gb:.0f} GB)"
+        if hardware_profile.gpu_name and vram_gb is not None
+        else (hardware_profile.gpu_name if hardware_profile.gpu_name else "CPU only")
+    )
+    hw_line = Text()
+    hw_line.append("hardware  ", style="dim")
+    hw_line.append(f"{hardware_profile.total_ram_gb:.0f} GB RAM", style="white")
+    hw_line.append("  ·  ", style="dim")
+    hw_line.append(gpu_part, style="white")
+    hw_line.append("  ·  ", style="dim")
+    hw_line.append(f"tier: {tier}", style=color)
+
+    # Providers
+    parts: list[str] = []
+    if ollama_live:
+        parts.append("[green]● ollama[/green]")
+    for pid in configured_providers:
+        if pid != "ollama":
+            parts.append(f"[green]● {pid}[/green]")
+    if not parts:
+        parts.append("[red]✗ no providers[/red]")
+    providers_text = Text.from_markup("providers  " + "  ".join(parts))
+
+    # Model
+    if active_model_id:
+        model_text = Text.from_markup(
+            f"[dim]model[/dim]     [cyan]{active_model_id}[/cyan]"
+        )
+    else:
+        model_text = Text.from_markup(
+            "[dim]model[/dim]     [yellow]none — type /model to select[/yellow]"
+        )
+
+    # Project type (optional)
+    project_text = None
+    if project_type_name and project_type_name != "Unknown":
+        project_text = Text.from_markup(
+            f"[dim]project[/dim]   [green]{project_type_name}[/green]"
+        )
+
+    # Hint
+    hint = Text("type a prompt or ", style="dim")
+    hint.append("/help", style="cyan")
+    hint.append(" for commands", style="dim")
+
+    body_items = [header, hw_line, providers_text, model_text]
+    if project_text:
+        body_items.append(project_text)
+    body_items.append(hint)
+
+    console.print(Panel(
+        Group(*body_items),
+        border_style="cyan",
+        padding=(0, 1),
+    ))
+
+    for warning in hardware_profile.warnings:
+        console.print(f"  [yellow]⚠[/yellow] [dim]{warning}[/dim]")
+    for suggestion in hardware_profile.suggestions:
+        console.print(f"  [dim]→ {suggestion}[/dim]")
+    if hardware_profile.warnings or hardware_profile.suggestions:
+        console.print()

velune/cli/commands/__init__.py

@@ -0,0 +1,32 @@
+"""Built-in Velune CLI command modules."""
+
+from velune.cli.commands.ask import ask_cmd, ask_command
+from velune.cli.commands.chat import chat_command
+from velune.cli.commands.config import config_cmd
+from velune.cli.commands.daemon import daemon_cmd
+from velune.cli.commands.doctor import doctor_cmd
+from velune.cli.commands.init import init_command
+from velune.cli.commands.mcp import mcp_cmd, mcp_serve
+from velune.cli.commands.memory import memory_cmd
+from velune.cli.commands.models import models_cmd
+from velune.cli.commands.run import run_cmd, run_command
+from velune.cli.commands.setup import setup_command
+from velune.cli.commands.workspace import workspace_cmd
+
+__all__ = [
+    "ask_cmd",
+    "ask_command",
+    "chat_command",
+    "config_cmd",
+    "init_command",
+    "memory_cmd",
+    "setup_command",
+    "models_cmd",
+    "run_cmd",
+    "run_command",
+    "workspace_cmd",
+    "daemon_cmd",
+    "doctor_cmd",
+    "mcp_cmd",
+    "mcp_serve",
+]

velune/cli/commands/ask.py

@@ -0,0 +1,149 @@
+"""Interactive ask command boundary — routes natural language questions to the Council."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import typer
+
+if TYPE_CHECKING:
+    from velune.cognition.firewall import CognitiveFirewall
+from rich.console import Console
+
+from velune.cli.context import CLIContext
+from velune.cli.display.council_view import CouncilDisplayView
+from velune.repository.schemas import RepositorySnapshot
+
+console = Console()
+ask_cmd = typer.Typer(help="Interactive prompt entry point")
+
+
+def ask_command(
+    ctx: typer.Context,
+    prompt: str | None = typer.Argument(None, help="Question or task to route through Velune"),
+    council_tier: str | None = typer.Option(None, "--council-tier", help="Override council execution tier (instant, standard, full)"),
+) -> None:
+    """Deliberates with the Reasoning Council for conceptual answers and code reviews without execution."""
+
+    if ctx.invoked_subcommand is not None:
+        return
+
+    cli_context = ctx.obj
+    if not isinstance(cli_context, CLIContext):
+        raise typer.BadParameter("CLI context was not properly initialized")
+
+    if not prompt:
+        if cli_context.json_mode:
+            import json
+            print(json.dumps({"error": "Prompt argument is required in JSON mode"}))
+            raise typer.Exit(code=1)
+        # Prompt user interactively if no prompt argument is given
+        prompt = typer.prompt("What would you like to ask Velune?")
+        if not prompt:
+            console.print("[yellow]Empty query. Exiting.[/yellow]")
+            return
+
+    from velune.core.event_loop import submit
+    submit(_ask_command_async(cli_context, prompt, council_tier))
+
+
+async def _ask_command_async(cli_context: CLIContext, prompt: str, council_tier: str | None = None) -> None:
+    # 1. Access services from DI container
+    container = cli_context.container
+    lifecycle = container.get("runtime.lifecycle")
+    model_registry = container.get("runtime.model_registry")
+    model_specialization = container.get("runtime.council_orchestrator").mapper
+    repo_cognition = container.get("runtime.repository_cognition")
+    orchestrator = container.get("runtime.council_orchestrator")
+
+    # 2. Boot subsystems
+    if not cli_context.json_mode:
+        console.print("[bold cyan]⠋[/bold cyan] Bootstrapping Cognitive Operating System kernel...")
+    await lifecycle.startup()
+    await model_registry.refresh()
+
+    # Onboarding preflight check gate
+    from velune.cli.commands.preflight import run_preflight_check
+    if not await run_preflight_check(container, console if not cli_context.json_mode else None):
+        if cli_context.json_mode:
+            import json
+            print(json.dumps({"error": "Preflight check failed. Ensure workspace is initialized and models are scanned."}))
+        await lifecycle.shutdown()
+        return
+
+    if not cli_context.json_mode:
+        display = CouncilDisplayView(console)
+        display.render_header(prompt)
+
+    # 3. Map role specializations
+    roles = model_specialization.map_roles()
+    if not cli_context.json_mode:
+        display.render_role_assignments(roles)
+
+    from velune.cognition.firewall import CognitiveFirewall
+    firewall = CognitiveFirewall()
+
+    # 4. Ingest and Scan AST Snapshot
+    snapshot: RepositorySnapshot | None = None
+    if not cli_context.json_mode:
+        with console.status("[bold magenta]⚡ Scanning codebase AST structure...[/bold magenta]"):
+            snapshot = repo_cognition.index()
+    else:
+        snapshot = repo_cognition.index()
+
+    formatted_snap = _format_snapshot_context_safe(snapshot, firewall)
+
+    # 5. deliberating debate loop
+    council_res = None
+    if not cli_context.json_mode:
+        with console.status("[bold magenta]🧠 Deliberating Reasoning Council debate...[/bold magenta]"):
+            council_res = await orchestrator.execute_task(prompt, formatted_snap, council_tier=council_tier)
+    else:
+        council_res = await orchestrator.execute_task(prompt, formatted_snap, council_tier=council_tier)
+
+    arbitration = council_res["arbitration"]
+    final_summary = council_res["final_summary"]
+
+    if cli_context.json_mode:
+        import json
+        roles_dict = {role.value: model_id for role, model_id in roles.items()}
+        print(json.dumps({
+            "prompt": prompt,
+            "roles": roles_dict,
+            "reviewer_report": council_res["reviewer_report"],
+            "challenger_report": council_res["challenger_report"],
+            "arbitration": arbitration,
+            "final_summary": final_summary,
+        }))
+    else:
+        # 6. Render reports
+        display.render_step_header("Council Reviewer", "🔍")
+        display.render_reviewer_report(council_res["reviewer_report"])
+
+        display.render_step_header("Council Challenger", "⚡")
+        display.render_challenger_report(council_res["challenger_report"])
+
+        display.render_step_header("Arbitration Engine", "⚖️")
+        display.render_arbitration_result(arbitration)
+
+        display.render_step_header("Council Synthesizer", "🚀")
+        display.render_synthesized_response(final_summary)
+
+    # 7. Shutdown
+    await lifecycle.shutdown()
+
+
+def _format_snapshot_context_safe(snapshot: RepositorySnapshot, firewall: CognitiveFirewall) -> str:
+    """Format snapshot metadata context for query prompt securely."""
+    lines = [f"Repository Root: {snapshot.root_path}"]
+    lines.append("Codebase Files:")
+    for f in snapshot.files[:25]:
+        # Only expose path and language — no raw symbol names or content
+        risk_marker = " [⚠ injection-risk]" if f.metadata.get("injection_risk") else ""
+        lines.append(f"  - {f.path} ({f.language.value}){risk_marker}")
+        # Symbol names are safe to expose (identifiers, not content)
+        if f.symbols:
+            safe_syms = [s.name for s in f.symbols[:3] if s.name.isidentifier()]
+            if safe_syms:
+                lines.append(f"    Symbols: {', '.join(safe_syms)}")
+    return "\n".join(lines)

velune/cli/commands/base.py

@@ -0,0 +1,16 @@
+"""Command registration contracts."""
+
+from __future__ import annotations
+
+from typing import Protocol
+
+import typer
+
+from velune.kernel.registry import ServiceContainer
+
+
+class CommandRegistrar(Protocol):
+    """A command module that can attach itself to a Typer app."""
+
+    def register(self, app: typer.Typer, container: ServiceContainer) -> None:
+        """Register the command group or command callbacks."""