velune-cli 0.9.0__py3-none-any.whl

velune/cli/commands/workspace.py

@@ -0,0 +1,249 @@
+"""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:
+            from velune.cli.rendering.error_panel import render_error
+            from velune.core.errors.catalog import WorkspaceNotInitializedError
+
+            console.print(
+                render_error(
+                    WorkspaceNotInitializedError(
+                        cause_override=f"No .velune directory found in {path}."
+                    )
+                )
+            )
+        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,36 @@
+"""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

velune/cli/councilmodel_ui.py

@@ -0,0 +1,199 @@
+"""Interactive two-stage TUI for assigning models to council agent roles."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from prompt_toolkit.application import Application
+from prompt_toolkit.formatted_text import FormattedText
+from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.layout import Layout
+from prompt_toolkit.layout.containers import Window
+from prompt_toolkit.layout.controls import FormattedTextControl
+
+from velune.orchestration.role_assignments import (
+    COUNCIL_ROLES,
+    ROLE_DESCRIPTIONS,
+    CouncilRoleMap,
+)
+
+if TYPE_CHECKING:
+    from rich.console import Console
+
+    from velune.core.types.model import ModelDescriptor
+
+# Sentinel to distinguish "user pressed Escape" from "user selected clear"
+_CANCELLED = object()
+
+
+async def run_councilmodel_ui(
+    role_map: CouncilRoleMap,
+    available_models: list[ModelDescriptor],
+    console: Console,
+) -> CouncilRoleMap | None:
+    """Two-stage interactive UI: select a role, then select a model for it.
+
+    Returns the updated role_map, or None if cancelled at the role-select stage.
+    """
+
+    # ── Stage 1: Role selection ────────────────────────────────────────
+    disabled_roles = {"architect", "security", "challenger", "synthesizer"}
+    active_indices = [i for i, r in enumerate(COUNCIL_ROLES) if r not in disabled_roles]
+    selected_role_idx = [active_indices[0] if active_indices else 0]
+    role_result: list[str | None] = [None]
+
+    def render_role_list() -> FormattedText:
+        lines: list[tuple[str, str]] = []
+        lines.append(("bold", "  Assign model to council role\n"))
+        lines.append(("fg:ansibrightblack", "  ↑↓ navigate · Enter select · Esc cancel\n\n"))
+        for i, role in enumerate(COUNCIL_ROLES):
+            is_active = i == selected_role_idx[0]
+            prefix = "❯ " if is_active else "  "
+
+            if role in disabled_roles:
+                row_style = "fg:ansibrightblack"
+                tag = " [disabled]"
+                prefix = "  "
+                desc = ROLE_DESCRIPTIONS.get(role, "")
+                lines.append((row_style, f"  {prefix}{role:<14} {desc}{tag}\n"))
+            else:
+                row_style = "bold fg:cyan" if is_active else ""
+                desc = ROLE_DESCRIPTIONS.get(role, "")
+                lines.append((row_style, f"  {prefix}{role:<14} {desc}\n"))
+                current = role_map.get(role)
+                if current:
+                    lines.append(
+                        ("fg:ansibrightblack", f"               currently: {current.model_id}\n")
+                    )
+        return FormattedText(lines)
+
+    kb1 = KeyBindings()
+
+    @kb1.add("up")
+    def _up(event) -> None:
+        curr = selected_role_idx[0]
+        while True:
+            curr = (curr - 1) % len(COUNCIL_ROLES)
+            if curr in active_indices:
+                selected_role_idx[0] = curr
+                break
+
+    @kb1.add("down")
+    def _down(event) -> None:
+        curr = selected_role_idx[0]
+        while True:
+            curr = (curr + 1) % len(COUNCIL_ROLES)
+            if curr in active_indices:
+                selected_role_idx[0] = curr
+                break
+
+    @kb1.add("enter")
+    def _select_role(event) -> None:
+        role_result[0] = COUNCIL_ROLES[selected_role_idx[0]]
+        event.app.exit()
+
+    @kb1.add("escape")
+    @kb1.add("c-c")
+    def _cancel_role(event) -> None:
+        event.app.exit()  # role_result stays None
+
+    app1 = Application(
+        layout=Layout(
+            Window(
+                content=FormattedTextControl(render_role_list, focusable=True),
+            )
+        ),
+        key_bindings=kb1,
+        full_screen=False,
+        mouse_support=False,
+    )
+    await app1.run_async()
+
+    selected_role = role_result[0]
+    if selected_role is None:
+        return None  # cancelled at role stage
+
+    # ── Stage 2: Model selection for chosen role ───────────────────────
+    # First entry is None = "clear assignment"
+    model_options: list[ModelDescriptor | None] = [None] + list(available_models)
+    selected_model_idx = [0]
+    model_result: list[object] = [_CANCELLED]
+
+    def render_model_list() -> FormattedText:
+        lines: list[tuple[str, str]] = []
+        lines.append(("bold", f"  Select model for [{selected_role}]\n"))
+        lines.append(("fg:ansibrightblack", "  ↑↓ navigate · Enter select · Esc back\n\n"))
+
+        for i, model in enumerate(model_options):
+            is_active = i == selected_model_idx[0]
+            prefix = "❯ " if is_active else "  "
+            row_style = "bold fg:cyan" if is_active else ""
+
+            if model is None:
+                lines.append((row_style, f"  {prefix}(clear — use default routing)\n"))
+                continue
+
+            current = role_map.get(selected_role)
+            is_current = current is not None and current.model_id == model.model_id
+            current_marker = " ← current" if is_current else ""
+            local_cloud = "local" if model.is_local else "cloud"
+            cost = getattr(model, "cost_per_1k_tokens", None)
+            free_str = " free" if cost == 0.0 else ""
+            lines.append(
+                (
+                    row_style,
+                    f"  {prefix}{model.model_id:<42}"
+                    f" [{local_cloud}{free_str} · {model.speed_tier}]"
+                    f"{current_marker}\n",
+                )
+            )
+        return FormattedText(lines)
+
+    kb2 = KeyBindings()
+
+    @kb2.add("up")
+    def _up2(event) -> None:
+        selected_model_idx[0] = (selected_model_idx[0] - 1) % len(model_options)
+
+    @kb2.add("down")
+    def _down2(event) -> None:
+        selected_model_idx[0] = (selected_model_idx[0] + 1) % len(model_options)
+
+    @kb2.add("enter")
+    def _select_model(event) -> None:
+        model_result[0] = model_options[selected_model_idx[0]]
+        event.app.exit()
+
+    @kb2.add("escape")
+    @kb2.add("c-c")
+    def _cancel_model(event) -> None:
+        event.app.exit()  # model_result stays _CANCELLED
+
+    app2 = Application(
+        layout=Layout(
+            Window(
+                content=FormattedTextControl(render_model_list, focusable=True),
+            )
+        ),
+        key_bindings=kb2,
+        full_screen=False,
+        mouse_support=False,
+    )
+    await app2.run_async()
+
+    if model_result[0] is _CANCELLED:
+        return role_map  # user backed out — return map unchanged
+
+    chosen_model = model_result[0]
+    if chosen_model is None:
+        role_map.clear_role(selected_role)
+        console.print(f"[yellow]✓ Cleared assignment for [{selected_role}][/yellow]")
+    else:
+        role_map.assign(selected_role, chosen_model.model_id, chosen_model.provider_id)
+        console.print(
+            f"[green]✓ [{selected_role}][/green] → "
+            f"[cyan]{chosen_model.model_id}[/cyan] "
+            f"[dim]({chosen_model.provider_id})[/dim]"
+        )
+
+    return role_map