velune-cli 1.0.0__py3-none-any.whl

velune/cli/commands/run.py

@@ -0,0 +1,171 @@
+"""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"),
+) -> 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")
+
+    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")
+
+    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 _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,182 @@
+"""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]",
+        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()

velune/cli/commands/workspace.py

@@ -0,0 +1,217 @@
+"""Workspace commands — velune workspace init/status."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.box import ROUNDED
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+from velune.cli.context import CLIContext
+
+console = Console()
+workspace_cmd = typer.Typer(help="Workspace management commands")
+
+
+@workspace_cmd.command("init")
+def workspace_init(
+    ctx: typer.Context,
+    path: Path = typer.Argument(Path.cwd(), help="Workspace path"),
+    force: bool = typer.Option(False, "--force", "-f", help="Force reinitialization and re-index"),
+) -> None:
+    """Initialize a Velune workspace and build initial Tree-sitter AST parser indices."""
+    cli_context = ctx.obj
+    if not isinstance(cli_context, CLIContext):
+        raise typer.BadParameter("CLI context was not properly initialized")
+
+    if not cli_context.json_mode:
+        console.print(f"[bold cyan]Initializing Velune Cognitive Workspace at:[/bold cyan] {path}")
+
+    # 1. Create .velune directory structure
+    velune_dir = path / ".velune"
+    velune_dir.mkdir(exist_ok=True)
+    (velune_dir / "memory").mkdir(exist_ok=True)
+    (velune_dir / "retrieval").mkdir(exist_ok=True)
+    (velune_dir / "index").mkdir(exist_ok=True)
+    (velune_dir / "snapshots").mkdir(exist_ok=True)
+
+    if not cli_context.json_mode:
+        console.print("[green]✓[/green] Created .velune configuration directory structure.")
+
+    # 2. Write default .veluneignore if one doesn't already exist
+    veluneignore_path = path / ".veluneignore"
+    if not veluneignore_path.exists():
+        from velune.repository.scanner import DEFAULT_VELUNEIGNORE
+        veluneignore_path.write_text(DEFAULT_VELUNEIGNORE, encoding="utf-8")
+        if not cli_context.json_mode:
+            console.print("[green]✓[/green] Created default .veluneignore (edit to customise index exclusions).")
+
+    from velune.core.event_loop import submit
+    submit(_workspace_init_async(cli_context, path, velune_dir, force))
+
+
+async def _workspace_init_async(
+    cli_context: CLIContext,
+    path: Path,
+    velune_dir: Path,
+    force: bool,
+) -> None:
+    container = cli_context.container
+    lifecycle = container.get("runtime.lifecycle")
+    repo_cognition = container.get("runtime.repository_cognition")
+
+    # 3. Boot subsystems and compile index
+    await lifecycle.startup()
+
+    if not cli_context.json_mode:
+        console.print("[bold cyan]⠋[/bold cyan] Building Tree-sitter compiler AST indices and scanning imports...")
+        with console.status("[bold magenta]⚡ Parsing symbols, dependencies, and git Authorship...[/bold magenta]"):
+            snapshot = repo_cognition.index(force=force)
+    else:
+        snapshot = repo_cognition.index(force=force)
+
+    # Calculate statistics
+    num_files = len(snapshot.files)
+    num_symbols = len(snapshot.symbols)
+    num_edges = len(snapshot.edges)
+    skipped_secrets = snapshot.summary.get("skipped_secrets", [])
+
+    languages = {}
+    for f in snapshot.files:
+        languages[f.language.value] = languages.get(f.language.value, 0) + 1
+
+    lang_summary = ", ".join(f"{count} {lang}" for lang, count in languages.items())
+    git_branch = snapshot.summary.get("git", {}).get("active_branch", "untracked")
+
+    # 4. Render gorgeous Success Summary Panel
+    if cli_context.json_mode:
+        import json
+        print(json.dumps({
+            "success": True,
+            "workspace_path": str(path),
+            "caches_directory": str(velune_dir),
+            "indexed_files": num_files,
+            "languages": languages,
+            "parsed_ast_symbols": num_symbols,
+            "dependency_edges": num_edges,
+            "active_branch": git_branch,
+            "skipped_secrets": skipped_secrets,
+        }))
+    else:
+        console.print()
+        console.print(
+            Panel(
+                Text.assemble(
+                    ("[bold green]✓ VELUNE WORKSPACE SUCCESSFULLY INDEXED[/bold green]\n\n"),
+                    (f"[bold]Workspace path:[/bold] {path}\n"),
+                    (f"[bold]Caches directory:[/bold] {velune_dir}\n"),
+                    (f"[bold]Indexed files:[/bold] {num_files} ({lang_summary or 'no code files found'})\n"),
+                    (f"[bold]Parsed AST symbols:[/bold] {num_symbols} classes/functions/imports\n"),
+                    (f"[bold]Dependency edges:[/bold] {num_edges} import link(s)\n"),
+                    (f"[bold]Active branch:[/bold] [magenta]{git_branch}[/magenta]\n\n"),
+                    ("[dim]Velune repository cognitive engine is primed. Use 'velune run' to start autonomous edits.[/dim]")
+                ),
+                border_style="green",
+                box=ROUNDED,
+                title="[bold green]Cognitive Priming Success[/bold green]"
+            )
+        )
+
+        if skipped_secrets:
+            secret_lines = "\n".join(f"  [bold yellow]•[/bold yellow] {p}" for p in skipped_secrets)
+            console.print(
+                Panel(
+                    Text.from_markup(
+                        "[bold yellow]Velune detected and protected the following files from being indexed:[/bold yellow]\n\n"
+                        + secret_lines
+                        + "\n\n[dim]These files matched known secrets/credentials patterns. "
+                        "Add them to [bold].veluneignore[/bold] to silence this notice, "
+                        "or ensure they are listed in [bold].gitignore[/bold].[/dim]"
+                    ),
+                    title="[bold yellow]🔒 Secrets Protected[/bold yellow]",
+                    border_style="yellow",
+                    box=ROUNDED,
+                    padding=(1, 2),
+                )
+            )
+
+    await lifecycle.shutdown()
+
+
+@workspace_cmd.command("status")
+def workspace_status(
+    ctx: typer.Context,
+    path: Path = typer.Option(Path.cwd(), "--path", "-p", help="Workspace path"),
+) -> None:
+    """Show active workspace structure and index summary."""
+    velune_dir = path / ".velune"
+
+    cli_context = ctx.obj
+    if not isinstance(cli_context, CLIContext):
+        raise typer.BadParameter("CLI context was not properly initialized")
+
+    if not velune_dir.exists():
+        if cli_context.json_mode:
+            import json
+            print(json.dumps({"error": "Not a Velune workspace (no .velune directory detected)"}))
+        else:
+            console.print("[bold red]✗ Not a Velune workspace (no .velune directory detected).[/bold red]")
+            console.print("[dim]Use 'velune workspace init' to initialize.[/dim]")
+        return
+
+    from velune.core.event_loop import submit
+    submit(_workspace_status_async(cli_context, path, velune_dir))
+
+
+async def _workspace_status_async(
+    cli_context: CLIContext,
+    path: Path,
+    velune_dir: Path,
+) -> None:
+    container = cli_context.container
+    lifecycle = container.get("runtime.lifecycle")
+    repo_cognition = container.get("runtime.repository_cognition")
+
+    await lifecycle.startup()
+
+    if not cli_context.json_mode:
+        with console.status("[bold cyan]Querying cognitive index status...[/bold cyan]"):
+            snapshot = repo_cognition.index(force=False)
+    else:
+        snapshot = repo_cognition.index(force=False)
+
+    num_files = len(snapshot.files)
+    num_symbols = len(snapshot.symbols)
+    git_branch = snapshot.summary.get("git", {}).get("active_branch", "untracked")
+
+    if cli_context.json_mode:
+        import json
+        print(json.dumps({
+            "workspace_root": str(path),
+            "velune_cache": str(velune_dir),
+            "indexed_files_count": num_files,
+            "indexed_symbols_count": num_symbols,
+            "git_branch": git_branch,
+            "status": "Active & Fully Primed"
+        }))
+    else:
+        console.print(
+            Panel(
+                Text.assemble(
+                    (f"[bold]Workspace root:[/bold] {path}\n"),
+                    (f"[bold]Velune cache:[/bold] {velune_dir}\n"),
+                    (f"[bold]Indexed files count:[/bold] {num_files}\n"),
+                    (f"[bold]Indexed symbols count:[/bold] {num_symbols}\n"),
+                    (f"[bold]Git branch:[/bold] [magenta]{git_branch}[/magenta]\n"),
+                    ("[bold]Status:[/bold] [bold green]Active & Fully Primed[/bold green]")
+                ),
+                border_style="cyan",
+                box=ROUNDED,
+                title="[bold cyan]Workspace Status[/bold cyan]"
+            )
+        )
+
+    await lifecycle.shutdown()

velune/cli/context.py

@@ -0,0 +1,37 @@
+"""CLI runtime context passed through Typer commands."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+from rich.console import Console
+
+from velune.core.runtime import RuntimeContext
+from velune.kernel.config import VeluneConfig
+from velune.kernel.registry import ServiceContainer
+
+
+@dataclass(slots=True)
+class CLIContext:
+    """Shared CLI state for the current process."""
+
+    workspace: Path
+    config_path: Path | None
+    verbose: bool
+    runtime: RuntimeContext
+    json_mode: bool = False
+    yes: bool = False
+
+    @property
+    def console(self) -> Console:
+        return self.runtime.console
+
+    @property
+    def config(self) -> VeluneConfig:
+        return self.runtime.config
+
+    @property
+    def container(self) -> ServiceContainer:
+        return self.runtime.container
+