velune-cli 0.9.0__py3-none-any.whl

velune/cli/commands/chat.py

@@ -0,0 +1,228 @@
+"""Interactive conversational chat entry point with low-latency streaming."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from velune.cli.context import CLIContext
+from velune.cognition.firewall import CognitiveFirewall
+from velune.models.specializations import CouncilRole
+from velune.repository.schemas import RepositorySnapshot
+
+console = Console()
+
+
+def chat_command(ctx: typer.Context) -> None:
+    """Converses directly with the codebase using a fast, single-model streaming interface."""
+    cli_context = ctx.obj
+    if not isinstance(cli_context, CLIContext):
+        raise typer.BadParameter("CLI context was not properly initialized")
+
+    from velune.core.event_loop import submit
+
+    submit(_chat_command_async(cli_context))
+
+
+async def _chat_command_async(cli_context: CLIContext) -> 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")
+
+    # 2. Boot subsystems
+    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):
+        await lifecycle.shutdown()
+        return
+
+    # 3. Map Coder role to get fast, single-model access
+    roles = model_specialization.map_roles()
+    coder_model = roles.get(CouncilRole.CODER)
+    if not coder_model:
+        from velune.cli.rendering.error_panel import render_error
+        from velune.core.errors.catalog import NoModelsAvailableError
+
+        console.print(
+            render_error(
+                NoModelsAvailableError(
+                    cause_override="No Coder model is assigned or found in the model catalog."
+                )
+            )
+        )
+        await lifecycle.shutdown()
+        return
+
+    provider_registry = container.get("runtime.provider_registry")
+    provider = provider_registry.get_or_raise(coder_model.provider_id)
+
+    # 4. Ingest and Scan AST Snapshot
+    with console.status("[bold magenta]⚡ Scanning codebase AST structure...[/bold magenta]"):
+        snapshot = repo_cognition.index()
+
+    firewall = CognitiveFirewall()
+    formatted_snap = _format_snapshot_context_safe(snapshot, firewall)
+
+    # 5. Initialize conversation history with codebase context
+    messages = [
+        {
+            "role": "system",
+            "content": (
+                "You are the Lead Coder for the Velune Reasoning Council, serving in low-latency conversational mode.\n"
+                "Your objective is to answer questions, explain code, and assist with natural language tasks concisely and directly.\n"
+                "You have access to the user's workspace context details below.\n"
+                "Keep responses focused, and do not use verbose pleasantries."
+            ),
+        },
+        {"role": "system", "content": f"User's workspace context summary:\n{formatted_snap}"},
+    ]
+
+    console.print()
+    console.print(
+        "[bold green]Velune Chat Mode[/bold green] (type [cyan]!exit[/cyan] to quit, [cyan]!run <task>[/cyan] to escalate to full council)"
+    )
+    console.print(
+        "--------------------------------------------------------------------------------"
+    )
+
+    while True:
+        try:
+            user_input = console.input("[bold green]You:[/bold green] ").strip()
+        except (KeyboardInterrupt, EOFError):
+            console.print("\n[yellow]Exiting chat session. Goodbye![/yellow]")
+            break
+
+        if not user_input:
+            continue
+
+        if user_input.lower() in ("!exit", "!quit"):
+            console.print("[yellow]Exiting chat session. Goodbye![/yellow]")
+            break
+
+        # 6. Escalation handler to full council
+        if user_input.startswith("!run "):
+            task = user_input[5:].strip()
+            if not task:
+                console.print(
+                    "[yellow]Usage: !run <task>  — please specify a task to execute[/yellow]"
+                )
+                continue
+            console.print(
+                f"[bold cyan]Escalating task to full Reasoning Council: '{task}'...[/bold cyan]"
+            )
+
+            orchestration_engine = container.get("runtime.orchestration_engine")
+            try:
+                milestones = []
+                async for milestone in orchestration_engine.stream(task):
+                    console.print(f"  [bold cyan]•[/bold cyan] {milestone}")
+                    milestones.append(milestone)
+
+                run_id = None
+                for m in milestones:
+                    if hasattr(m, "run_id"):
+                        run_id = m.run_id
+                        break
+                    elif isinstance(m, str) and m.startswith("[") and "]" in m:
+                        run_id = m.split("]")[0][1:]
+                        break
+                state = orchestration_engine.get_state(run_id) if run_id else None
+                if state:
+                    from velune.orchestration.schemas import ExecutionStatus
+
+                    success = state.status == ExecutionStatus.COMPLETED
+                    if success:
+                        console.print(
+                            f"[bold green]✓ Execution completed successfully: {state.output or 'Done'}[/bold green]"
+                        )
+                    else:
+                        from velune.cli.rendering.error_panel import render_unexpected_error
+
+                        console.print(
+                            render_unexpected_error(
+                                RuntimeError(state.error or "Unknown execution failure")
+                            )
+                        )
+                else:
+                    console.print("[dim]Council run completed but returned no state.[/dim]")
+            except Exception as e:
+                from velune.cli.rendering.error_panel import render_error, render_unexpected_error
+                from velune.core.errors.catalog import VeluneError
+
+                if isinstance(e, VeluneError):
+                    console.print(render_error(e))
+                else:
+                    console.print(render_unexpected_error(e))
+            continue
+
+        # 7. Low-latency, streaming conversational execution
+        messages.append({"role": "user", "content": user_input})
+        from velune.core.types.inference import InferenceRequest
+
+        request = InferenceRequest(
+            model_id=coder_model.model_id,
+            messages=messages,
+            temperature=0.3,
+        )
+
+        console.print("[bold cyan]Velune:[/bold cyan] ", end="")
+        full_response_content = []
+
+        try:
+            capabilities = provider.get_capabilities()
+            supports_streaming = getattr(capabilities, "supports_streaming", False) and hasattr(
+                provider, "stream"
+            )
+
+            if supports_streaming:
+                try:
+                    async for chunk in provider.stream(request):
+                        print(chunk.content, end="", flush=True)
+                        full_response_content.append(chunk.content)
+                    print()
+                except KeyboardInterrupt:
+                    print()
+                    console.print("[yellow]\nGeneration cancelled by user.[/yellow]")
+            else:
+                response = await provider.infer(request)
+                console.print(response.content)
+                full_response_content.append(response.content)
+
+            if full_response_content:
+                assistant_response = "".join(full_response_content)
+                messages.append({"role": "assistant", "content": assistant_response})
+
+        except Exception as e:
+            print()
+            from velune.cli.rendering.error_panel import render_error, render_unexpected_error
+            from velune.core.errors.catalog import VeluneError
+
+            if isinstance(e, VeluneError):
+                console.print(render_error(e))
+            else:
+                console.print(render_unexpected_error(e))
+
+    # 8. 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]:
+        risk_marker = " [⚠ injection-risk]" if f.metadata.get("injection_risk") else ""
+        lines.append(f"  - {f.path} ({f.language.value}){risk_marker}")
+        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/config.py

@@ -0,0 +1,224 @@
+"""Config command - velune config set/get/show."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+
+from velune.cli.context import CLIContext
+
+console = Console()
+
+config_cmd = typer.Typer(help="Configuration management commands")
+
+
+@config_cmd.command("set")
+def config_set(
+    ctx: typer.Context,
+    key: str = typer.Argument(..., help="Configuration key (e.g. providers.default_provider)"),
+    value: str = typer.Argument(..., help="Configuration value"),
+) -> None:
+    """Set a configuration value in velune.toml."""
+    cli_context = ctx.obj if isinstance(ctx.obj, CLIContext) else None
+    if not cli_context:
+        if ctx.obj and getattr(ctx.obj, "json_mode", False):
+            import json
+
+            print(json.dumps({"error": "CLI context is uninitialized"}))
+        else:
+            from velune.cli.rendering.error_panel import render_error
+            from velune.core.errors.catalog import WorkspaceNotInitializedError
+
+            console.print(
+                render_error(
+                    WorkspaceNotInitializedError(
+                        cause_override="CLI context was not properly initialized before this command."
+                    )
+                )
+            )
+        raise typer.Exit(1)
+
+    config_path = cli_context.config_path or (cli_context.workspace / "velune.toml")
+
+    # Load raw TOML
+    import toml
+
+    try:
+        if config_path.exists():
+            data = toml.load(config_path)
+        else:
+            data = {}
+    except Exception as e:
+        if cli_context.json_mode:
+            import json
+
+            print(json.dumps({"error": f"Failed to load existing config: {e}"}))
+        else:
+            from velune.cli.rendering.error_panel import render_unexpected_error
+
+            console.print(render_unexpected_error(e))
+        data = {}
+
+    # Set the nested key
+    parts = key.split(".")
+    curr = data
+    for part in parts[:-1]:
+        if part not in curr or not isinstance(curr[part], dict):
+            curr[part] = {}
+        curr = curr[part]
+
+    # Convert value to correct type (bool, int, float, str)
+    typed_val: Any = value
+    if value.lower() == "true":
+        typed_val = True
+    elif value.lower() == "false":
+        typed_val = False
+    else:
+        try:
+            if "." in value:
+                typed_val = float(value)
+            else:
+                typed_val = int(value)
+        except ValueError:
+            pass
+
+    curr[parts[-1]] = typed_val
+
+    # Save back
+    try:
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(config_path, "w") as f:
+            toml.dump(data, f)
+        if cli_context.json_mode:
+            import json
+
+            print(
+                json.dumps(
+                    {"success": True, "key": key, "value": typed_val, "path": str(config_path)}
+                )
+            )
+        else:
+            console.print(
+                f"[green]✓ Successfully set [bold]{key}[/bold] to [bold]{typed_val}[/bold] in {config_path}[/green]"
+            )
+    except Exception as e:
+        if cli_context.json_mode:
+            import json
+
+            print(json.dumps({"error": f"Failed to save config: {e}"}))
+        else:
+            from velune.cli.rendering.error_panel import render_unexpected_error
+
+            console.print(render_unexpected_error(e))
+        raise typer.Exit(1)
+
+
+@config_cmd.command("get")
+def config_get(
+    ctx: typer.Context,
+    key: str = typer.Argument(..., help="Configuration key (e.g. providers.default_provider)"),
+) -> None:
+    """Get a configuration value."""
+    cli_context = ctx.obj if isinstance(ctx.obj, CLIContext) else None
+    if not cli_context:
+        if ctx.obj and getattr(ctx.obj, "json_mode", False):
+            import json
+
+            print(json.dumps({"error": "CLI context is uninitialized"}))
+        else:
+            from velune.cli.rendering.error_panel import render_error
+            from velune.core.errors.catalog import WorkspaceNotInitializedError
+
+            console.print(
+                render_error(
+                    WorkspaceNotInitializedError(
+                        cause_override="CLI context was not properly initialized before this command."
+                    )
+                )
+            )
+        raise typer.Exit(1)
+
+    # Fetch from the active loaded config object which is resolved and typed
+    config = cli_context.config
+    parts = key.split(".")
+    curr: Any = config
+
+    for part in parts:
+        if hasattr(curr, part):
+            curr = getattr(curr, part)
+        elif isinstance(curr, dict) and part in curr:
+            curr = curr[part]
+        else:
+            if cli_context.json_mode:
+                import json
+
+                print(json.dumps({"error": f"Key '{key}' not found in active configuration"}))
+            else:
+                console.print(f"[red]Key '{key}' not found in active configuration.[/red]")
+            raise typer.Exit(1)
+
+    if cli_context.json_mode:
+        import json
+
+        print(json.dumps({"key": key, "value": curr}))
+    else:
+        console.print(f"[bold]{key}[/bold] = {curr}")
+
+
+@config_cmd.command("show")
+def config_show(ctx: typer.Context) -> None:
+    """Show all configuration."""
+    cli_context = ctx.obj if isinstance(ctx.obj, CLIContext) else None
+
+    if cli_context is None:
+        if ctx.obj and getattr(ctx.obj, "json_mode", False):
+            import json
+
+            print(json.dumps({"error": "Configuration not yet loaded"}))
+        else:
+            console.print(Panel.fit("Configuration not yet loaded.", title="Configuration"))
+        return
+
+    config = cli_context.config
+    if cli_context.json_mode:
+        import json
+
+        print(
+            json.dumps(
+                {
+                    "project": {
+                        "name": config.project.name,
+                        "version": config.project.version,
+                    },
+                    "providers": {
+                        "default": config.providers.default_provider,
+                    },
+                    "workspace": {
+                        "index_on_init": config.workspace.index_on_init,
+                        "watch_files": config.workspace.watch_files,
+                        "git_aware": config.workspace.git_aware,
+                    },
+                    "telemetry": {
+                        "enabled": config.telemetry.enabled,
+                        "log_level": config.telemetry.log_level,
+                    },
+                }
+            )
+        )
+    else:
+        console.print(
+            Panel.fit(
+                f"project.name = {config.project.name}\n"
+                f"project.version = {config.project.version}\n"
+                f"providers.default = {config.providers.default_provider}\n"
+                f"workspace.index_on_init = {config.workspace.index_on_init}\n"
+                f"workspace.watch_files = {config.workspace.watch_files}\n"
+                f"workspace.git_aware = {config.workspace.git_aware}\n"
+                f"telemetry.enabled = {config.telemetry.enabled}\n"
+                f"telemetry.log_level = {config.telemetry.log_level}",
+                title="Configuration",
+            )
+        )

velune/cli/commands/daemon.py

@@ -0,0 +1,88 @@
+import os
+import signal
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from velune.daemon.client import DaemonClient
+from velune.daemon.transport import DAEMON_PID_FILE
+
+daemon_cmd = typer.Typer(help="Velune daemon management")
+console = Console()
+
+
+@daemon_cmd.command("start")
+def daemon_start(workspace: Path = typer.Option(Path.cwd(), help="Workspace root")):
+    """Start Velune daemon in background."""
+    if DaemonClient.is_running():
+        console.print("[yellow]Daemon is already running.[/yellow]")
+        return
+
+    workspace_abs = workspace.resolve()
+
+    # Detached background process spawn
+    if sys.platform == "win32":
+        subprocess.Popen(
+            [sys.executable, "-m", "velune.daemon.server", str(workspace_abs)],
+            start_new_session=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+    else:
+        subprocess.Popen(
+            [sys.executable, "-m", "velune.daemon.server", str(workspace_abs)],
+            start_new_session=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+
+    # Wait for daemon to become active
+    for _ in range(30):
+        time.sleep(0.1)
+        if DaemonClient.is_running():
+            console.print("[green]Daemon started.[/green]")
+            return
+
+    console.print("[red]Failed to start daemon.[/red]")
+
+
+@daemon_cmd.command("stop")
+def daemon_stop():
+    """Stop background Velune daemon process."""
+    if not DaemonClient.is_running():
+        console.print("[yellow]Daemon is not running.[/yellow]")
+        return
+
+    if DAEMON_PID_FILE.exists():
+        pid = int(DAEMON_PID_FILE.read_text())
+        try:
+            os.kill(pid, signal.SIGTERM)
+            console.print("[green]Daemon stopped.[/green]")
+        except Exception as e:
+            console.print(f"[red]Failed to stop daemon PID {pid}: {e}[/red]")
+        finally:
+            try:
+                DAEMON_PID_FILE.unlink()
+            except Exception:
+                pass
+    else:
+        console.print("[yellow]Daemon running but PID file missing.[/yellow]")
+
+
+@daemon_cmd.command("status")
+def daemon_status():
+    """Display daemon running status and PID."""
+    if DaemonClient.is_running():
+        try:
+            from velune.kernel.entrypoint import run_async
+
+            result = run_async(DaemonClient.send_command("ping"))
+            console.print(f"[green]Daemon running (PID: {result['pid']})[/green]")
+        except Exception as e:
+            console.print(f"[red]Daemon running but communication failed: {e}[/red]")
+    else:
+        console.print("[yellow]Daemon not running[/yellow]")