@smilintux/skcapstone 0.1.0 → 0.2.3

package/src/skcapstone/cli/metrics_cmd.py

@@ -0,0 +1,136 @@
+"""Metrics command: show today's consciousness loop stats."""
+
+from __future__ import annotations
+
+import json
+from datetime import datetime, timezone
+from pathlib import Path
+
+import click
+
+from ._common import AGENT_HOME, console
+
+
+def register_metrics_commands(main: click.Group) -> None:
+    """Register the ``skcapstone metrics`` command."""
+
+    @main.command("metrics")
+    @click.option("--home", default=AGENT_HOME, type=click.Path(), help="Agent home directory.")
+    @click.option("--port", default=7777, help="Daemon API port (default: 7777).")
+    @click.option("--json-out", is_flag=True, help="Output raw JSON.")
+    @click.option("--date", "date_str", default=None, help="Show metrics for a specific date (YYYY-MM-DD).")
+    def metrics_cmd(home: str, port: int, json_out: bool, date_str: str | None):
+        """Show today's consciousness loop metrics.
+
+        Tries the running daemon first (GET /api/v1/metrics).
+        Falls back to reading the persisted daily JSON file.
+        """
+        data = _fetch_from_daemon(port)
+        if data is None:
+            data = _read_from_file(Path(home).expanduser(), date_str)
+
+        if data is None:
+            if json_out:
+                click.echo(json.dumps({"error": "No metrics available"}))
+            else:
+                console.print("[yellow]No metrics found.[/] Start the daemon or run a test message first.")
+            return
+
+        if json_out:
+            click.echo(json.dumps(data, indent=2))
+            return
+
+        _print_metrics(data)
+
+
+def _fetch_from_daemon(port: int) -> dict | None:
+    """Try GET /api/v1/metrics from the running daemon."""
+    import urllib.request
+    import urllib.error
+
+    try:
+        url = f"http://127.0.0.1:{port}/api/v1/metrics"
+        with urllib.request.urlopen(url, timeout=2) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except Exception:
+        return None
+
+
+def _read_from_file(home: Path, date_str: str | None) -> dict | None:
+    """Read a daily metrics JSON from disk."""
+    if date_str is None:
+        date_str = datetime.now(timezone.utc).strftime("%Y-%m-%d")
+    path = home / "metrics" / "daily" / f"{date_str}.json"
+    if not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+
+
+def _print_metrics(data: dict) -> None:
+    """Render metrics in a rich panel."""
+    from rich.panel import Panel
+    from rich.table import Table
+
+    date = data.get("date", "?")
+    msgs = data.get("messages_processed", 0)
+    responses = data.get("responses_sent", 0)
+    errors = data.get("errors", 0)
+    rt = data.get("response_time_ms", {})
+
+    error_color = "red" if errors > 0 else "green"
+    rt_str = (
+        f"min={rt.get('min', 0):.0f}ms  "
+        f"avg={rt.get('avg', 0):.0f}ms  "
+        f"p99={rt.get('p99', 0):.0f}ms  "
+        f"max={rt.get('max', 0):.0f}ms  "
+        f"n={rt.get('count', 0)}"
+    ) if rt.get("count", 0) > 0 else "[dim]no data[/]"
+
+    summary_lines = [
+        f"[bold]Date:[/]          {date}",
+        f"[bold]Messages:[/]      {msgs}",
+        f"[bold]Responses:[/]     {responses}",
+        f"[bold]Errors:[/]        [{error_color}]{errors}[/]",
+        f"[bold]Response time:[/] {rt_str}",
+    ]
+    console.print()
+    console.print(Panel(
+        "\n".join(summary_lines),
+        title="[cyan]Consciousness Metrics[/]",
+        border_style="cyan",
+    ))
+
+    # Backend usage table
+    backend_usage = data.get("backend_usage", {})
+    if backend_usage:
+        table = Table(title="Backend Usage", box=None, padding=(0, 2))
+        table.add_column("Backend", style="bold")
+        table.add_column("Requests", justify="right")
+        for bk, count in sorted(backend_usage.items(), key=lambda x: -x[1]):
+            table.add_row(bk, str(count))
+        console.print(table)
+
+    # Tier usage table
+    tier_usage = data.get("tier_usage", {})
+    if tier_usage:
+        table = Table(title="Tier Usage", box=None, padding=(0, 2))
+        table.add_column("Tier", style="bold")
+        table.add_column("Requests", justify="right")
+        for tier, count in sorted(tier_usage.items(), key=lambda x: -x[1]):
+            table.add_row(tier, str(count))
+        console.print(table)
+
+    # Per-peer message counts (top 10)
+    peer_counts = data.get("messages_per_peer", {})
+    if peer_counts:
+        table = Table(title="Messages per Peer (top 10)", box=None, padding=(0, 2))
+        table.add_column("Peer", style="bold cyan")
+        table.add_column("Messages", justify="right")
+        for peer, count in sorted(peer_counts.items(), key=lambda x: -x[1])[:10]:
+            table.add_row(peer, str(count))
+        console.print(table)
+
+    console.print()

package/src/skcapstone/cli/migrate.py

@@ -0,0 +1,62 @@
+"""CLI commands for multi-agent migration."""
+
+from __future__ import annotations
+
+import click
+
+from ._common import console
+
+
+def register_migrate_commands(cli: click.Group) -> None:
+    """Register the 'migrate' command group."""
+    cli.add_command(migrate_cmd)
+
+
+@click.command("migrate")
+@click.option("--agent", required=True, help="Agent name (e.g., opus)")
+@click.option("--dry-run", is_flag=True, help="Show what would happen without moving")
+@click.option("--root", default="~/.skcapstone", help="skcapstone root directory")
+def migrate_cmd(agent: str, dry_run: bool, root: str) -> None:
+    """Migrate to multi-agent household layout.
+
+    Moves per-agent data into agents/{name}/ and creates symlinks
+    at old paths for backward compatibility.
+    """
+    from pathlib import Path
+
+    from ..migrate_multi_agent import migrate_to_multi_agent
+
+    results = migrate_to_multi_agent(
+        root=Path(root),
+        agent_name=agent,
+        dry_run=dry_run,
+    )
+
+    if dry_run:
+        console.print("[yellow]DRY RUN[/] — no files will be moved\n")
+
+    if results["moved"]:
+        console.print("[green]Moved:[/]")
+        for item in results["moved"]:
+            console.print(f"  {item}")
+
+    if results["symlinks_created"]:
+        console.print("\n[cyan]Symlinks created:[/]")
+        for link in results["symlinks_created"]:
+            console.print(f"  {link}")
+
+    if results["skipped"]:
+        console.print("\n[dim]Skipped:[/]")
+        for item in results["skipped"]:
+            console.print(f"  {item}")
+
+    if results["errors"]:
+        console.print("\n[red]Errors:[/]")
+        for err in results["errors"]:
+            console.print(f"  {err}")
+
+    if not results["moved"] and not dry_run:
+        console.print("[dim]Nothing to migrate.[/]")
+    elif not dry_run:
+        console.print(f"\n[green]Migration complete.[/] Agent home: {results['agent_home']}")
+        console.print(f"[dim]Use: SKCAPSTONE_AGENT={agent} skcapstone status[/]")

package/src/skcapstone/cli/mood_cmd.py

@@ -0,0 +1,144 @@
+"""Mood command: display the agent's current emotional state."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import click
+
+from ._common import AGENT_HOME, console
+
+
+def register_mood_commands(main: click.Group) -> None:
+    """Register the ``skcapstone mood`` command."""
+
+    @main.command("mood")
+    @click.option(
+        "--home", default=AGENT_HOME, type=click.Path(),
+        help="Agent home directory.",
+    )
+    @click.option("--json-out", is_flag=True, help="Output raw JSON.")
+    @click.option(
+        "--update", is_flag=True,
+        help="Refresh from persisted daily metrics before displaying.",
+    )
+    def mood_cmd(home: str, json_out: bool, update: bool) -> None:
+        """Show the agent's current emotional state.
+
+        Mood is derived from three interaction pattern factors:
+
+        \b
+          Success   — response success rate (happy / frustrated)
+          Social    — message frequency     (social / isolated)
+          Stress    — error rate            (calm / stressed)
+        """
+        from ..mood import MoodTracker
+
+        home_path = Path(home).expanduser()
+        tracker = MoodTracker(home=home_path)
+
+        if update:
+            try:
+                from ..metrics import ConsciousnessMetrics
+                metrics = ConsciousnessMetrics(home=home_path, persist_interval=0)
+                tracker.update_from_metrics(metrics)
+            except Exception as exc:
+                if not json_out:
+                    console.print(f"[yellow]Warning: could not refresh metrics: {exc}[/]")
+
+        snap = tracker.snapshot
+
+        if json_out:
+            click.echo(snap.model_dump_json(indent=2))
+            return
+
+        _print_mood(snap)
+
+
+# ---------------------------------------------------------------------------
+# Rich rendering
+# ---------------------------------------------------------------------------
+
+_SUMMARY_COLORS: dict[str, str] = {
+    "flourishing": "bright_green",
+    "happy": "green",
+    "content": "cyan",
+    "neutral": "white",
+    "isolated": "dim",
+    "tense": "yellow",
+    "frustrated": "red",
+    "stressed": "bold red",
+}
+
+_SUCCESS_COLORS: dict[str, str] = {
+    "happy": "green",
+    "content": "cyan",
+    "neutral": "white",
+    "frustrated": "red",
+}
+
+_SOCIAL_COLORS: dict[str, str] = {
+    "social": "bright_cyan",
+    "active": "green",
+    "quiet": "white",
+    "isolated": "dim",
+}
+
+_STRESS_COLORS: dict[str, str] = {
+    "calm": "green",
+    "relaxed": "cyan",
+    "tense": "yellow",
+    "stressed": "bold red",
+}
+
+
+def _print_mood(snap) -> None:
+    """Render mood snapshot with Rich.
+
+    Args:
+        snap: :class:`~skcapstone.mood.MoodSnapshot` to display.
+    """
+    from rich.panel import Panel
+    from rich.table import Table
+
+    border_color = _SUMMARY_COLORS.get(snap.summary, "white")
+    summary_color = _SUMMARY_COLORS.get(snap.summary, "white")
+
+    header = f"[{summary_color}]{snap.summary.upper()}[/]"
+    if snap.updated_at:
+        header += f"  [dim]{snap.updated_at[:19]}Z[/]"
+
+    table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
+    table.add_column("Dimension", style="bold", min_width=10)
+    table.add_column("State", min_width=12)
+    table.add_column("Detail", style="dim")
+
+    # Success row
+    sc = _SUCCESS_COLORS.get(snap.success_mood, "white")
+    table.add_row(
+        "Success",
+        f"[{sc}]{snap.success_mood}[/]",
+        f"{snap.responses_sent}/{snap.messages_processed} responses  ({snap.success_rate:.0%})",
+    )
+
+    # Social row
+    soc = _SOCIAL_COLORS.get(snap.social_mood, "white")
+    table.add_row(
+        "Social",
+        f"[{soc}]{snap.social_mood}[/]",
+        f"{snap.messages_per_hour:.1f} msgs/hr  (window: {snap.window_hours}h)",
+    )
+
+    # Stress row
+    stc = _STRESS_COLORS.get(snap.stress_mood, "white")
+    table.add_row(
+        "Stress",
+        f"[{stc}]{snap.stress_mood}[/]",
+        f"{snap.errors} errors  ({snap.error_rate:.0%} error rate)",
+    )
+
+    console.print()
+    console.print(Panel(header, title="[bold]Agent Mood[/]", border_style=border_color))
+    console.print(table)
+    console.print()

package/src/skcapstone/cli/mount.py

@@ -0,0 +1,193 @@
+"""FUSE mount commands: start, stop, status."""
+
+from __future__ import annotations
+
+import json
+import sys
+from pathlib import Path
+
+import click
+
+from ._common import AGENT_HOME, console
+
+from rich.panel import Panel
+from rich.table import Table
+
+
+def register_mount_commands(main: click.Group) -> None:
+    """Register the mount command group."""
+
+    @main.group()
+    def mount():
+        """Sovereign FUSE filesystem — browse agent data as files.
+
+        \b
+        Mount the sovereign virtual filesystem to access memories, identity,
+        inbox, outbox, and coordination tasks as ordinary files.
+
+        \b
+        Mount:    skcapstone mount start
+        Debug:    skcapstone mount start --foreground
+        Unmount:  skcapstone mount stop
+        Status:   skcapstone mount status
+        """
+
+    @mount.command("start")
+    @click.option(
+        "--mount-point",
+        default="~/.sovereign/mount",
+        type=click.Path(),
+        help="Directory to mount the sovereign filesystem at.",
+        show_default=True,
+    )
+    @click.option(
+        "--home",
+        default=AGENT_HOME,
+        type=click.Path(),
+        help="Agent home directory.",
+    )
+    @click.option(
+        "--foreground",
+        "foreground",
+        is_flag=True,
+        default=False,
+        help="Run in foreground (blocks; useful for debugging).",
+    )
+    def mount_start(mount_point: str, home: str, foreground: bool):
+        """Mount the sovereign virtual filesystem.
+
+        Exposes memories, identity, inbox, outbox, and coordination tasks
+        as a read-mostly POSIX filesystem via FUSE.
+
+        \b
+        Requires: pip install skcapstone[fuse]
+
+        \b
+        Examples:
+
+            skcapstone mount start
+
+            skcapstone mount start --mount-point /mnt/sovereign
+
+            skcapstone mount start --foreground
+        """
+        from ..fuse_mount import FUSEDaemon
+
+        mount_path = Path(mount_point).expanduser()
+        home_path = Path(home).expanduser()
+
+        daemon = FUSEDaemon(mount_point=mount_path, agent_home=home_path)
+
+        if foreground:
+            console.print(
+                f"[bold cyan]Mounting sovereign filesystem at [white]{mount_path}[/] "
+                f"[dim](foreground — Ctrl-C to unmount)[/]"
+            )
+        else:
+            console.print(
+                f"[bold cyan]Mounting sovereign filesystem at [white]{mount_path}[/] ..."
+            )
+
+        ok = daemon.start(foreground=foreground)
+
+        if ok and not foreground:
+            console.print(f"[green]Mounted.[/] [dim]Unmount with: skcapstone mount stop[/]")
+        elif not ok:
+            console.print("[bold red]Mount failed.[/] Check logs or try --foreground for details.")
+            sys.exit(1)
+
+    @mount.command("stop")
+    @click.option(
+        "--mount-point",
+        default="~/.sovereign/mount",
+        type=click.Path(),
+        help="Mount point to unmount.",
+        show_default=True,
+    )
+    @click.option(
+        "--home",
+        default=AGENT_HOME,
+        type=click.Path(),
+        help="Agent home directory.",
+    )
+    def mount_stop(mount_point: str, home: str):
+        """Unmount the sovereign virtual filesystem.
+
+        \b
+        Example:
+
+            skcapstone mount stop
+        """
+        from ..fuse_mount import FUSEDaemon
+
+        mount_path = Path(mount_point).expanduser()
+        home_path = Path(home).expanduser()
+
+        daemon = FUSEDaemon(mount_point=mount_path, agent_home=home_path)
+        console.print(f"[bold cyan]Unmounting {mount_path} ...[/]")
+
+        ok = daemon.stop()
+        if ok:
+            console.print("[green]Unmounted.[/]")
+        else:
+            console.print(
+                "[bold red]Unmount failed.[/] "
+                f"[dim]Try manually: fusermount -u {mount_path}[/]"
+            )
+            sys.exit(1)
+
+    @mount.command("status")
+    @click.option(
+        "--mount-point",
+        default="~/.sovereign/mount",
+        type=click.Path(),
+        help="Mount point to check.",
+        show_default=True,
+    )
+    @click.option(
+        "--home",
+        default=AGENT_HOME,
+        type=click.Path(),
+        help="Agent home directory.",
+    )
+    @click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+    def mount_status(mount_point: str, home: str, as_json: bool):
+        """Show the status of the sovereign FUSE filesystem.
+
+        \b
+        Example:
+
+            skcapstone mount status
+
+            skcapstone mount status --json
+        """
+        from ..fuse_mount import FUSEDaemon
+
+        mount_path = Path(mount_point).expanduser()
+        home_path = Path(home).expanduser()
+
+        daemon = FUSEDaemon(mount_point=mount_path, agent_home=home_path)
+        status = daemon.status()
+
+        if as_json:
+            click.echo(json.dumps(status, indent=2))
+            return
+
+        mounted = status.get("mounted", False)
+        icon = "[bold green]MOUNTED[/]" if mounted else "[bold red]NOT MOUNTED[/]"
+        pid = status.get("pid")
+        updated = status.get("updated_at", "—")
+
+        table = Table(show_header=False, box=None, padding=(0, 2))
+        table.add_column("Key", style="dim")
+        table.add_column("Value")
+
+        table.add_row("Status", icon)
+        table.add_row("Mount point", str(status.get("mount_point", "")))
+        table.add_row("Agent home", str(status.get("agent_home", "")))
+        table.add_row("PID", str(pid) if pid else "[dim]—[/]")
+        table.add_row("Last updated", updated or "[dim]—[/]")
+
+        console.print()
+        console.print(Panel(table, title="[bold]Sovereign Filesystem Status[/]", border_style="cyan"))
+        console.print()

package/src/skcapstone/cli/notify.py

@@ -0,0 +1,112 @@
+"""Notification commands: skcapstone notify test / skcapstone notifications."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+
+from ._common import AGENT_HOME, console
+
+
+def register_notify_commands(main: click.Group) -> None:
+    """Register the notify command group and the notifications alias."""
+
+    @main.group()
+    def notify():
+        """Desktop notification management."""
+
+    @notify.command("test")
+    @click.option("--title", default="SKCapstone", show_default=True, help="Notification title.")
+    @click.option("--body", default="Test notification from SKCapstone.", show_default=True, help="Notification body.")
+    @click.option(
+        "--urgency",
+        default="normal",
+        show_default=True,
+        type=click.Choice(["low", "normal", "critical"]),
+        help="Notification urgency.",
+    )
+    @click.option(
+        "--dashboard-url",
+        default="http://localhost:7778",
+        show_default=True,
+        help="Dashboard URL opened when the 'Open Dashboard' action is clicked.",
+    )
+    def notify_test(title: str, body: str, urgency: str, dashboard_url: str):
+        """Send a test desktop notification with click-action buttons."""
+        from ..notifications import NotificationManager
+
+        # Bypass debounce for the test command by using a fresh manager
+        mgr = NotificationManager(debounce_seconds=0, dashboard_url=dashboard_url)
+        dispatched = mgr.notify(title, body, urgency)
+        if dispatched:
+            console.print(f"\n  [green]Notification dispatched[/]: {title!r} / {body!r}\n")
+            console.print(
+                "  [dim]Click 'Open Dashboard' to open the dashboard, "
+                "or 'Open SKChat' to launch skchat watch.[/]\n"
+            )
+        else:
+            console.print(
+                "\n  [yellow]Notification not dispatched[/] — no supported notification "
+                "system found (gi.repository.Notify / notify-send / osascript).\n"
+            )
+
+    # -----------------------------------------------------------------------
+    # Top-level alias: skcapstone notifications
+    # -----------------------------------------------------------------------
+
+    @main.command("notifications")
+    @click.option("--home", default=AGENT_HOME, type=click.Path(), help="Agent home directory.")
+    @click.option("--limit", "-n", default=20, show_default=True, help="Max results to show.")
+    @click.option("--json-out", is_flag=True, help="Output as JSON.")
+    def notifications_cmd(home: str, limit: int, json_out: bool):
+        """Show notification history (memories tagged 'notification')."""
+        import json as _json
+
+        from ..memory_engine import search as mem_search
+
+        home_path = Path(home).expanduser()
+        if not home_path.exists():
+            if json_out:
+                print(_json.dumps([]))
+                return
+            console.print("[bold red]No agent found.[/] Run skcapstone init first.")
+            sys.exit(1)
+
+        results = mem_search(home=home_path, query="notification", tags=["notification"], limit=limit)
+
+        if json_out:
+            output = [
+                {
+                    "id": entry.memory_id,
+                    "content": entry.content,
+                    "tags": entry.tags,
+                    "layer": entry.layer.value,
+                    "created_at": entry.created_at.isoformat() if entry.created_at else None,
+                }
+                for entry in results
+            ]
+            print(_json.dumps(output))
+            return
+
+        if not results:
+            console.print("\n  [dim]No notification history found.[/]\n")
+            return
+
+        from rich.table import Table
+
+        console.print(f"\n  [bold]{len(results)}[/] notification{'s' if len(results) != 1 else ''} in history:\n")
+
+        table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
+        table.add_column("ID", style="cyan", max_width=14)
+        table.add_column("When", style="dim", max_width=22)
+        table.add_column("Content", max_width=70)
+
+        for entry in results:
+            created = entry.created_at.strftime("%Y-%m-%d %H:%M:%S") if entry.created_at else "—"
+            preview = entry.content[:100] + ("..." if len(entry.content) > 100 else "")
+            table.add_row(entry.memory_id, created, preview)
+
+        console.print(table)
+        console.print()