velune-cli 0.9.0__py3-none-any.whl

velune/cli/commands/preflight.py

@@ -0,0 +1,95 @@
+"""Preflight check validation for model availability and workspace initialization."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from rich.box import ROUNDED
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from velune.kernel.registry import ServiceContainer
+
+
+async def run_preflight_check(container: ServiceContainer, console: Console | None = None) -> bool:
+    """Runs preflight checks for models and workspace state.
+
+    If checks fail, displays a gorgeous error panel with copy-pasteable fix commands and returns False.
+    Otherwise returns True.
+    """
+    issues = []
+
+    # 1. Check workspace initialization
+    workspace = container.get("runtime.workspace")
+    if not isinstance(workspace, Path):
+        workspace = Path(workspace)
+
+    # Guard: workspace must exist and be a git repository. On a brand-new
+    # install neither will be true — show a single targeted message and bail
+    # early rather than cascading through checks that will all fail.
+    if not workspace.exists() or not (workspace / ".git").exists():
+        if console:
+            console.print()
+            console.print(
+                Panel(
+                    Text.from_markup(
+                        "This doesn't look like a code project yet. Navigate to your project\n"
+                        "folder and run [bold green]velune workspace init[/bold green] first."
+                    ),
+                    title="[bold yellow]⚠️  Not a Project Directory[/bold yellow]",
+                    border_style="yellow",
+                    box=ROUNDED,
+                    padding=(1, 2),
+                )
+            )
+            console.print()
+        return False
+
+    # We check for the presence of the Tree-sitter AST index folder or `.velune` directory structure
+    if not (workspace / ".velune" / "index").exists():
+        issues.append(
+            "Workspace has not been initialized yet.\n"
+            "  [bold white]Fix:[/bold white] Run the initialization command to parse the codebase:\n"
+            "       [bold green]velune workspace init[/bold green]"
+        )
+
+    # 2. Check models registry
+    registry = container.get("runtime.model_registry")
+    models = registry.list_all()
+    if not models:
+        issues.append(
+            "No model providers or local LLM instances were detected.\n"
+            "  [bold white]Fix:[/bold white] Make sure Ollama/LM-Studio is running, or check API keys, and run:\n"
+            "       [bold green]velune models scan --probe[/bold green]"
+        )
+
+    if issues:
+        if console:
+            console.print()
+
+            body_elements = [
+                "[bold red]Velune preflight check failed with the following blocking issues:[/bold red]\n"
+            ]
+            for i, issue in enumerate(issues, 1):
+                body_elements.append(f"\n[bold red]{i}.[/bold red] {issue}\n")
+
+            body_elements.append(
+                "\n[dim]Ensure these preflight requirements are satisfied before running Reasoning Council tasks.[/dim]"
+            )
+
+            panel_content = Text.from_markup("".join(body_elements))
+
+            console.print(
+                Panel(
+                    panel_content,
+                    title="[bold red]⚠️ Preflight Check Blocked[/bold red]",
+                    border_style="red",
+                    box=ROUNDED,
+                    padding=(1, 2),
+                )
+            )
+            console.print()
+        return False
+
+    return True

velune/cli/commands/run.py

@@ -0,0 +1,270 @@
+"""Run command — velune run <task> to trigger Reasoning Council deliberation and sandbox execution."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from velune.cli.context import CLIContext
+from velune.cognition.firewall import CognitiveFirewall
+from velune.repository.schemas import RepositorySnapshot
+
+console = Console()
+run_cmd = typer.Typer(help="Autonomous council run commands")
+
+
+def run_command(
+    ctx: typer.Context,
+    task: str = typer.Argument(..., help="Natural-language task to execute"),
+    dry_run: bool = typer.Option(
+        False,
+        "--dry-run",
+        "-d",
+        help="Deliberate but do not write modifications or execute scripts",
+    ),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Force execution without human confirm thresholds"
+    ),
+    yes: bool = typer.Option(
+        False, "--yes", "-y", help="Skip cost confirmation prompts (for scripting)"
+    ),
+) -> None:
+    """Deliberate with the stateful LangGraph Reasoning Council and execute in the secured sandbox."""
+
+    cli_context = ctx.obj
+    if not isinstance(cli_context, CLIContext):
+        raise typer.BadParameter("CLI context was not properly initialized")
+
+    # Propagate --yes into shared context so async helpers can read it
+    cli_context.yes = yes or cli_context.yes
+
+    from velune.core.event_loop import submit
+
+    submit(_run_command_async(cli_context, task, dry_run, force))
+
+
+async def _run_command_async(
+    cli_context: CLIContext,
+    task: str,
+    dry_run: bool,
+    force: bool,
+) -> None:
+    # 1. Access modern services from the DI container
+    container = cli_context.container
+    lifecycle = container.get("runtime.lifecycle")
+    model_registry = container.get("runtime.model_registry")
+    orchestration_engine = container.get("runtime.orchestration_engine")
+    # 2. Boot up Cognitive OS Subsystems
+    if not cli_context.json_mode:
+        console.print("[bold cyan]⠋[/bold cyan] Bootstrapping Cognitive Operating System kernel...")
+    await lifecycle.startup()
+
+    # 3. Refresh model catalog scan to assign specialized seats
+    if not cli_context.json_mode:
+        console.print(
+            "[bold cyan]⠋[/bold cyan] Probing system hardware and local/remote providers..."
+        )
+    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:
+        console.print()
+        console.print(
+            Panel(
+                f"[bold green]Task Auth:[/bold green] {task}",
+                border_style="cyan",
+                title="[bold cyan]Velune Stateful Execution Pipeline[/bold cyan]",
+            )
+        )
+        # 4. Stream Multi-Agent Council Deliberation & Execution Graph
+        console.print(
+            "[bold magenta]🧠 Streaming LangGraph stateful execution & checkpoint pipeline...[/bold magenta]\n"
+        )
+
+    # --- Pre-operation cost estimation gate ---
+    if not cli_context.json_mode:
+        _maybe_confirm_cost(cli_context, task)
+
+    from velune.orchestration.schemas import ExecutionStatus
+
+    async def stream_runner():
+        milestones = []
+        async for milestone in orchestration_engine.stream(task):
+            if not cli_context.json_mode:
+                console.print(f"  [bold cyan]•[/bold cyan] {milestone}")
+            milestones.append(milestone)
+
+        # Parse run_id from milestones (format: "[run_id] milestone_name")
+        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
+        return orchestration_engine.get_state(run_id) if run_id else None
+
+    state = await stream_runner()
+
+    # 5. Display Task Execution Results
+    if not cli_context.json_mode:
+        console.print()
+    if state is None:
+        if cli_context.json_mode:
+            import json
+
+            print(json.dumps({"error": "Pipeline failed to initialize state."}))
+        else:
+            console.print("[bold red]✗ Pipeline failed to initialize state.[/bold red]")
+        await lifecycle.shutdown()
+        return
+
+    success = state.status == ExecutionStatus.COMPLETED
+    attempts_count = len(state.attempts)
+    plan_steps = len(state.task_plan.steps) if state.task_plan else 0
+    checkpoints_count = len(state.checkpoints)
+
+    if cli_context.json_mode:
+        import json
+
+        print(
+            json.dumps(
+                {
+                    "success": success,
+                    "run_id": state.run_id,
+                    "plan_steps": plan_steps,
+                    "retry_attempts": attempts_count,
+                    "checkpoints_saved": checkpoints_count,
+                    "output": state.output or "Execution completed successfully.",
+                    "error": state.error,
+                    "validation_issues": state.validation_issues or [],
+                }
+            )
+        )
+    else:
+        if success:
+            console.print(
+                Panel(
+                    Text.assemble(
+                        ("[bold green]✓ STATEFUL AUTONOMOUS EXECUTION COMPLETED[/bold green]\n\n"),
+                        (f"Run ID: [bold white]{state.run_id}[/bold white]\n"),
+                        (f"Plan Steps: [bold white]{plan_steps}[/bold white] steps processed\n"),
+                        (f"Retry Attempts: [bold white]{attempts_count}[/bold white]\n"),
+                        (f"Checkpoints Saved: [bold white]{checkpoints_count}[/bold white]\n\n"),
+                        ("[bold green]Synthesized Output:[/bold green]\n"),
+                        (state.output or "Execution completed successfully."),
+                    ),
+                    border_style="green",
+                    title="[bold green]Success Report[/bold green]",
+                )
+            )
+        else:
+            console.print(
+                Panel(
+                    Text.assemble(
+                        ("[bold red]✗ AUTONOMOUS PIPELINE BLOCKED & ROLLED BACK[/bold red]\n\n"),
+                        (f"Run ID: [bold white]{state.run_id}[/bold white]\n"),
+                        (
+                            f"Failure Reason: [bold red]{state.error or 'Validation/Execution mismatch'}[/bold red]\n"
+                        ),
+                        (f"Retry Attempts: [bold white]{attempts_count}[/bold white]\n"),
+                        (
+                            f"Validation Issues: [bold yellow]{', '.join(state.validation_issues) if state.validation_issues else 'None'}[/bold yellow]\n\n"
+                        ),
+                        (
+                            "[yellow]State checkpointer stashed checkpoints, and Git workspace states have been preserved/rolled back.[/yellow]"
+                        ),
+                    ),
+                    border_style="red",
+                    title="[bold red]Rollback Execution Report[/bold red]",
+                )
+            )
+
+    # 6. Graceful Shutdown
+    await lifecycle.shutdown()
+
+
+def _maybe_confirm_cost(cli_context: CLIContext, task: str) -> None:
+    """Estimate cost of the upcoming run and prompt for confirmation if above threshold.
+
+    Raises SystemExit if the user declines.  Skipped when --yes is set.
+    """
+    from velune.telemetry.cost_estimator import CostEstimator
+
+    # Heuristic: estimate from task text alone as lower-bound; council adds far more tokens.
+    # We use a conservative 8× multiplier to account for repo context + multi-agent turns.
+    task_messages = [{"role": "user", "content": task}]
+
+    try:
+        model_registry = cli_context.container.get("runtime.model_registry")
+        models = model_registry.list_all() if model_registry else []
+    except Exception:
+        models = []
+
+    # Pick the first non-local model as the representative for cost estimation
+    cloud_model = next((m for m in models if not getattr(m, "is_local", False)), None)
+    if cloud_model is None:
+        return  # All local — no cost to warn about
+
+    estimator = CostEstimator()
+    base_tokens = estimator.estimate_tokens(task_messages, cloud_model)
+    estimated_tokens = base_tokens * 8  # council overhead multiplier
+    cost = estimator.estimate_cost(estimated_tokens, cloud_model)
+
+    if cost is None:
+        return
+
+    threshold = 0.01
+    try:
+        threshold = cli_context.config.providers.cost_threshold_usd
+    except Exception:
+        pass
+
+    if cost <= threshold:
+        return  # Below threshold — proceed silently
+
+    estimate_str = estimator.format_estimate(estimated_tokens, cost, cloud_model)
+    console.print(f"\n[yellow]Estimated cost:[/yellow] {estimate_str}")
+
+    if cli_context.yes:
+        return
+
+    answer = console.input("Proceed? [Y/n] ").strip().lower()
+    if answer in ("n", "no"):
+        console.print("[red]Aborted.[/red]")
+        raise typer.Exit(0)
+
+
+def _format_snapshot_context_safe(snapshot: RepositorySnapshot, firewall: CognitiveFirewall) -> str:
+    """Format the RepositorySnapshot securely as a text summary context for the planner/coder agents."""
+    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/setup.py

@@ -0,0 +1,184 @@
+"""Interactive provider setup wizard — stores keys in the OS keychain."""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.prompt import Confirm, Prompt
+from rich.table import Table
+
+from velune.providers.keystore import get_key, has_key, save_key
+
+console = Console()
+
+PROVIDER_METADATA: dict[str, dict] = {
+    "ollama": {
+        "label": "Ollama (local — free, no key needed)",
+        "requires_key": False,
+        "free": True,
+        "url": "https://ollama.com",
+    },
+    "groq": {
+        "label": "Groq (cloud — free tier, very fast)",
+        "requires_key": True,
+        "free": True,
+        "key_label": "Groq API key",
+        "get_key_url": "https://console.groq.com/keys",
+    },
+    "openai": {
+        "label": "OpenAI (cloud — GPT-4o, paid)",
+        "requires_key": True,
+        "free": False,
+        "key_label": "OpenAI API key",
+        "get_key_url": "https://platform.openai.com/api-keys",
+    },
+    "anthropic": {
+        "label": "Anthropic (cloud — Claude, paid)",
+        "requires_key": True,
+        "free": False,
+        "key_label": "Anthropic API key",
+        "get_key_url": "https://console.anthropic.com",
+    },
+    "xai": {
+        "label": "xAI (cloud — Grok, paid)",
+        "requires_key": True,
+        "free": False,
+        "key_label": "xAI API key",
+        "get_key_url": "https://console.x.ai",
+    },
+    "google": {
+        "label": "Google Gemini (cloud — 2.0 Flash free quota)",
+        "requires_key": True,
+        "free": True,
+        "key_label": "Google API key",
+        "get_key_url": "https://aistudio.google.com/app/apikey",
+    },
+    "openrouter": {
+        "label": "OpenRouter (cloud — one key, 100+ models)",
+        "requires_key": True,
+        "free": False,
+        "key_label": "OpenRouter API key",
+        "get_key_url": "https://openrouter.ai/keys",
+    },
+    "together": {
+        "label": "Together.AI (cloud — Llama, Qwen, DeepSeek, cheap)",
+        "requires_key": True,
+        "free": False,
+        "key_label": "Together.AI API key",
+        "get_key_url": "https://api.together.ai/settings/api-keys",
+    },
+    "fireworks": {
+        "label": "Fireworks.AI (cloud — fastest open-model inference)",
+        "requires_key": True,
+        "free": False,
+        "key_label": "Fireworks.AI API key",
+        "get_key_url": "https://fireworks.ai/account/api-keys",
+    },
+}
+
+
+def run_setup_wizard() -> None:
+    """Run the interactive API key setup wizard."""
+    console.print(
+        Panel(
+            "[bold cyan]Velune Provider Setup[/bold cyan]\n"
+            "[dim]Configure which AI providers you want to use.[/dim]\n"
+            "[dim]Keys are stored securely in your OS keychain.[/dim]\n\n"
+            "🔒 [bold green]Privacy Notice:[/bold green] [dim]Your code and conversations stay on this machine unless you configure a cloud provider.[/dim]",
+            border_style="cyan",
+            padding=(0, 1),
+        )
+    )
+    console.print()
+
+    chosen = _select_providers()
+    if not chosen:
+        console.print("[yellow]No providers selected. Run `velune setup` any time.[/yellow]")
+        return
+
+    configured: list[str] = []
+    for pid in chosen:
+        meta = PROVIDER_METADATA[pid]
+        if not meta.get("requires_key"):
+            console.print(f"[green]✓[/green] {meta['label']} — no key required")
+            configured.append(pid)
+            continue
+
+        console.print(f"\n[cyan]{meta['label']}[/cyan]")
+        console.print(f"  [dim]Get your key: {meta.get('get_key_url', '')}[/dim]")
+
+        if has_key(pid):
+            existing = get_key(pid)
+            masked = _mask_key(existing)
+            overwrite = Confirm.ask(
+                f"  Key already configured ({masked}). Replace it?",
+                default=False,
+            )
+            if not overwrite:
+                configured.append(pid)
+                continue
+
+        key = Prompt.ask(
+            f"  Enter {meta['key_label']}",
+            password=True,
+        )
+
+        if not key.strip():
+            console.print("  [yellow]Skipped — no key entered.[/yellow]")
+            continue
+
+        save_key(pid, key.strip())
+        console.print("  [green]✓ Saved to OS keychain[/green]")
+        configured.append(pid)
+
+    console.print()
+    if configured:
+        console.print(f"[bold green]✓ Configured providers:[/bold green] {', '.join(configured)}")
+        console.print("[dim]Run `velune doctor` to verify connectivity.[/dim]")
+
+
+def _select_providers() -> list[str]:
+    table = Table(border_style="dim", padding=(0, 1))
+    table.add_column("#", style="dim", width=3)
+    table.add_column("Provider", style="cyan")
+    table.add_column("Type", style="dim")
+    table.add_column("Cost", style="dim")
+    table.add_column("Status")
+
+    provider_ids = list(PROVIDER_METADATA.keys())
+    for i, pid in enumerate(provider_ids, 1):
+        meta = PROVIDER_METADATA[pid]
+        cost = "[green]free[/green]" if meta.get("free") else "[dim]paid[/dim]"
+        status = "[green]✓ configured[/green]" if has_key(pid) else "[dim]not set[/dim]"
+        ptype = "local" if not meta.get("requires_key") else "cloud"
+        table.add_row(str(i), meta["label"], ptype, cost, status)
+
+    console.print(table)
+    console.print()
+
+    raw = Prompt.ask(
+        "Select providers to configure [dim](comma-separated numbers, e.g. 1,2,3)[/dim]",
+        default="1",
+    )
+
+    selected: list[str] = []
+    for part in raw.split(","):
+        part = part.strip()
+        if part.isdigit():
+            idx = int(part) - 1
+            if 0 <= idx < len(provider_ids):
+                selected.append(provider_ids[idx])
+    return selected
+
+
+def _mask_key(key: str | None) -> str:
+    if not key:
+        return "***"
+    if len(key) <= 12:
+        return "*" * len(key)
+    return key[:8] + "..." + key[-4:]
+
+
+def setup_command() -> None:
+    """Configure AI provider API keys."""
+    run_setup_wizard()