velune-cli 1.0.0__py3-none-any.whl

velune/cli/commands/chat.py

@@ -0,0 +1,188 @@
+"""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:
+        console.print("[bold red]✗ No Coder model assigned or found. Make sure your model catalog is scanned.[/bold red]")
+        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("[bold red]Error: please specify a task to execute (e.g. !run implement feature x)[/bold red]")
+                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:
+                        console.print(f"[bold red]✗ Execution failed: {state.error}[/bold red]")
+                else:
+                    console.print("[bold red]✗ Escalated execution failed or did not return a state.[/bold red]")
+            except Exception as e:
+                console.print(f"[bold red]✗ Escalation error: {e}[/bold red]")
+            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()
+            console.print(f"[bold red]Error streaming response: {e}[/bold red]")
+
+    # 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,182 @@
+"""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:
+            console.print("[red]CLI context is uninitialized.[/red]")
+        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:
+            console.print(f"[red]Failed to load existing config: {e}[/red]")
+        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:
+            console.print(f"[red]Failed to save config: {e}[/red]")
+        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:
+            console.print("[red]CLI context is uninitialized.[/red]")
+        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,85 @@
+import asyncio
+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:
+            # Intentional: sync CLI callback, not inside running loop
+            result = asyncio.run(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]")