velune-cli 0.9.0__py3-none-any.whl

velune/__init__.py

@@ -0,0 +1,5 @@
+"""Velune package metadata."""
+
+__version__ = "0.9.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,208 @@
+"""Typer application factory for Velune."""
+
+from __future__ import annotations
+
+import sys
+
+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.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.core.startup_profiler import mark as _startup_mark
+from velune.kernel.registry import ServiceContainer
+
+_startup_mark("cli.app imported (typer/rich/runtime ready)")
+
+
+def _startup_frames(workspace: Path, config_path: Path | None) -> list[Panel]:
+    body = (
+        f"[bold cyan]Velune[/bold cyan] [dim]v{__version__}[/dim] · "
+        "[green]Local-first AI Orchestrator[/green]"
+    )
+    frame = Panel(
+        Text.from_markup(body),
+        border_style="cyan",
+        padding=(0, 2),
+    )
+    return [frame]
+
+
+def _show_startup_banner(console: Console, workspace: Path, config_path: Path | None) -> None:
+    """Render the welcome banner once, instantly.
+
+    The previous implementation animated the banner frame-by-frame with a
+    ``time.sleep(0.08)`` per line — ~0.6-1.2s of pure blocking delay on every
+    interactive launch. Modern AI terminals show their surface immediately;
+    perceived speed comes from an instant prompt, not a reveal animation.
+    """
+    import sys
+
+    if not sys.stdout.isatty():
+        return  # Skip banner in CI, piped output, --quiet mode
+
+    console.print(_startup_frames(workspace, config_path)[-1])
+
+
+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"[bold cyan]velune[/bold cyan] version [green]{__version__}[/green]"
+                )
+            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:
+                from velune.cli.rendering.error_panel import render_error, render_unexpected_error
+                from velune.core.errors.catalog import VeluneError, WorkspaceNotInitializedError
+
+                if isinstance(e, VeluneError):
+                    Console().print(render_error(e))
+                elif "velune.toml" in str(e).lower() or "workspace" in str(e).lower():
+                    Console().print(render_error(WorkspaceNotInitializedError(str(e))))
+                else:
+                    Console().print(render_unexpected_error(e))
+            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
+
+                # list_configured_providers already includes a (short, deduped)
+                # Ollama reachability probe, so a single call suffices.
+                configured = list_configured_providers()
+
+                if not configured:
+                    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_banner(runtime.console, workspace, config_path)
+                _startup_mark("REPL handoff (prompt visible)")
+                from velune.kernel.entrypoint import launch
+
+                launch(runtime)
+
+    register_commands(app, ServiceContainer())
+    return app
+
+
+app = create_app()

velune/cli/autocomplete.py

@@ -0,0 +1,80 @@
+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"),
+    ("graph", "Render a hierarchical tree of knowledge graph entities"),
+    ("bench", "View or run empirical model capability benchmarks"),
+    ("config", "Show current system configuration settings"),
+    ("history", "Show REPL command execution history"),
+]
+
+_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,60 @@
+from rich.console import Console
+
+
+def render_startup_banner(
+    console: Console,
+    hardware_profile,
+    configured_providers: list[str],
+    ollama_live: bool,
+    workspace_path: str,
+    active_model_id: str | None,
+    version: str = "0.1.0",
+    project_type_name: str | None = None,
+) -> None:
+    # Title header
+    console.print(f"[bold white]Velune {version}[/bold white]")
+    console.print("[dim]Keys: /help for commands, /exit to exit[/dim]")
+
+    # Linked workspace path
+    pt_suffix = (
+        f" ({project_type_name})" if project_type_name and project_type_name != "Unknown" else ""
+    )
+    console.print(f"Linked to: [white]{workspace_path}[/white]{pt_suffix}")
+
+    # Hardware/System info
+    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 or "CPU only")
+    )
+    ram_part = f"{hardware_profile.total_ram_gb:.0f}GB RAM"
+
+    provider_list = []
+    if ollama_live:
+        provider_list.append("ollama")
+    for pid in configured_providers:
+        if pid != "ollama":
+            provider_list.append(pid)
+
+    providers_str = ", ".join(provider_list) if provider_list else "none"
+    console.print(f"System: {ram_part} • {gpu_part} • providers: {providers_str}")
+
+    # Model
+    if active_model_id:
+        console.print(f"Model: [cyan]{active_model_id}[/cyan]")
+    else:
+        console.print("Model: [yellow]none — type /model to select[/yellow]")
+    console.print()
+
+    # Warnings/suggestions
+    if hardware_profile.warnings:
+        for warning in hardware_profile.warnings:
+            console.print(f"[yellow]⚠[/yellow]  [yellow]{warning}[/yellow]")
+
+    if hardware_profile.suggestions:
+        for suggestion in hardware_profile.suggestions:
+            console.print(f"[cyan]→[/cyan]  {suggestion}")
+
+    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,175 @@
+"""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."""