luckyd-code 1.2.2__py3-none-any.whl

luckyd_code/cli_commands/__init__.py

@@ -0,0 +1 @@
+"""CLI slash-command handlers."""

luckyd_code/cli_commands/audit.py

@@ -0,0 +1,120 @@
+"""Handler for /audit subcommands.
+
+Subcommands
+-----------
+/audit run      — run one synchronous audit cycle immediately
+/audit status   — print daemon status summary
+/audit metrics  — dump full metrics history as JSONL
+"""
+
+from __future__ import annotations
+
+import json
+
+from ..cli_utils import console
+
+
+def handle_audit_command(repl, args: list[str]) -> None:
+    """Dispatch /audit <subcommand> [options]."""
+    sub = args[0].lower() if args else "help"
+
+    if sub == "run":
+        _audit_run(repl)
+    elif sub == "status":
+        _audit_status(repl)
+    elif sub == "metrics":
+        _audit_metrics(repl)
+    else:
+        console.print(
+            "[yellow]Usage:[/yellow] /audit run | status | metrics\n"
+            "  [dim]run[/dim]     — trigger one audit cycle right now\n"
+            "  [dim]status[/dim]  — show daemon state and latest metrics\n"
+            "  [dim]metrics[/dim] — dump full JSONL metrics history"
+        )
+
+
+# ------------------------------------------------------------------ #
+#  /audit run
+# ------------------------------------------------------------------ #
+
+def _audit_run(repl) -> None:
+    """Run one synchronous audit cycle in the foreground."""
+    from pathlib import Path
+    from ..audit_daemon import AuditDaemon
+
+    project_root = str(repl.config.working_directory or Path.cwd())
+
+    # Re-use a running daemon instance if available, otherwise create a
+    # temporary one.  The temporary instance will respect the lock file and
+    # bail out if the background daemon is already running.
+    daemon: AuditDaemon = getattr(repl, "_audit_daemon", None) or AuditDaemon(
+        repl.config, project_root=project_root
+    )
+
+    console.print("[dim]Running audit cycle...[/dim]")
+    try:
+        summary = daemon.audit()
+    except Exception as exc:
+        console.print(f"[red]Audit failed: {exc}[/red]")
+        return
+
+    if summary.get("skipped"):
+        console.print(f"[yellow]Audit skipped:[/yellow] {summary['skip_reason']}")
+        return
+
+    metrics = summary.get("metrics", {})
+    attempted = summary.get("improvements_attempted", 0)
+    committed = summary.get("improvements_committed", 0)
+    regressions = summary.get("regressions", [])
+
+    console.print("[bold green]Audit complete[/bold green]")
+    if metrics:
+        for name, value in sorted(metrics.items()):
+            console.print(f"  [cyan]{name:<28}[/cyan] {value:.4f}")
+    if regressions:
+        for r in regressions:
+            console.print(f"  [red]⚠ regression:[/red] {r}")
+    if attempted:
+        status = "committed" if committed else "rolled back"
+        console.print(f"  improvement: {status} ({attempted} attempted, {committed} committed)")
+
+
+# ------------------------------------------------------------------ #
+#  /audit status
+# ------------------------------------------------------------------ #
+
+def _audit_status(repl) -> None:
+    """Print human-readable daemon status."""
+    from pathlib import Path
+    from ..audit_daemon import AuditDaemon
+
+    project_root = str(repl.config.working_directory or Path.cwd())
+    daemon: AuditDaemon = getattr(repl, "_audit_daemon", None) or AuditDaemon(
+        repl.config, project_root=project_root
+    )
+
+    console.print(daemon.status())
+
+
+# ------------------------------------------------------------------ #
+#  /audit metrics
+# ------------------------------------------------------------------ #
+
+def _audit_metrics(repl) -> None:
+    """Dump full metrics history as pretty-printed JSON."""
+    from pathlib import Path
+    from ..audit_daemon import AuditDaemon
+
+    project_root = str(repl.config.working_directory or Path.cwd())
+    daemon: AuditDaemon = getattr(repl, "_audit_daemon", None) or AuditDaemon(
+        repl.config, project_root=project_root
+    )
+
+    raw = daemon.metrics_json()
+    rows = json.loads(raw)
+    if not rows:
+        console.print("[yellow]No metrics recorded yet. Run /audit run to collect a baseline.[/yellow]")
+        return
+
+    console.print(f"[dim]{len(rows)} metric rows — most recent last[/dim]")
+    console.print(raw)

luckyd_code/cli_commands/background.py

@@ -0,0 +1,83 @@
+"""Handle /background commands."""
+
+
+def handle_background_command(repl, args):
+    """Handle /background start|status|result|list commands."""
+    from ..cli_utils import console
+
+    if not args:
+        console.print("[yellow]Usage: /background start|status|result|list[/yellow]")
+        return
+
+    sub = args[0].lower()
+
+    if sub == "start":
+        task = " ".join(args[1:])
+        if not task:
+            console.print("[yellow]Usage: /background start <task description>[/yellow]")
+            return
+        task_id = repl.background.start_task(task)
+        console.print(f"[green]Background task started:[/green] {task_id}")
+        console.print(f"[dim]Check status: /background status {task_id}[/dim]")
+        console.print(f"[dim]View result: /background result {task_id}[/dim]")
+
+    elif sub == "status":
+        if len(args) > 1:
+            statuses = repl.background.get_status(args[1])
+        else:
+            statuses = repl.background.get_status()
+
+        if not statuses:
+            console.print("[yellow]No background tasks[/yellow]")
+            return
+
+        for s in statuses:
+            status_color = {
+                "pending": "yellow",
+                "running": "cyan",
+                "done": "green",
+                "error": "red",
+            }.get(s["status"], "dim")
+
+            console.print(f"  [{status_color}]{s['id']}[/{status_color}] {s['status']}")
+            console.print(f"    Task: {s['description']}")
+            if s["result_preview"]:
+                console.print(f"    Preview: {s['result_preview']}")
+
+    elif sub == "result":
+        if len(args) < 2:
+            console.print("[yellow]Usage: /background result <task_id>[/yellow]")
+            return
+        result = repl.background.get_result(args[1])
+        if result:
+            console.print(result)
+        else:
+            statuses = repl.background.get_status(args[1])
+            if statuses and statuses[0]:
+                s = statuses[0]
+                if s["status"] == "running":
+                    console.print("[yellow]Task still running...[/yellow]")
+                elif s["status"] == "error":
+                    console.print(f"[red]Task failed: {s['error']}[/red]")
+                else:
+                    console.print("[yellow]No result yet[/yellow]")
+            else:
+                console.print("[red]Task not found[/red]")
+
+    elif sub == "list":
+        statuses = repl.background.get_status()
+        if not statuses:
+            console.print("[yellow]No background tasks[/yellow]")
+            return
+        console.print("[bold]Background Tasks:[/bold]")
+        for s in statuses:
+            status_color = {
+                "pending": "yellow",
+                "running": "cyan",
+                "done": "green",
+                "error": "red",
+            }.get(s["status"], "dim")
+            console.print(f"  [{status_color}]{s['id']}[/{status_color}] ({s['status']}) {s['description']}")
+
+    else:
+        console.print(f"[red]Unknown: /background {sub}[/red]")

luckyd_code/cli_commands/brain.py

@@ -0,0 +1,87 @@
+"""Handle /brain commands."""
+
+import os
+import time as _time
+
+from ..brain import Retriever, VectorIndexer, rebuild_project
+
+
+def handle_brain_command(repl, args):
+    """Handle /brain rebuild|stats|status commands."""
+    from ..cli_utils import console
+
+    sub = args[0].lower() if args else "status"
+
+    if sub == "rebuild":
+        with console.status("Rebuilding codebase index...", spinner="dots"):
+            result = rebuild_project(os.getcwd())
+            repl.brain.load()
+            repl._rag_retriever = None
+
+        rag_info = f"{result.get('chunks', 0)} chunks, {result.get('files', 0)} files" if result.get('chunks') else "no supported files found"
+        console.print(
+            f"[green]Brain rebuilt:[/green] {rag_info} | "
+            f"{result.get('node_count', 0)} symbols, "
+            f"{result.get('files_parsed', 0)} files"
+        )
+
+        brain_summary = repl.brain.summarize()
+        for i, m in enumerate(repl.context.messages):
+            if isinstance(m.get("content"), str) and m["content"].startswith("<knowledge-graph>"):
+                repl.context.messages[i]["content"] = brain_summary
+                break
+            elif isinstance(m.get("content"), str) and m["content"].startswith("<rag-context>"):
+                repl.context.messages.pop(i)
+                break
+        else:
+            repl.context.messages.insert(1, {
+                "role": "user",
+                "content": brain_summary,
+            })
+
+    elif sub == "stats":
+        has_rag = True
+        try:
+            r = Retriever()
+            info = r.stats()
+        except Exception:
+            has_rag = False
+
+        if not repl.brain.nodes and not has_rag:
+            console.print("[yellow]Brain is empty. Run `/brain rebuild` to index your codebase.[/yellow]")
+            return
+
+        from ..tools.brain_tools import BrainStatusTool
+        status = BrainStatusTool()
+        console.print(status.run())
+
+    else:  # "status" or no args
+        rag_available = False
+        try:
+            idx = VectorIndexer()
+            rag_available = idx.load()
+        except Exception:
+            pass
+
+        if not repl.brain.nodes and not rag_available:
+            console.print("[yellow]Brain is empty. Run `/brain rebuild` to index your codebase.[/yellow]")
+            return
+
+        if rag_available:
+            r = Retriever()
+            info = r.stats()
+            vec = info.get("vector", {})
+            console.print(
+                f"[cyan]Brain:[/cyan] {vec.get('chunks', 0)} chunks, "
+                f"{vec.get('files', 0)} files | "
+                f"{repl.brain.stats.get('node_count', 0)} symbols"
+            )
+        else:
+            console.print(f"[cyan]Brain:[/cyan] {repl.brain.stats.get('node_count', 0)} symbols, "
+                         f"{repl.brain.stats.get('edge_count', 0)} relations, "
+                         f"{repl.brain.stats.get('files_parsed', 0)} files")
+        if repl.brain.stats.get("last_built"):
+            last = _time.strftime("%Y-%m-%d %H:%M:%S",
+                                 _time.localtime(repl.brain.stats["last_built"]))
+            console.print(f"[cyan]Last built:[/cyan] {last}")
+        console.print("[dim]Full stats: /brain stats | Rebuild: /brain rebuild[/dim]")

luckyd_code/cli_commands/config.py

@@ -0,0 +1,75 @@
+"""Handle /config commands."""
+
+import os
+
+from .. import settings as cfg
+from ..api import test_connection
+
+
+def handle_config_command(repl, args):
+    """Handle /config list|get|set commands."""
+    from ..cli_utils import console
+
+    if not args:
+        console.print("[yellow]Usage: /config list|get|set[/yellow]")
+        return
+
+    sub = args[0].lower()
+
+    if sub == "list":
+        console.print("[bold]Provider:[/bold]")
+        console.print(f"  [cyan]provider[/cyan] = {repl.config.provider}")
+        console.print(f"  [cyan]model[/cyan] = {repl.config.model}")
+        console.print(f"  [cyan]base_url[/cyan] = {repl.config.base_url}")
+        console.print("[bold]Settings:[/bold]")
+        settings = cfg.load_settings()
+        for k, v in settings.items():
+            console.print(f"  [cyan]{k}[/cyan] = {v}")
+
+    elif sub == "get":
+        if len(args) < 2:
+            console.print("[yellow]Usage: /config get <key>[/yellow]")
+            return
+        settings = cfg.load_settings()
+        val = settings.get(args[1], "[dim]not set[/dim]")
+        console.print(f"[cyan]{args[1]}[/cyan] = {val}")
+
+    elif sub == "set":
+        if len(args) < 3:
+            console.print("[yellow]Usage: /config set <key> <value>[/yellow]")
+            return
+
+        if args[1] == "provider":
+            if args[2] != "deepseek":
+                console.print("[red]Provider must be 'deepseek'[/red]")
+                return
+            repl.config.provider = args[2]
+            repl.config.base_url = "https://api.deepseek.com/v1"
+            env_key = os.environ.get("DEEPSEEK_API_KEY")
+            if env_key:
+                repl.config.api_key = env_key
+            repl.config.save()
+            console.print(f"[green]Switched provider to {args[2]}[/green]")
+            console.print(f"[green]  base_url: {repl.config.base_url}[/green]")
+            with console.status("Testing new API connection...", spinner="dots"):
+                ok, msg = test_connection(repl.config.api_key, repl.config.base_url)
+            if ok:
+                console.print("[green]New connection OK[/green]")
+            else:
+                console.print(f"[red]New connection failed: {msg}[/red]")
+            return
+
+        if args[1] == "shell":
+            valid = ("auto", "git_bash", "wsl", "cmd")
+            if args[2] not in valid:
+                console.print(f"[red]Shell must be one of: {', '.join(valid)}[/red]")
+                return
+            from ..tools.bash import reset_shell_cache
+            reset_shell_cache()
+            console.print(f"[green]Shell set to {args[2]}. Will take effect on next Bash command.[/green]")
+
+        cfg.save_setting(args[1], args[2])
+        console.print(f"[green]Set {args[1]} = {args[2]}[/green]")
+
+    else:
+        console.print(f"[red]Unknown: /config {sub}[/red]")