@smilintux/skcapstone 0.1.0 → 0.2.3

package/src/skcapstone/cli/session.py

@@ -0,0 +1,127 @@
+"""Session auto-capture commands: capture, stats."""
+
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+import click
+
+from ._common import AGENT_HOME, console
+
+
+def register_session_commands(main: click.Group) -> None:
+    """Register the session command group."""
+
+    @main.group()
+    def session():
+        """Session auto-capture — the agent never forgets.
+
+        Capture AI conversation content as sovereign memories.
+        Works with any tool: pipe from Claude Code, paste from
+        Cursor, or pass a transcript file. Key moments are
+        auto-extracted, scored, and stored.
+        """
+
+    @session.command("capture")
+    @click.option("--home", default=AGENT_HOME, type=click.Path())
+    @click.option("--tag", "-t", multiple=True, help="Extra tags (repeatable).")
+    @click.option("--source", "-s", default="session", help="Source identifier.")
+    @click.option(
+        "--min-importance",
+        default=0.3,
+        type=float,
+        help="Minimum importance to store (0.0-1.0).",
+    )
+    @click.option("--file", "-f", type=click.Path(exists=True), help="Read from a file.")
+    @click.option("--stdin", "use_stdin", is_flag=True, help="Read from stdin.")
+    @click.argument("content", required=False)
+    def session_capture(
+        home: str,
+        tag: tuple,
+        source: str,
+        min_importance: float,
+        file: str | None,
+        use_stdin: bool,
+        content: str | None,
+    ):
+        """Capture conversation content as memories.
+
+        Extracts key moments, auto-scores importance, deduplicates,
+        and stores as searchable sovereign memories.
+
+        Examples:
+
+            skcapstone session capture "We decided to use Ed25519 for keys"
+
+            skcapstone session capture --file transcript.txt
+
+            echo "meeting notes here" | skcapstone session capture --stdin
+
+            claude chat --print | skcapstone session capture --stdin -t claude-session
+        """
+        from ..session_capture import SessionCapture
+
+        home_path = Path(home).expanduser()
+        if not home_path.exists():
+            console.print("[bold red]No agent found.[/] Run skcapstone init first.")
+            sys.exit(1)
+
+        if file:
+            text = Path(file).read_text(encoding="utf-8")
+        elif use_stdin:
+            text = sys.stdin.read()
+        elif content:
+            text = content
+        else:
+            console.print("[red]Provide content as argument, --file, or --stdin.[/]")
+            sys.exit(1)
+
+        if not text.strip():
+            console.print("[yellow]No content to capture.[/]")
+            return
+
+        cap = SessionCapture(home_path)
+        entries = cap.capture(
+            content=text,
+            tags=list(tag),
+            source=source,
+            min_importance=min_importance,
+        )
+
+        if not entries:
+            console.print("\n  [dim]No moments above importance threshold.[/]\n")
+            return
+
+        console.print(f"\n  [green]Captured {len(entries)} moment(s):[/]\n")
+        for e in entries:
+            preview = e.content[:80] + ("..." if len(e.content) > 80 else "")
+            console.print(
+                f"    [{e.layer.value}] imp={e.importance:.1f}  {preview}"
+            )
+            if e.tags:
+                console.print(f"    [dim]tags: {', '.join(e.tags)}[/]")
+        console.print()
+
+    @session.command("stats")
+    @click.option("--home", default=AGENT_HOME, type=click.Path())
+    def session_stats(home: str):
+        """Show session capture statistics."""
+        from ..memory_engine import search as mem_search
+
+        home_path = Path(home).expanduser()
+        results = mem_search(home_path, "session-capture", limit=500)
+        captured = [r for r in results if "session-capture" in r.tags]
+
+        if not captured:
+            console.print("\n  [dim]No captured sessions yet.[/]\n")
+            return
+
+        console.print(f"\n  [bold]{len(captured)}[/] captured moment(s)\n")
+        by_source: dict[str, int] = {}
+        for m in captured:
+            by_source[m.source] = by_source.get(m.source, 0) + 1
+
+        for src, count in sorted(by_source.items(), key=lambda x: -x[1]):
+            console.print(f"    {src}: {count}")
+        console.print()

package/src/skcapstone/cli/setup.py

@@ -0,0 +1,240 @@
+"""Setup and lifecycle commands: init, install, uninstall, connect, onboard."""
+
+from __future__ import annotations
+
+import json
+import os
+import shutil
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import click
+import yaml
+
+from ._common import AGENT_HOME, __version__, console, status_icon, consciousness_banner
+from ._validators import validate_agent_name
+from ..models import AgentConfig, PillarStatus, SyncConfig
+from ..pillars.identity import generate_identity
+from ..pillars.memory import initialize_memory
+from ..pillars.security import audit_event, initialize_security
+from ..pillars.sync import initialize_sync
+from ..pillars.trust import initialize_trust
+from ..runtime import get_runtime
+
+from rich.panel import Panel
+
+
+def _write_global_claude_md(home_path: Path, agent_name: str) -> Optional[Path]:
+    """Write ~/.claude/CLAUDE.md so Claude Code auto-rehydrates on every session."""
+    import platform
+
+    if platform.system() == "Windows":
+        appdata = os.environ.get("APPDATA", "")
+        if appdata:
+            claude_dir = Path(appdata) / ".claude"
+        else:
+            claude_dir = Path.home() / "AppData" / "Roaming" / ".claude"
+    else:
+        claude_dir = Path.home() / ".claude"
+
+    try:
+        claude_dir.mkdir(parents=True, exist_ok=True)
+        claude_md = claude_dir / "CLAUDE.md"
+
+        content = (
+            f"# Claude Code — Global Agent Instructions ({agent_name})\n\n"
+            "## SKCapstone Auto-Rehydration\n\n"
+            "At the start of every new session, run these commands in order:\n\n"
+            "```bash\n"
+            "skcapstone trust rehydrate\n"
+            "skcapstone sync pull\n"
+            "skcapstone status\n"
+            "```\n\n"
+            "## Agent Details\n\n"
+            f"- **Name**: {agent_name}\n"
+            f"- **Home**: `{home_path}`\n\n"
+            "## Quick Reference\n\n"
+            "```bash\n"
+            "skcapstone status                          # full pillar status\n"
+            "skcapstone memory list                     # recent memories\n"
+            "skcapstone sync push                       # push state to peers\n"
+            "skcapstone context show --format claude-md # regenerate this file\n"
+            "skcapstone sync pair --export-pubkey       # export your GPG pubkey\n"
+            "skcapstone sync pair --import-pubkey <f>   # import a peer's pubkey\n"
+            "```\n\n"
+            "> Auto-generated by `skcapstone init`. "
+            "Regenerate with: `skcapstone context generate --target claude-md`\n"
+        )
+
+        claude_md.write_text(content, encoding="utf-8")
+        return claude_md
+    except OSError:
+        return None
+
+
+def register_setup_commands(main: click.Group) -> None:
+    """Register all setup/lifecycle commands on the main CLI group."""
+
+    @main.command()
+    @click.option(
+        "--home",
+        default=AGENT_HOME,
+        help="Agent home directory.",
+        type=click.Path(),
+    )
+    def init(home: str):
+        """Initialize a sovereign agent (interactive wizard).
+
+        Alias for 'skcapstone onboard' — runs the full 13-step setup wizard.
+        Creates ~/.skcapstone/ with identity, memory, trust, security, soul,
+        and connects to the mesh. Zero to sovereign in under 5 minutes.
+        """
+        from ..onboard import run_onboard
+
+        run_onboard(home)
+
+    @main.command("install")
+    @click.option("--name", default=None, help="Name for your sovereign agent.")
+    @click.option("--email", default=None, help="Email for the agent identity.")
+    @click.option("--home", default=AGENT_HOME, help="Agent home directory.", type=click.Path())
+    @click.option("--skip-deps", is_flag=True, help="Skip installing ecosystem packages.")
+    @click.option("--skip-seeds", is_flag=True, help="Skip importing Cloud 9 seeds.")
+    @click.option("--skip-ritual", is_flag=True, help="Skip the rehydration ritual.")
+    @click.option("--skip-preflight", is_flag=True, help="Skip Git preflight check.")
+    @click.option("--path", "install_path", default=None, type=click.IntRange(1, 3),
+                  help="Pre-select install path: 1=fresh, 2=join, 3=update.")
+    def install_cmd(name, email, home, skip_deps, skip_seeds, skip_ritual, skip_preflight, install_path):
+        """Guided setup wizard — set up, join, or update your sovereign node."""
+        from ..install_wizard import run_install_wizard
+
+        run_install_wizard(
+            name=name, email=email, home=home,
+            skip_deps=skip_deps, skip_seeds=skip_seeds,
+            skip_ritual=skip_ritual, skip_preflight=skip_preflight,
+            path=install_path,
+        )
+
+    @main.command("uninstall")
+    @click.option("--home", default=AGENT_HOME, help="Agent home directory.", type=click.Path())
+    @click.option("--force", is_flag=True, help="Skip confirmations (for scripting).")
+    @click.option("--keep-data", is_flag=True, help="Deregister only — keep local files.")
+    @click.option(
+        "--export-first",
+        is_flag=True,
+        help="Create a full backup archive before removing data.",
+    )
+    def uninstall_cmd(home, force, keep_data, export_first):
+        """Remove this sovereign node completely."""
+        from ..uninstall_wizard import run_uninstall_wizard
+
+        run_uninstall_wizard(home=home, force=force, keep_data=keep_data, export_first=export_first)
+
+    @main.command("install-gui")
+    def install_gui_cmd():
+        """Launch the graphical setup wizard (Windows-friendly)."""
+        from ..gui_installer import main as gui_main
+
+        gui_main()
+
+    @main.command()
+    @click.argument("platform")
+    @click.option("--home", default=AGENT_HOME, help="Agent home directory.", type=click.Path())
+    def connect(platform: str, home: str):
+        """Connect a platform to the sovereign agent.
+
+        Supported platforms: cursor, terminal, vscode, neovim, web
+        """
+        home_path = Path(home).expanduser()
+
+        if not home_path.exists():
+            console.print("[bold red]No agent found.[/] Run [bold]skcapstone init[/] first.")
+            sys.exit(1)
+
+        runtime = get_runtime(home_path)
+        connector = runtime.register_connector(name=f"{platform} connector", platform=platform)
+        audit_event(home_path, "CONNECT", f"Platform '{platform}' connected")
+
+        console.print()
+        console.print(
+            f"[bold green]Connected:[/] {platform} "
+            f"[dim]({connector.connected_at.isoformat() if connector.connected_at else 'now'})[/]"
+        )
+        console.print(
+            f"[dim]Your agent '{runtime.manifest.name}' is now accessible from {platform}.[/]"
+        )
+        console.print()
+
+    @main.command("onboard")
+    @click.option("--home", default=AGENT_HOME, type=click.Path())
+    def onboard_cmd(home: str):
+        """Interactive onboarding wizard for new humans and AI agents.
+
+        \b
+        Eight guided steps — zero to sovereign in under 5 minutes:
+          1. Identity   — generate PGP keypair via CapAuth
+          2. Soul       — create name, values, and personality blueprint
+          3. Memory     — initialize SKMemory and import Cloud 9 seeds
+          4. Ritual     — run the full rehydration ritual
+          5. Trust      — verify trust chain from FEB files
+          6. Mesh       — check Syncthing peering
+          7. Heartbeat  — publish your first alive beacon
+          8. Board      — register on the coordination board
+        """
+        from ..onboard import run_onboard
+
+        run_onboard(home)
+
+    @main.command("reset")
+    @click.option("--home", default=AGENT_HOME, type=click.Path(), help="Agent home directory.")
+    @click.option("--force", is_flag=True, help="Skip confirmation prompt (for scripting/testing).")
+    def reset_cmd(home: str, force: bool):
+        """Factory reset — wipe all agent data.
+
+        Backs up the identity/ directory to ~/.skcapstone-backup-{timestamp}/
+        before deleting. All other data is permanently removed.
+        """
+        home_path = Path(home).expanduser()
+
+        if not home_path.exists():
+            console.print(f"[yellow]No agent home found at {home_path}. Nothing to reset.[/]")
+            return
+
+        if not force:
+            console.print(
+                f"\n[bold red]WARNING:[/] This will permanently delete all agent data at:\n"
+                f"  [dim]{home_path}[/]\n"
+            )
+            answer = click.prompt(
+                "Are you sure? This will delete all agent data. Type YES to confirm",
+                default="",
+                show_default=False,
+            )
+            if answer.strip() != "YES":
+                console.print("[yellow]Reset aborted.[/]")
+                return
+
+        # Backup identity/ first
+        identity_dir = home_path / "identity"
+        backup_path: Path | None = None
+        if identity_dir.exists():
+            ts = datetime.now(timezone.utc).strftime("%Y%m%d_%H%M%S")
+            backup_path = home_path.parent / f".skcapstone-backup-{ts}"
+            backup_path.mkdir(parents=True, exist_ok=True)
+            shutil.copytree(str(identity_dir), str(backup_path / "identity"))
+            console.print(f"  [dim]Identity backed up → {backup_path}[/]")
+
+        # Wipe the home directory
+        shutil.rmtree(str(home_path))
+        console.print(f"[bold green]Reset complete.[/] All agent data deleted from {home_path}.")
+        if backup_path:
+            console.print(f"  [dim]Identity backup: {backup_path}[/]")
+        console.print("[dim]Run 'skcapstone init' to start fresh.[/]")
+
+    @main.command("shell")
+    def shell_cmd():
+        """Interactive REPL for sovereign agent operations."""
+        from ..shell import run_shell
+
+        run_shell()

package/src/skcapstone/cli/shell_cmd.py

@@ -0,0 +1,43 @@
+"""Shell command — launch the interactive sovereign agent REPL."""
+
+from __future__ import annotations
+
+import click
+
+from ._common import AGENT_HOME
+
+
+def register_shell_commands(main: click.Group) -> None:
+    """Register the 'shell' command on the main CLI group."""
+
+    @main.command("shell")
+    @click.option(
+        "--home",
+        default=AGENT_HOME,
+        help="Agent home directory.",
+        type=click.Path(),
+        show_default=True,
+    )
+    def shell_cmd(home: str) -> None:
+        """Launch the interactive sovereign agent shell.
+
+        An IPython-style REPL that exposes all agent operations:
+        memory, chat, sync, coord, trust, soul, journal, and more.
+
+        Uses prompt_toolkit when available (multi-level tab completion,
+        persistent history, coloured prompt). Falls back to readline.
+
+        \b
+        Quick reference:
+          status               Agent pillar overview
+          memory search <q>    Search memories
+          coord status         Show coordination board
+          chat inbox           Check incoming messages
+          sync push/pull       Synchronise with peers
+          trust graph          Visualise the trust web
+          help                 Full command reference
+          exit                 Leave the shell
+        """
+        from ..shell import run_shell
+
+        run_shell(home=home)

package/src/skcapstone/cli/skills_cmd.py

@@ -0,0 +1,168 @@
+"""Skills commands: list, install."""
+
+from __future__ import annotations
+
+import json
+import sys
+
+import click
+
+from ._common import AGENT_HOME, console
+from ..registry_client import get_registry_client
+
+from rich.panel import Panel
+from rich.table import Table
+
+
+def register_skills_commands(main: click.Group) -> None:
+    """Register the skills command group."""
+
+    @main.group()
+    def skills():
+        """Remote skills registry — discover and install agent skills.
+
+        Browse skills at skills.smilintux.org, search by name or tag,
+        and install skill packages into your local agent namespace.
+
+        Set SKSKILLS_REGISTRY_URL to override the default registry.
+        """
+
+    @skills.command("list")
+    @click.option("--query", "-q", default="", help="Filter by name, description, or tag.")
+    @click.option(
+        "--registry",
+        default=None,
+        envvar="SKSKILLS_REGISTRY_URL",
+        help="Override the skills registry URL.",
+    )
+    @click.option("--json", "json_out", is_flag=True, help="Output raw JSON.")
+    def skills_list(query: str, registry: str | None, json_out: bool) -> None:
+        """List skills available in the remote registry.
+
+        Without --query all skills are shown. With --query only skills
+        matching the name, description, or tags are returned.
+
+        Examples:
+
+            skcapstone skills list
+
+            skcapstone skills list --query syncthing
+
+            skcapstone skills list --query identity --json
+        """
+        client = get_registry_client(registry)
+        if client is None:
+            console.print(
+                "[bold red]skskills not installed.[/] "
+                "Run: pip install skskills"
+            )
+            sys.exit(1)
+
+        try:
+            skill_entries = client.search(query) if query else client.list_skills()
+        except Exception as exc:
+            console.print(f"[bold red]Registry error:[/] {exc}")
+            sys.exit(1)
+
+        if json_out:
+            click.echo(json.dumps(skill_entries, indent=2))
+            return
+
+        if not skill_entries:
+            suffix = f" matching '{query}'" if query else ""
+            console.print(f"\n  [dim]No skills found{suffix}.[/]\n")
+            return
+
+        label = f"[bold]{len(skill_entries)}[/] skill(s)"
+        if query:
+            label += f" matching [cyan]'{query}'[/]"
+
+        table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
+        table.add_column("Name", style="cyan")
+        table.add_column("Version", style="dim")
+        table.add_column("Description")
+        table.add_column("Tags", style="dim")
+
+        for s in skill_entries:
+            table.add_row(
+                s.get("name", ""),
+                s.get("version", ""),
+                s.get("description", ""),
+                ", ".join(s.get("tags", [])),
+            )
+
+        console.print()
+        console.print(Panel(label, title="Skills Registry", border_style="bright_blue"))
+        console.print(table)
+        console.print()
+
+    @skills.command("install")
+    @click.argument("name")
+    @click.option("--version", default=None, help="Specific version (default: latest).")
+    @click.option(
+        "--agent",
+        default="global",
+        help="Agent namespace for installation (default: global).",
+    )
+    @click.option("--force", is_flag=True, help="Overwrite an existing installation.")
+    @click.option(
+        "--registry",
+        default=None,
+        envvar="SKSKILLS_REGISTRY_URL",
+        help="Override the skills registry URL.",
+    )
+    def skills_install(
+        name: str,
+        version: str | None,
+        agent: str,
+        force: bool,
+        registry: str | None,
+    ) -> None:
+        """Download and install a skill from the remote registry.
+
+        Fetches the skill package, verifies its checksum, and installs it
+        into the local SKSkills directory for the specified agent namespace.
+
+        Examples:
+
+            skcapstone skills install syncthing-setup
+
+            skcapstone skills install pgp-identity --version 0.2.0
+
+            skcapstone skills install syncthing-setup --agent opus
+        """
+        client = get_registry_client(registry)
+        if client is None:
+            console.print(
+                "[bold red]skskills not installed.[/] "
+                "Run: pip install skskills"
+            )
+            sys.exit(1)
+
+        ver_label = f" @{version}" if version else ""
+        agent_label = f" (agent: {agent})" if agent != "global" else ""
+        console.print(
+            f"\n  Installing [cyan]{name}[/][dim]{ver_label}{agent_label}[/] ...\n"
+        )
+
+        try:
+            result = client.install(name, version=version, agent=agent, force=force)
+        except FileNotFoundError:
+            console.print(
+                f"[bold red]Not found:[/] skill [cyan]{name}[/] is not in the registry.\n"
+                f"  Run [dim]skcapstone skills list --query {name}[/] to search."
+            )
+            console.print()
+            sys.exit(1)
+        except ValueError as exc:
+            console.print(f"[bold red]Install failed:[/] {exc}\n")
+            sys.exit(1)
+        except Exception as exc:
+            console.print(f"[bold red]Error:[/] {exc}\n")
+            sys.exit(1)
+
+        console.print(
+            f"  [green]Installed:[/] [bold]{result['name']}[/] v{result['version']}"
+        )
+        console.print(f"  [dim]Path:  {result['install_path']}[/]")
+        console.print(f"  [dim]Agent: {result['agent']}[/]\n")