velune-cli 0.9.0__py3-none-any.whl

velune/cli/commands/init.py

@@ -0,0 +1,170 @@
+"""velune init — workspace initialisation command."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.panel import Panel
+from rich.table import Table
+
+app_init = typer.Typer()
+console = Console()
+
+
+@app_init.command("init")
+def init_command(
+    path: Path = typer.Argument(
+        default=None,
+        help="Path to project root (defaults to current directory)",
+    ),
+    provider: str = typer.Option(
+        None,
+        "--provider",
+        "-p",
+        help="Default provider: ollama | groq | openai | anthropic",
+    ),
+    skip_hardware: bool = typer.Option(
+        False,
+        "--skip-hardware-check",
+        help="Skip hardware detection",
+    ),
+) -> None:
+    """Initialize Velune in a project.
+
+    Creates .velune/ config, detects hardware, checks providers,
+    and prepares the workspace for first use.
+    """
+    workspace = (path or Path.cwd()).resolve()
+
+    console.print(
+        Panel(
+            f"[bold cyan]Velune Init[/bold cyan]\n[dim]Setting up workspace: {workspace}[/dim]",
+            border_style="cyan",
+            padding=(0, 1),
+        )
+    )
+
+    if not skip_hardware:
+        _run_hardware_check()
+
+    # .velune/ directory tree
+    velune_dir = workspace / ".velune"
+    velune_dir.mkdir(exist_ok=True)
+    (velune_dir / "sessions").mkdir(exist_ok=True)
+    (velune_dir / "index").mkdir(exist_ok=True)
+    console.print("[green]✓[/green] Created .velune/ directory")
+
+    # Project type detection
+    try:
+        import json as _json
+
+        from velune.repository.project_type import ProjectTypeDetector
+
+        _profile = ProjectTypeDetector().detect(workspace)
+        (velune_dir / "project_profile.json").write_text(
+            _json.dumps(
+                {
+                    "project_type": _profile.project_type.value,
+                    "display_name": _profile.display_name,
+                    "primary_language": _profile.primary_language,
+                    "detected_frameworks": _profile.detected_frameworks,
+                    "entry_points": _profile.entry_points,
+                    "test_directories": _profile.test_directories,
+                    "config_files": _profile.config_files,
+                },
+                indent=2,
+            )
+        )
+        console.print(
+            f"[green]✓[/green] Detected project type: [cyan]{_profile.display_name}[/cyan]"
+        )
+        if _profile.detected_frameworks:
+            console.print(f"  [dim]Frameworks: {', '.join(_profile.detected_frameworks)}[/dim]")
+    except Exception:
+        pass
+
+    # .veluneignore
+    ignore_file = workspace / ".veluneignore"
+    if not ignore_file.exists():
+        from velune.repository.scanner import DEFAULT_VELUNEIGNORE
+
+        ignore_file.write_text(DEFAULT_VELUNEIGNORE)
+        console.print("[green]✓[/green] Created .veluneignore")
+
+    # config.toml
+    config_path = velune_dir / "config.toml"
+    if not config_path.exists():
+        default_provider = provider or _suggest_provider()
+        config_content = f"""\
+[project]
+name = "{workspace.name}"
+workspace = "."
+
+[providers]
+default_provider = "{default_provider}"
+
+[council]
+default_tier = "auto"
+
+[memory]
+enabled = true
+"""
+        config_path.write_text(config_content)
+        console.print(
+            f"[green]✓[/green] Created .velune/config.toml (provider: {default_provider})"
+        )
+
+    # .gitignore
+    gitignore = workspace / ".gitignore"
+    if gitignore.exists():
+        content = gitignore.read_text()
+        if ".velune/" not in content:
+            with open(gitignore, "a") as f:
+                f.write("\n# Velune\n.velune/\n")
+            console.print("[green]✓[/green] Added .velune/ to .gitignore")
+
+    console.print()
+    console.print("[bold green]✓ Velune initialized.[/bold green]")
+    console.print("[dim]Next steps:[/dim]")
+    console.print("  [cyan]velune[/cyan]          — start the REPL")
+    console.print("  [cyan]velune doctor[/cyan]   — verify configuration")
+
+
+def _run_hardware_check() -> None:
+    from velune.hardware.detector import HardwareDetector
+
+    profile = HardwareDetector().detect()
+
+    table = Table(border_style="dim", padding=(0, 1), show_header=False)
+    table.add_column("Key", style="dim", width=20)
+    table.add_column("Value", style="white")
+
+    table.add_row("RAM", f"{profile.total_ram_gb:.0f} GB")
+    table.add_row("GPU", profile.gpu_name or "None (CPU only)")
+    table.add_row(
+        "VRAM",
+        f"{profile.vram_total_gb:.0f} GB" if profile.vram_total_gb else "—",
+    )
+    table.add_row("Tier", f"[cyan]{profile.tier.value}[/cyan]")
+    table.add_row("Best local model", profile.recommended_model_size)
+
+    console.print(table)
+
+    for w in profile.warnings:
+        console.print(f"  [yellow]⚠[/yellow] {w}")
+    for s in profile.suggestions:
+        console.print(f"  [dim]→ {s}[/dim]")
+
+
+def _suggest_provider() -> str:
+    try:
+        import httpx
+
+        r = httpx.get("http://localhost:11434/api/tags", timeout=2)
+        if r.status_code == 200:
+            return "ollama"
+    except Exception:
+        pass
+    return "groq"

velune/cli/commands/mcp.py

@@ -0,0 +1,82 @@
+"""MCP command - velune mcp-serve and velune mcp connect."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from velune.cli.context import CLIContext
+from velune.core.event_loop import submit
+from velune.core.runtime import build_runtime
+from velune.mcp.client import VeluneMCPClient
+from velune.mcp.server import VeluneMCPServer
+
+console = Console()
+mcp_cmd = typer.Typer(help="Model Context Protocol (MCP) commands")
+
+
+@mcp_cmd.command("connect")
+def mcp_connect(
+    ctx: typer.Context,
+    server_url: str = typer.Argument(..., help="SSE URL of the external MCP server"),
+    name: str = typer.Argument(..., help="Name of the MCP server"),
+) -> None:
+    """Connect to an external MCP server and list its tools."""
+    console.print(f"[cyan]Connecting to external MCP server '{name}' at {server_url}...[/cyan]")
+
+    client = VeluneMCPClient(server_url, name)
+
+    async def _connect_and_list():
+        try:
+            tools = await client.connect()
+            console.print(f"[green]✓ Connected to {name} successfully![/green]")
+            console.print(f"[bold]Exposed Tools ({len(tools)}):[/bold]")
+            for tool in tools:
+                desc = tool.get("description", "No description")
+                if len(desc) > 80:
+                    desc = desc[:77] + "..."
+                console.print(f"  - [cyan]{name}_{tool['name']}[/cyan]: {desc}")
+        except Exception as e:
+            console.print(f"[red]Error connecting to MCP server: {e}[/red]")
+            raise typer.Exit(1)
+        finally:
+            await client.disconnect()
+
+    submit(_connect_and_list())
+
+
+@mcp_cmd.command("serve")
+def mcp_serve_subcmd(ctx: typer.Context) -> None:
+    """Start Velune as an MCP server for Claude Desktop / VS Code."""
+    cli_context = ctx.obj if isinstance(ctx.obj, CLIContext) else None
+    workspace = cli_context.workspace if cli_context else Path.cwd()
+    config_path = cli_context.config_path if cli_context else None
+
+    container = build_runtime(workspace, config_path=config_path).container
+    tool_registry = container.get("runtime.tool_registry")
+    server = VeluneMCPServer(tool_registry)
+
+    import logging
+
+    logging.getLogger("velune").setLevel(logging.WARNING)
+
+    submit(server.run_stdio())
+
+
+def mcp_serve(ctx: typer.Context) -> None:
+    """Start Velune as an MCP server for Claude Desktop / VS Code."""
+    cli_context = ctx.obj if isinstance(ctx.obj, CLIContext) else None
+    workspace = cli_context.workspace if cli_context else Path.cwd()
+    config_path = cli_context.config_path if cli_context else None
+
+    container = build_runtime(workspace, config_path=config_path).container
+    tool_registry = container.get("runtime.tool_registry")
+    server = VeluneMCPServer(tool_registry)
+
+    import logging
+
+    logging.getLogger("velune").setLevel(logging.WARNING)
+
+    submit(server.run_stdio())

velune/cli/commands/memory.py

@@ -0,0 +1,293 @@
+"""Memory commands — velune memory inspect/stats/clear/compact.
+
+Phase 1 Honesty Refactor
+------------------------
+All three commands previously returned hardcoded fake data or performed
+no actual work.  They now:
+
+* ``inspect``  — reads real records from the episodic SQLite tier.
+  Falls back gracefully to an empty result set on cold start (no DB yet).
+
+* ``clear``    — actually calls ``delete_session()`` (episodic) or
+  ``clear()`` (working) to remove data.  No longer a no-op.
+
+* ``compact``  — emits an honest "not yet implemented" notice instead of
+  printing fabricated distillation counters.  The command still succeeds
+  so callers can script against it safely.
+"""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from velune.cli.context import CLIContext
+from velune.cli.display.memory_view import MemoryDisplayView
+
+console = Console()
+memory_cmd = typer.Typer(help="Memory management commands")
+
+
+@memory_cmd.command("stats")
+def memory_stats(ctx: typer.Context) -> None:
+    """Show visual memory map and registered policy statistics."""
+    cli_context = ctx.obj
+    if not isinstance(cli_context, CLIContext):
+        raise typer.BadParameter("CLI context was not properly initialized")
+
+    config = cli_context.config
+
+    # Compile memory statistics block
+    stats = {
+        "workspace": str(cli_context.workspace),
+        "working_memory_ttl": config.memory.working_memory_ttl,
+        "episodic_retention_days": config.memory.episodic_retention_days,
+        "semantic_threshold": config.memory.semantic_threshold,
+        "graph_enabled": config.memory.graph_enabled,
+    }
+
+    if cli_context.json_mode:
+        import json
+
+        print(json.dumps(stats))
+        return
+
+    display = MemoryDisplayView(console)
+    display.render_memory_architecture(stats)
+
+
+@memory_cmd.command("inspect")
+def memory_inspect(
+    ctx: typer.Context,
+    tier: str = typer.Option(
+        "all", "--tier", "-t", help="Memory tier to inspect (working, episodic, all)"
+    ),
+    limit: int = typer.Option(10, "--limit", "-l", help="Number of records to show"),
+    session_id: str = typer.Option(
+        "", "--session", "-s", help="Filter by session ID (empty = all)"
+    ),
+) -> None:
+    """Inspect stored records across different memory tiers.
+
+    Reads *real* data from the episodic SQLite database.  If no data has
+    been written yet (cold start), an empty table is shown rather than
+    fabricated placeholder records.
+    """
+    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(_memory_inspect_async(cli_context, tier, limit, session_id))
+
+
+async def _memory_inspect_async(
+    cli_context: CLIContext,
+    tier: str,
+    limit: int,
+    session_id: str,
+) -> None:
+    container = cli_context.container
+    lifecycle = container.get("runtime.lifecycle")
+
+    await lifecycle.startup()
+
+    records: list[dict] = []
+
+    # --- Working memory (always in-process) ---
+    if tier.lower() in ("working", "all"):
+        try:
+            working = container.get("runtime.working_memory")
+            if working:
+                for turn in working.get_recent_turns(limit=limit):
+                    if session_id and getattr(turn, "session_id", "") != session_id:
+                        continue
+                    records.append(
+                        {
+                            "id": f"wrk-{turn.timestamp:.0f}",
+                            "tier": "working",
+                            "importance": 0.0,  # working tier has no importance scores yet
+                            "content_preview": (turn.content[:120] + "…")
+                            if len(turn.content) > 120
+                            else turn.content,
+                            "status": turn.role,
+                        }
+                    )
+        except Exception as exc:
+            if not cli_context.json_mode:
+                console.print(f"[yellow]⚠ Could not read working memory: {exc}[/yellow]")
+
+    # --- Episodic memory (SQLite) ---
+    if tier.lower() in ("episodic", "all"):
+        try:
+            episodic = container.get("runtime.episodic_memory")
+            if episodic:
+                # If no session_id filter provided, scan recent turns from a
+                # heuristic default session so the table isn't always empty.
+                sid = session_id or "default"
+                turns = episodic.get_turns(sid)
+                for turn in turns[-limit:]:
+                    records.append(
+                        {
+                            "id": f"eps-{turn.id or turn.timestamp:.0f}",
+                            "tier": "episodic",
+                            "importance": 0.0,
+                            "content_preview": (turn.content[:120] + "…")
+                            if len(turn.content) > 120
+                            else turn.content,
+                            "status": turn.role,
+                        }
+                    )
+        except Exception as exc:
+            if not cli_context.json_mode:
+                console.print(f"[yellow]⚠ Could not read episodic memory: {exc}[/yellow]")
+
+    if cli_context.json_mode:
+        import json
+
+        print(json.dumps({"records": records[:limit]}))
+    else:
+        display = MemoryDisplayView(console)
+        if records:
+            display.render_memory_records_table(records[:limit], tier)
+        else:
+            console.print(
+                "[dim]No memory records found"
+                + (f" for session '{session_id}'" if session_id else "")
+                + ". Run a task first to populate episodic memory.[/dim]"
+            )
+
+    await lifecycle.shutdown()
+
+
+@memory_cmd.command("clear")
+def memory_clear(
+    ctx: typer.Context,
+    tier: str = typer.Argument(..., help="Memory tier to clear (working, episodic, all)"),
+    session_id: str = typer.Option("default", "--session", "-s", help="Session ID to clear"),
+    confirm: bool = typer.Option(False, "--confirm", "-y", help="Skip safety prompt"),
+) -> None:
+    """Clear memory records of a specific tier.
+
+    Actually removes data — no longer a no-op.
+    """
+    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 and not confirm:
+        typer.confirm(
+            f"Are you sure you want to purge '{tier}' memory tier"
+            + (f" for session '{session_id}'" if session_id else "")
+            + "?",
+            abort=True,
+        )
+
+    from velune.core.event_loop import submit
+
+    submit(_memory_clear_async(cli_context, tier, session_id))
+
+
+async def _memory_clear_async(cli_context: CLIContext, tier: str, session_id: str) -> None:
+    container = cli_context.container
+    lifecycle = container.get("runtime.lifecycle")
+    await lifecycle.startup()
+
+    cleared: list[str] = []
+    errors: list[str] = []
+
+    if tier.lower() in ("working", "all"):
+        try:
+            working = container.get("runtime.working_memory")
+            if working:
+                working.clear()
+                cleared.append("working")
+        except Exception as exc:
+            errors.append(f"working: {exc}")
+
+    if tier.lower() in ("episodic", "all"):
+        try:
+            episodic = container.get("runtime.episodic_memory")
+            if episodic and session_id:
+                episodic.delete_session(session_id)
+                cleared.append(f"episodic[session={session_id}]")
+        except Exception as exc:
+            errors.append(f"episodic: {exc}")
+
+    await lifecycle.shutdown()
+
+    if cli_context.json_mode:
+        import json
+
+        print(json.dumps({"success": not errors, "cleared": cleared, "errors": errors}))
+    else:
+        for c in cleared:
+            console.print(f"[green]✓ Cleared {c} memory.[/green]")
+        for e in errors:
+            console.print(f"[red]✗ Error clearing {e}[/red]")
+        if not cleared and not errors:
+            console.print("[dim]Nothing to clear.[/dim]")
+
+
+@memory_cmd.command("compact")
+def memory_compact(ctx: typer.Context) -> None:
+    """Trigger the memory consolidator to compress episodic history into vectors & graph facts.
+
+    Note: Semantic distillation (vector + graph consolidation) is not yet
+    implemented in Phase 1.  This command will report honestly instead of
+    printing fabricated success counters.
+    """
+    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(_memory_compact_async(cli_context))
+
+
+async def _memory_compact_async(cli_context: CLIContext) -> None:
+    container = cli_context.container
+    lifecycle = container.get("runtime.lifecycle")
+
+    await lifecycle.startup()
+
+    # Compact only what Phase 1 actually implements:
+    # flush working memory turns → episodic SQLite.
+    # Semantic distillation and graph consolidation are planned for a later phase.
+    if not cli_context.json_mode:
+        console.print("[bold cyan]⠋[/bold cyan] Flushing working memory to episodic store...")
+
+    try:
+        # shutdown() now handles the flush
+        await lifecycle.shutdown()
+        if not cli_context.json_mode:
+            console.print("[green]✓[/green] Working memory flushed to episodic SQLite.")
+            console.print(
+                "[dim]Note: semantic distillation (vector + graph consolidation) "
+                "is planned for a future phase and is not yet active.[/dim]"
+            )
+    except Exception as exc:
+        await lifecycle.shutdown()
+        if not cli_context.json_mode:
+            console.print(f"[red]✗ Compaction error: {exc}[/red]")
+        if cli_context.json_mode:
+            import json
+
+            print(json.dumps({"success": False, "error": str(exc)}))
+        return
+
+    if cli_context.json_mode:
+        import json
+
+        print(
+            json.dumps(
+                {
+                    "success": True,
+                    "message": "Working memory flushed to episodic SQLite. Semantic compaction not yet implemented.",
+                }
+            )
+        )
+    else:
+        console.print("[bold green]Memory flush complete.[/bold green]")