velune-cli 0.9.0__py3-none-any.whl

velune/cli/display/council_view.py

@@ -0,0 +1,254 @@
+"""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,126 @@
+"""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,25 @@
+"""Rich terminal themes."""
+
+from rich.theme import Theme
+
+
+class VeluneTheme:
+    """Velune CLI theme — modern, restrained color palette."""
+
+    @staticmethod
+    def get_theme() -> Theme:
+        """Get the Velune theme with sophisticated color choices."""
+        return Theme(
+            {
+                "info": "blue",  # Primary blue for info
+                "warning": "yellow",  # Warm yellow for warnings
+                "error": "red",  # Clear red for errors
+                "success": "green",  # Green for success
+                "title": "bold blue",  # Primary blue titles
+                "subtitle": "dim blue",  # Subtle secondary blue
+                "key": "dim white",  # Subtle key labels
+                "value": "white",  # Clear values
+                "muted": "dim",  # Background/muted text
+                "accent": "#d4af37",  # Warm gold accent
+            }
+        )

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,51 @@
+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

velune/cli/modes.py

@@ -0,0 +1,86 @@
+from dataclasses import dataclass
+from enum import Enum
+
+
+class SessionMode(Enum):
+    NORMAL = "normal"
+    OPTIMUS = "optimus"
+    GODLY = "godly"
+
+
+@dataclass
+class ModeConfig:
+    mode: SessionMode
+    council_tier: str  # "instant" | "minimal" | "standard" | "full" | "auto"
+    context_compression: bool  # compress context before each call
+    max_context_tokens: int  # hard cap on context sent per call
+    temperature: float
+    retrieval_depth: int  # how many memory + repo chunks to pull
+    use_fastest_model: bool  # optimus: pick smallest capable model
+    use_largest_model: bool  # godly: pick largest available model
+    disable_critics: bool  # optimus: skip critic agents
+    description: str
+    prompt_color: str  # Rich color for prompt badge
+
+
+MODE_CONFIGS: dict[SessionMode, ModeConfig] = {
+    SessionMode.NORMAL: ModeConfig(
+        mode=SessionMode.NORMAL,
+        council_tier="auto",
+        context_compression=False,
+        max_context_tokens=16384,
+        temperature=0.3,
+        retrieval_depth=8,
+        use_fastest_model=False,
+        use_largest_model=False,
+        disable_critics=False,
+        description="Balanced — auto-selects council tier per task",
+        prompt_color="cyan",
+    ),
+    SessionMode.OPTIMUS: ModeConfig(
+        mode=SessionMode.OPTIMUS,
+        council_tier="instant",
+        context_compression=True,
+        max_context_tokens=4096,
+        temperature=0.1,
+        retrieval_depth=3,
+        use_fastest_model=True,
+        use_largest_model=False,
+        disable_critics=True,
+        description="Speed mode — smallest model, compressed context, instant tier",
+        prompt_color="yellow",
+    ),
+    SessionMode.GODLY: ModeConfig(
+        mode=SessionMode.GODLY,
+        council_tier="full",
+        context_compression=False,
+        max_context_tokens=128000,
+        temperature=0.5,
+        retrieval_depth=20,
+        use_fastest_model=False,
+        use_largest_model=True,
+        disable_critics=False,
+        description="Maximum — largest model, full context, complete council",
+        prompt_color="magenta",
+    ),
+}
+
+
+class ModeManager:
+    def __init__(self) -> None:
+        self._active = SessionMode.NORMAL
+
+    @property
+    def current(self) -> SessionMode:
+        return self._active
+
+    @property
+    def config(self) -> ModeConfig:
+        return MODE_CONFIGS[self._active]
+
+    def set_mode(self, mode: SessionMode) -> ModeConfig:
+        self._active = mode
+        return self.config
+
+    def is_normal(self) -> bool:
+        return self._active == SessionMode.NORMAL