velune-cli 1.0.0__py3-none-any.whl

velune/cli/councilmodel_ui.py

@@ -0,0 +1,171 @@
+"""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 ────────────────────────────────────────
+    selected_role_idx = [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 "  "
+            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:
+        selected_role_idx[0] = (selected_role_idx[0] - 1) % len(COUNCIL_ROLES)
+
+    @kb1.add("down")
+    def _down(event) -> None:
+        selected_role_idx[0] = (selected_role_idx[0] + 1) % len(COUNCIL_ROLES)
+
+    @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

velune/cli/display/council_view.py

@@ -0,0 +1,240 @@
+"""Rich terminal visualization of the Reasoning Council debate, scoring, and votes."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.box import ROUNDED
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from velune.cognition.council.planner import TaskPlan
+from velune.models.specializations import CouncilRole
+
+
+class CouncilDisplayView:
+    """Beautiful Rich-based UI components to visualize Reasoning Council deliberations."""
+
+    def __init__(self, console: Console) -> None:
+        self.console = console
+
+    def render_header(self, task: str) -> None:
+        """Display an eye-catching header for the council run."""
+        self.console.print()
+        self.console.print(
+            Panel(
+                Text.assemble(
+                    ("[bold magenta]VELUNE COGNITIVE OS[/bold magenta] — [cyan]Reasoning Council Active[/cyan]\n"),
+                    ("[dim]Objective:[/dim] ", "[italic white]" + task + "[/italic white]")
+                ),
+                border_style="magenta",
+                box=ROUNDED,
+                title="[bold white]🧠 Cognitive Deliberation[/bold white]",
+                title_align="left"
+            )
+        )
+
+    def render_role_assignments(self, assignments: dict[CouncilRole, Any]) -> None:
+        """Render a table displaying mapped specialized models for the council."""
+        table = Table(
+            title="[bold cyan]Mapped Council Specializations[/bold cyan]",
+            box=ROUNDED,
+            border_style="dim",
+            expand=True
+        )
+        table.add_column("Council Seat", style="bold yellow")
+        table.add_column("Provider / Endpoint", style="green")
+        table.add_column("Target Model", style="cyan")
+        table.add_column("Key Skills / Tags", style="magenta")
+
+        for role, desc in assignments.items():
+            caps = []
+            if hasattr(desc, "capabilities") and desc.capabilities:
+                for cap_name in ["coding", "reasoning", "planning", "summarization", "tool_use"]:
+                    level = getattr(desc.capabilities, cap_name, None)
+                    if level and level > 0:
+                        caps.append(f"{cap_name} ({level.name})")
+            tags = ", ".join(caps) if caps else ", ".join(desc.tags) if getattr(desc, "tags", None) else "reasoning"
+            table.add_row(
+                role.value.upper(),
+                desc.provider_id.capitalize(),
+                desc.model_id,
+                tags
+            )
+        self.console.print(table)
+        self.console.print()
+
+    def render_step_header(self, step_name: str, agent_emoji: str = "🤖") -> None:
+        """Draw an elegant boundary indicating a change in agent active deliberation."""
+        self.console.print(f"\n[bold magenta]●[/bold magenta] [bold white]{agent_emoji} {step_name}[/bold white] is deliberating...")
+
+    def render_planner_dag(self, plan: TaskPlan) -> None:
+        """Render the Planner's task plan DAG as a neat hierarchical or sequential table."""
+        table = Table(
+            title="[bold yellow]Execution Plan Compiled by Council Planner[/bold yellow]",
+            box=ROUNDED,
+            border_style="yellow",
+            expand=True
+        )
+        table.add_column("ID", style="bold cyan", width=8)
+        table.add_column("Description", style="white")
+        table.add_column("Dependencies", style="magenta")
+        table.add_column("Validation Strategy", style="green")
+
+        for step in plan.steps:
+            deps = ", ".join(step.dependencies) if step.dependencies else "[dim]None[/dim]"
+            val = step.metadata.get("test_command") or "Syntax check + File existence"
+            table.add_row(
+                step.id,
+                step.description,
+                deps,
+                str(val)
+            )
+        self.console.print(table)
+        self.console.print()
+
+    def render_code_proposal(self, code_proposal: str) -> None:
+        """Format the coder's proposed implementation code inside a syntax-focused block."""
+        self.console.print(
+            Panel(
+                Text(code_proposal, style="green"),
+                title="[bold green]💻 Coder Proposed Patch[/bold green]",
+                border_style="green",
+                box=ROUNDED,
+                expand=True
+            )
+        )
+
+    def render_reviewer_report(self, report: Any) -> None:
+        """Render the Reviewer's static audit, showing passed status and critical issues."""
+        if isinstance(report, dict):
+            passed = report.get("passed", True)
+            confidence = report.get("confidence_rating", 0.8)
+            issues = report.get("critical_issues", [])
+        else:
+            passed = report.passed
+            confidence = report.confidence_rating
+            issues = report.critical_issues
+
+        status_text = "[bold green]PASS[/bold green]" if passed else "[bold red]FAIL / BLOCKED[/bold red]"
+        border_style = "green" if passed else "red"
+
+        content = []
+        content.append(f"[bold]Verification Status:[/bold] {status_text}")
+        content.append(f"[bold]Confidence Rating:[/bold] {confidence:.2f}")
+
+        if issues:
+            content.append("\n[bold red]⚠️ Critical Issues Detected:[/bold red]")
+            for issue in issues:
+                content.append(f"  [red]•[/red] {issue}")
+        else:
+            content.append("\n[green]✓ Static static checks passed. No syntactical or safety concerns raised.[/green]")
+
+        self.console.print(
+            Panel(
+                "\n".join(content),
+                title="[bold]🔍 Reviewer Audit[/bold]",
+                border_style=border_style,
+                box=ROUNDED,
+                expand=True
+            )
+        )
+
+    def render_challenger_report(self, report: Any) -> None:
+        """Render the Challenger's adversarial audit and failure vector probes."""
+        if isinstance(report, dict):
+            severity = report.get("severity_rating", 0.0)
+            vectors = report.get("failure_vectors", [])
+        else:
+            severity = report.severity_rating
+            vectors = report.failure_vectors
+
+        border_style = "yellow" if severity > 0.4 else "dim"
+
+        content = []
+        content.append(f"[bold]Adversarial Severity Rating:[/bold] [bold red]{severity:.2f}[/bold red] / 1.00")
+
+        if vectors:
+            content.append("\n[bold yellow]⚡ Failure Vectors Simulated:[/bold yellow]")
+            for vec in vectors:
+                content.append(f"  [yellow]•[/yellow] {vec}")
+        else:
+            content.append("\n[dim]No significant failure vectors or edge-case gaps simulated.[/dim]")
+
+        self.console.print(
+            Panel(
+                "\n".join(content),
+                title="[bold]⚡ Challenger Adversarial Check[/bold]",
+                border_style=border_style,
+                box=ROUNDED,
+                expand=True
+            )
+        )
+
+    def render_arbitration_result(self, res: Any) -> None:
+        """Display calibrated confidence score, contradiction matches, and human-review flags."""
+        if isinstance(res, dict):
+            confidence = res.get("overall_confidence", 0.8)
+            review_required = res.get("requires_human_review", False)
+            flags = res.get("flags", [])
+            winning_claims = res.get("winning_claims", [])
+            synthesis_inst = res.get("synthesis_instructions", "")
+        else:
+            confidence = res.overall_confidence
+            review_required = res.requires_human_review
+            flags = res.flags
+            winning_claims = res.winning_claims
+            synthesis_inst = res.synthesis_instructions
+
+        # Color calibrated confidence based on score
+        if confidence > 0.75:
+            conf_str = f"[bold green]{confidence * 100:.1f}% (High Confidence)[/bold green]"
+            border_style = "green"
+        elif confidence > 0.55:
+            conf_str = f"[bold yellow]{confidence * 100:.1f}% (Medium Confidence)[/bold yellow]"
+            border_style = "yellow"
+        else:
+            conf_str = f"[bold red]{confidence * 100:.1f}% (Low Confidence / High Volatility)[/bold red]"
+            border_style = "red"
+
+        status_text = "[bold red]YES (Blocked / Escalate)[/bold red]" if review_required else "[bold green]NO (Autonomous Pass)[/bold green]"
+
+        content = []
+        content.append(f"[bold]Calibrated Council Confidence Score:[/bold] {conf_str}")
+        content.append(f"[bold]Escalate to Human-in-the-Loop Review:[/bold] {status_text}")
+
+        if flags:
+            content.append(f"[bold red]System Flags Raised:[/bold red] {', '.join(flags)}")
+
+        if winning_claims:
+            content.append("\n[bold cyan]Winning Claims & Arbitration Compromise:[/bold cyan]")
+            for claim in winning_claims:
+                content.append(f"  [cyan]✓[/cyan] {claim}")
+
+        if synthesis_inst:
+            content.append("\n[bold dim]Arbitrator Instructions for Synthesizer:[/bold dim]")
+            content.append(f"[dim]{synthesis_inst}[/dim]")
+
+        self.console.print(
+            Panel(
+                "\n".join(content),
+                title="[bold white]⚖️ Council Arbitration Engine[/bold white]",
+                border_style=border_style,
+                box=ROUNDED,
+                expand=True
+            )
+        )
+
+    def render_synthesized_response(self, text: str) -> None:
+        """Display final walker walkthrough summary and accomplishments."""
+        self.console.print(
+            Panel(
+                Text(text, style="white"),
+                title="[bold magenta]🚀 Deliberated Walkthrough & Accomplishments[/bold magenta]",
+                border_style="magenta",
+                box=ROUNDED,
+                expand=True
+            )
+        )

velune/cli/display/memory_view.py

@@ -0,0 +1,93 @@
+"""Rich terminal rendering of hierarchical memory tiers, priority decays, and graph entities."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.box import ROUNDED
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+from rich.tree import Tree
+
+
+class MemoryDisplayView:
+    """Beautiful Rich-based UI components to visualize Velune's 5-tier Hierarchical Memory system."""
+
+    def __init__(self, console: Console) -> None:
+        self.console = console
+
+    def render_memory_architecture(self, stats: dict[str, Any]) -> None:
+        """Render a magnificent visual map of the memory tiers and active index statistics."""
+        self.console.print(
+            Panel(
+                Text.assemble(
+                    ("[bold magenta]VELUNE CORE HIERARCHICAL MEMORY MAP[/bold magenta]\n"),
+                    ("[dim]Active Workspace:[/dim] [italic cyan]" + str(stats.get("workspace", "current")) + "[/italic cyan]\n\n"),
+                    ("[bold yellow]Tier 1: Working Memory[/bold yellow]  ──► In-memory state, fast lookups (TTL: " + str(stats.get("working_memory_ttl", 3600)) + "s)\n"),
+                    ("[bold green]Tier 2: Episodic SQLite[/bold green] ──► Task runs, step histories (Retention: " + str(stats.get("episodic_retention_days", 30)) + " days)\n"),
+                    ("[bold blue]Tier 3: Semantic Qdrant[/bold blue]  ──► Vector code snippet indices (Similarity Threshold: " + str(stats.get("semantic_threshold", 0.85)) + ")\n"),
+                    ("[bold cyan]Tier 4: Graphiti Graph[/bold cyan]   ──► Entity relationships & AST Dependency Graph (Graphiti Enabled: " + str(stats.get("graph_enabled", True)) + ")\n"),
+                    ("[bold red]Tier 5: Archive Storage[/bold red]  ──► Long-term zstd-compressed cold files")
+                ),
+                title="[bold white]🧠 Memory Architecture Map[/bold white]",
+                border_style="magenta",
+                box=ROUNDED,
+                title_align="left"
+            )
+        )
+
+    def render_memory_records_table(self, records: list[dict[str, Any]], memory_type: str) -> None:
+        """Render a structured table showing registered records across specific memory tiers."""
+        table = Table(
+            title=f"[bold green]Registered Memory Records ({memory_type.capitalize()})[/bold green]",
+            box=ROUNDED,
+            border_style="green",
+            expand=True
+        )
+        table.add_column("Record ID / Key", style="bold cyan", width=25)
+        table.add_column("Memory Tier", style="magenta")
+        table.add_column("Importance Score", style="yellow")
+        table.add_column("Content Preview", style="white")
+        table.add_column("Age (s) / Status", style="blue")
+
+        for rec in records:
+            importance = rec.get("importance", 1.0)
+            importance_bar = "★" * int(importance * 5)
+            table.add_row(
+                rec.get("id", "N/A"),
+                rec.get("tier", memory_type),
+                f"{importance:.2f} ({importance_bar})",
+                rec.get("content_preview", ""),
+                rec.get("status", "Active")
+            )
+        self.console.print(table)
+        self.console.print()
+
+    def render_knowledge_graph(self, entities: list[dict[str, Any]], relations: list[dict[str, Any]]) -> None:
+        """Render a beautiful hierarchical tree of knowledge graph entities and their relational links."""
+        root = Tree("[bold cyan]🌐 Graphiti Knowledge Graph Root[/bold cyan]")
+
+        # Index entities by type for rendering
+        by_type: dict[str, list[dict[str, Any]]] = {}
+        for ent in entities:
+            etype = ent.get("type", "entity").upper()
+            if etype not in by_type:
+                by_type[etype] = []
+            by_type[etype].append(ent)
+
+        for etype, items in by_type.items():
+            type_node = root.add(f"[bold yellow]🏷️ {etype}[/bold yellow]")
+            for item in items:
+                name = item.get("name", item.get("id", "Unknown"))
+                importance = item.get("importance", 1.0)
+                item_node = type_node.add(f"[cyan]{name}[/cyan] [dim](imp: {importance:.2f})[/dim]")
+
+                # Find relations where this item is the source
+                for rel in relations:
+                    if rel.get("source") == item.get("id"):
+                        item_node.add(f"──[magenta]{rel.get('relation', 'connected')}[/magenta]──► [white]{rel.get('target')}[/white]")
+
+        self.console.print(Panel(root, title="[bold white]Knowledge Graph Visualization[/bold white]", border_style="cyan", box=ROUNDED))
+        self.console.print()

velune/cli/display/panels.py

@@ -0,0 +1,35 @@
+"""Rich-based terminal panels."""
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+
+class DisplayPanels:
+    """Utility class for creating rich display panels."""
+
+    def __init__(self, console: Console):
+        self.console = console
+
+    def info_panel(self, title: str, content: str) -> None:
+        """Display an info panel."""
+        self.console.print(Panel(content, title=title, border_style="blue"))
+
+    def success_panel(self, title: str, content: str) -> None:
+        """Display a success panel."""
+        self.console.print(Panel(content, title=title, border_style="green"))
+
+    def warning_panel(self, title: str, content: str) -> None:
+        """Display a warning panel."""
+        self.console.print(Panel(content, title=title, border_style="yellow"))
+
+    def error_panel(self, title: str, content: str) -> None:
+        """Display an error panel."""
+        self.console.print(Panel(content, title=title, border_style="red"))
+
+    def create_table(self, title: str, columns: list[str]) -> Table:
+        """Create a rich table."""
+        table = Table(title=title)
+        for column in columns:
+            table.add_column(column)
+        return table

velune/cli/display/progress.py

@@ -0,0 +1,25 @@
+"""Rich-based progress display."""
+
+from rich.console import Console
+from rich.progress import BarColumn, Progress, SpinnerColumn, TaskProgressColumn, TextColumn
+
+
+class ProgressDisplay:
+    """Utility class for displaying progress."""
+
+    def __init__(self, console: Console):
+        self.console = console
+
+    def create_progress(self) -> Progress:
+        """Create a rich progress bar."""
+        return Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TaskProgressColumn(),
+            console=self.console,
+        )
+
+    def spinner(self, description: str):
+        """Create a spinner context manager."""
+        return self.console.status(description)

velune/cli/display/themes.py

@@ -0,0 +1,21 @@
+"""Rich terminal themes."""
+
+from rich.theme import Theme
+
+
+class VeluneTheme:
+    """Velune CLI theme."""
+
+    @staticmethod
+    def get_theme() -> Theme:
+        """Get the Velune theme."""
+        return Theme({
+            "info": "cyan",
+            "warning": "yellow",
+            "error": "red",
+            "success": "green",
+            "title": "bold blue",
+            "subtitle": "bold cyan",
+            "key": "magenta",
+            "value": "green",
+        })

velune/cli/main.py

@@ -0,0 +1,15 @@
+"""Backward-compatible CLI entry point."""
+
+import sys
+
+if sys.platform == "win32":
+    try:
+        sys.stdout.reconfigure(encoding="utf-8")
+        sys.stderr.reconfigure(encoding="utf-8")
+    except Exception:
+        pass
+
+from velune.cli.app import app
+
+if __name__ == "__main__":
+    app()

velune/cli/model_selector.py

@@ -0,0 +1,44 @@
+from velune.cli.modes import ModeConfig
+from velune.core.types.model import ModelDescriptor
+
+
+class ModeAwareModelSelector:
+    def __init__(self, model_registry, provider_registry) -> None:
+        self.model_registry = model_registry
+        self.provider_registry = provider_registry
+
+    def select_for_mode(
+        self,
+        config: ModeConfig,
+        current_model: ModelDescriptor | None,
+    ) -> ModelDescriptor | None:
+        all_models = [
+            m for m in self.model_registry.list_all()
+            if self.provider_registry.get(m.provider_id) is not None
+        ]
+        if not all_models:
+            return current_model
+
+        if config.use_fastest_model:
+            # Smallest context window = fastest / lightest
+            # Prefer local 3B/7B over cloud in optimus
+            local = [m for m in all_models if m.is_local]
+            pool = local if local else all_models
+            return min(pool, key=lambda m: m.context_length)
+
+        if config.use_largest_model:
+            # Largest context + highest capability score
+            def capability_score(m: ModelDescriptor) -> int:
+                caps = m.capabilities
+                if not caps:
+                    return 0
+                return sum([
+                    getattr(caps, f, 0).value if hasattr(
+                        getattr(caps, f, None), "value"
+                    ) else 0
+                    for f in ["coding", "reasoning", "planning",
+                               "summarization", "instruction_following"]
+                ])
+            return max(all_models, key=capability_score)
+
+        return current_model