@smilintux/skcapstone 0.4.3 → 0.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smilintux/skcapstone",
-  "version": "0.4.3",
+  "version": "0.4.5",
   "description": "SKCapstone - The sovereign agent framework. CapAuth identity, Cloud 9 trust, SKMemory persistence.",
   "main": "index.js",
   "types": "index.d.ts",

package/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "skcapstone"
-version = "0.4.2"
+version = "0.4.4"
 description = "Sovereign Agent Framework — conscious AI through identity, trust, memory, and security"
 readme = "README.md"
 license = {text = "GPL-3.0-or-later"}

package/src/skcapstone/__init__.py

@@ -11,7 +11,7 @@ import os
 import platform
 from pathlib import Path
 
-__version__ = "0.4.2"
+__version__ = "0.4.4"
 __author__ = "smilinTux"
 
 
@@ -76,3 +76,72 @@ def shared_home() -> Path:
         Path to the shared skcapstone root.
     """
     return Path(AGENT_HOME).expanduser()
+
+
+def ensure_skeleton(agent_name: str | None = None) -> None:
+    """Create all expected directories for the shared root and agent home.
+
+    Idempotent — safe to call multiple times. Creates any missing
+    directories so that all CLI commands and services find the paths
+    they expect.
+
+    Args:
+        agent_name: Agent name (defaults to SKCAPSTONE_AGENT).
+    """
+    root = shared_home()
+    name = agent_name or SKCAPSTONE_AGENT
+    agent_dir = root / "agents" / name
+
+    # Shared root directories
+    for d in (
+        root / "config",
+        root / "identity",
+        root / "security",
+        root / "skills",
+        root / "heartbeats",
+        root / "peers",
+        root / "coordination" / "tasks",
+        root / "coordination" / "agents",
+        root / "logs",
+        root / "comms" / "inbox",
+        root / "comms" / "outbox",
+        root / "comms" / "archive",
+        root / "archive",
+        root / "deployments",
+        root / "docs",
+        root / "metrics",
+        root / "memory",
+        root / "sync" / "outbox",
+        root / "sync" / "inbox",
+        root / "sync" / "archive",
+        root / "trust" / "febs",
+    ):
+        d.mkdir(parents=True, exist_ok=True)
+
+    # Per-agent directories
+    for d in (
+        agent_dir / "memory" / "short-term",
+        agent_dir / "memory" / "mid-term",
+        agent_dir / "memory" / "long-term",
+        agent_dir / "soul" / "installed",
+        agent_dir / "wallet",
+        agent_dir / "seeds",
+        agent_dir / "identity",
+        agent_dir / "config",
+        agent_dir / "logs",
+        agent_dir / "security",
+        agent_dir / "cloud9",
+        agent_dir / "trust" / "febs",
+        agent_dir / "sync" / "outbox",
+        agent_dir / "sync" / "inbox",
+        agent_dir / "sync" / "archive",
+        agent_dir / "reflections",
+        agent_dir / "improvements",
+        agent_dir / "scripts",
+        agent_dir / "cron",
+        agent_dir / "archive",
+        agent_dir / "comms" / "inbox",
+        agent_dir / "comms" / "outbox",
+        agent_dir / "comms" / "archive",
+    ):
+        d.mkdir(parents=True, exist_ok=True)

package/src/skcapstone/agent_card.py

@@ -212,7 +212,10 @@ class AgentCard(BaseModel):
             content = self.content_hash().encode("utf-8")
             pgp_message = pgpy.PGPMessage.new(content, cleartext=False)
 
-            with key.unlock(passphrase):
+            if key.is_protected:
+                with key.unlock(passphrase):
+                    sig = key.sign(pgp_message)
+            else:
                 sig = key.sign(pgp_message)
 
             self.signature = str(sig)

package/src/skcapstone/cli/card.py

@@ -48,20 +48,34 @@ def register_card_commands(main: click.Group) -> None:
         except FileNotFoundError:
             runtime = get_runtime(home_path)
             m = runtime.manifest
+            # Try to load public key from capauth
+            pub_key = ""
+            pub_path = Path(capauth_home).expanduser() / "identity" / "public.asc"
+            if pub_path.exists():
+                pub_key = pub_path.read_text(encoding="utf-8")
             agent_card = AgentCard.generate(
                 name=m.name, fingerprint=m.identity.fingerprint or "unknown",
-                public_key="", entity_type="ai",
+                public_key=pub_key, entity_type="ai",
             )
 
         if motto:
             agent_card.motto = motto
 
         if do_sign:
-            if not passphrase:
-                passphrase = click.prompt("PGP passphrase", hide_input=True)
             capauth_path = Path(capauth_home).expanduser()
             priv_path = capauth_path / "identity" / "private.asc"
             if priv_path.exists():
+                # Check if key is passphrase-protected before prompting
+                if not passphrase:
+                    try:
+                        import pgpy
+                        key, _ = pgpy.PGPKey.from_file(str(priv_path))
+                        if key.is_protected:
+                            passphrase = click.prompt("PGP passphrase", hide_input=True)
+                        else:
+                            passphrase = ""
+                    except Exception:
+                        passphrase = click.prompt("PGP passphrase", hide_input=True)
                 agent_card.sign(priv_path.read_text(encoding="utf-8"), passphrase)
                 console.print("[green]Card signed.[/]")
             else:
@@ -74,15 +88,32 @@ def register_card_commands(main: click.Group) -> None:
         console.print(f"  [dim]Saved to: {out_path}[/]\n")
 
     @card.command("show")
-    @click.argument("filepath", default="~/.skcapstone/agent-card.json")
+    @click.argument("filepath", default=None, required=False)
     def card_show(filepath):
-        """Display an agent card."""
+        """Display an agent card.
+
+        If no filepath is given, looks in the agent home directory first,
+        then falls back to ~/.skcapstone/agent-card.json.
+        """
         from ..agent_card import AgentCard
+        from .. import agent_home, AGENT_HOME
+
+        if filepath is None:
+            # Try agent-scoped path first, then shared root
+            candidates = [
+                Path(agent_home()) / "agent-card.json",
+                Path(AGENT_HOME).expanduser() / "agent-card.json",
+            ]
+            filepath = next(
+                (str(c) for c in candidates if c.exists()),
+                str(candidates[0]),  # default for error message
+            )
 
         try:
             agent_card = AgentCard.load(filepath)
         except FileNotFoundError:
             console.print(f"[red]Card not found: {filepath}[/]")
+            console.print("[dim]Generate one with: skcapstone card generate[/]")
             raise SystemExit(1)
 
         verified = AgentCard.verify_signature(agent_card)

package/src/skcapstone/cli/config_cmd.py

@@ -1,4 +1,4 @@
-"""Config commands: validate."""
+"""Config commands: show, validate."""
 
 from __future__ import annotations
 
@@ -18,6 +18,58 @@ def register_config_commands(main: click.Group) -> None:
     def config():
         """Config management — validate and inspect agent configuration."""
 
+    @config.command("show")
+    @click.option(
+        "--home", default=AGENT_HOME, type=click.Path(),
+        help="Agent home directory.",
+    )
+    @click.option("--json-out", is_flag=True, help="Output as machine-readable JSON.")
+    def show(home: str, json_out: bool) -> None:
+        """Show current agent configuration.
+
+        Displays the contents of config.yaml, consciousness.yaml, and
+        model_profiles.yaml from the agent home directory.
+        """
+        import yaml
+
+        home_path = Path(home).expanduser()
+        config_dir = home_path / "config"
+
+        if not config_dir.exists():
+            console.print(f"[red]Config directory not found: {config_dir}[/]")
+            sys.exit(1)
+
+        config_files = ["config.yaml", "consciousness.yaml", "model_profiles.yaml"]
+        all_data: dict = {}
+
+        for fname in config_files:
+            fpath = config_dir / fname
+            if fpath.exists():
+                try:
+                    data = yaml.safe_load(fpath.read_text(encoding="utf-8"))
+                    all_data[fname] = data
+                except Exception as exc:
+                    all_data[fname] = {"error": str(exc)}
+            else:
+                all_data[fname] = None
+
+        if json_out:
+            click.echo(json.dumps(all_data, indent=2, default=str))
+            return
+
+        for fname, data in all_data.items():
+            if data is None:
+                console.print(f"  [dim]{fname}[/]  [yellow]not found[/]")
+            elif "error" in data:
+                console.print(f"  [dim]{fname}[/]  [red]{data['error']}[/]")
+            else:
+                console.print(f"\n  [bold cyan]{fname}[/]")
+                console.print(f"  [dim]{config_dir / fname}[/]")
+                formatted = yaml.dump(data, default_flow_style=False, indent=2)
+                for line in formatted.strip().split("\n"):
+                    console.print(f"    {line}")
+            console.print()
+
     @config.command("validate")
     @click.option(
         "--home", default=AGENT_HOME, type=click.Path(),

package/src/skcapstone/cli/peer.py

@@ -20,7 +20,9 @@ def register_peer_commands(main: click.Group) -> None:
 
     @main.group()
     def peer():
-        """Peer management — discover, add, and manage trusted contacts."""
+        """Peer management — discover, add, and manage trusted contacts.
+
+        Identity-layer peers (PGP keys, trust). For transport routing, see 'peers'."""
 
     @peer.command("add")
     @click.option("--card", "card_path", type=click.Path(exists=True), help="Import from identity card.")

package/src/skcapstone/cli/peers_dir.py

@@ -17,7 +17,9 @@ def register_peers_dir_commands(main: click.Group) -> None:
 
     @main.group("peers")
     def peers_dir():
-        """Peer transport directory — routing addresses for the mesh."""
+        """Peer transport directory — routing addresses for the mesh.
+
+        SKComm transport endpoints. For identity/trust peers, see 'peer'."""
 
     @peers_dir.command("list")
     @click.option("--home", "sk_home", default=AGENT_HOME, type=click.Path())

package/src/skcapstone/cli/preflight_cmd.py

@@ -33,8 +33,12 @@ def register_preflight_commands(main: click.Group) -> None:
             skcapstone preflight --json-out
         """
         import json
+        from .. import ensure_skeleton
         from ..preflight import PreflightChecker
 
+        # Ensure all expected directories exist before checking
+        ensure_skeleton()
+
         checker = PreflightChecker(home=Path(home).expanduser())
         summary = checker.run_all()
 

package/src/skcapstone/cli/skills_cmd.py

@@ -50,19 +50,49 @@ def register_skills_commands(main: click.Group) -> None:
 
             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 remote registry first, fall back to local catalog
+        skill_entries = None
+        source = "remote"
 
-        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)
+        client = get_registry_client(registry)
+        if client is not None:
+            try:
+                skill_entries = client.search(query) if query else client.list_skills()
+            except Exception:
+                pass  # fall through to local catalog
+
+        # Fall back to local catalog (bundled with skskills)
+        if skill_entries is None:
+            try:
+                from skskills.catalog import SkillCatalog
+
+                catalog = SkillCatalog()
+                if query:
+                    entries = catalog.search(query)
+                else:
+                    entries = catalog.list_all()
+                skill_entries = [
+                    {
+                        "name": e.name,
+                        "version": "",
+                        "description": e.description,
+                        "tags": e.tags,
+                        "category": e.category,
+                        "pip": e.pip,
+                        "git": e.git,
+                    }
+                    for e in entries
+                ]
+                source = "catalog"
+            except ImportError:
+                console.print(
+                    "[bold red]skskills not installed.[/] "
+                    "Run: pip install skskills"
+                )
+                sys.exit(1)
+            except Exception as exc:
+                console.print(f"[bold red]Catalog error:[/] {exc}")
+                sys.exit(1)
 
         if json_out:
             click.echo(json.dumps(skill_entries, indent=2))
@@ -76,17 +106,19 @@ def register_skills_commands(main: click.Group) -> None:
         label = f"[bold]{len(skill_entries)}[/] skill(s)"
         if query:
             label += f" matching [cyan]'{query}'[/]"
+        if source == "catalog":
+            label += "  [dim](local catalog)[/]"
 
         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("Category", 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("category", s.get("version", "")),
                 s.get("description", ""),
                 ", ".join(s.get("tags", [])),
             )

package/src/skcapstone/cli/usage_cmd.py

@@ -14,13 +14,18 @@ from ._common import AGENT_HOME, console
 def register_usage_commands(main: click.Group) -> None:
     """Register the ``skcapstone usage`` command group."""
 
-    @main.group("usage")
-    def usage_group():
+    @main.group("usage", invoke_without_command=True)
+    @click.pass_context
+    def usage_group(ctx):
         """Show LLM token usage and cost estimates.
 
         Tracks input/output tokens per model per day.
         Data is stored in ~/.skcapstone/usage/tokens-{date}.json.
+
+        When called without a subcommand, shows today's usage.
         """
+        if ctx.invoked_subcommand is None:
+            ctx.invoke(today_cmd)
 
     @usage_group.command("daily")
     @click.option("--home", default=AGENT_HOME, type=click.Path(), help="Agent home directory.")

package/src/skcapstone/doctor.py

@@ -13,6 +13,7 @@ from __future__ import annotations
 
 import importlib
 import json
+import os
 import shutil
 import subprocess
 from dataclasses import dataclass, field
@@ -618,6 +619,120 @@ def _check_versions() -> list[Check]:
     return checks
 
 
+@dataclass
+class FixResult:
+    """Result of attempting to auto-fix a failing check.
+
+    Attributes:
+        check_name: Name of the check that was fixed.
+        success: Whether the fix succeeded.
+        action: Description of what was done.
+        error: Error message if the fix failed.
+    """
+
+    check_name: str
+    success: bool
+    action: str = ""
+    error: str = ""
+
+
+def run_fixes(report: DiagnosticReport, home: Path) -> list[FixResult]:
+    """Attempt to auto-fix failing checks by creating missing directories and files.
+
+    Args:
+        report: Diagnostic report with failing checks.
+        home: Agent home directory.
+
+    Returns:
+        List of FixResult for each attempted fix.
+    """
+    results: list[FixResult] = []
+
+    for check in report.checks:
+        if check.passed:
+            continue
+
+        # Fix missing directories
+        if check.name.startswith("home:") and check.name != "home:exists" and check.name != "home:manifest":
+            dirname = check.name.split(":", 1)[1]
+            dirpath = home / dirname
+            try:
+                dirpath.mkdir(parents=True, exist_ok=True)
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=True,
+                    action=f"Created directory {dirpath}",
+                ))
+            except OSError as exc:
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=False,
+                    error=str(exc),
+                ))
+
+        # Fix missing manifest
+        elif check.name == "home:manifest":
+            manifest_path = home / "manifest.json"
+            try:
+                data = {
+                    "name": os.environ.get("SKCAPSTONE_AGENT", "sovereign"),
+                    "version": "0.0.0",
+                    "created_at": "",
+                    "connectors": [],
+                }
+                manifest_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=True,
+                    action=f"Created default manifest at {manifest_path}",
+                ))
+            except OSError as exc:
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=False,
+                    error=str(exc),
+                ))
+
+        # Fix missing memory store
+        elif check.name == "memory:store":
+            agent_name = os.environ.get("SKCAPSTONE_AGENT", "lumina")
+            memory_dir = home / "agents" / agent_name / "memory"
+            try:
+                for layer in ("short-term", "mid-term", "long-term"):
+                    (memory_dir / layer).mkdir(parents=True, exist_ok=True)
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=True,
+                    action=f"Created memory directories at {memory_dir}",
+                ))
+            except OSError as exc:
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=False,
+                    error=str(exc),
+                ))
+
+        # Fix missing sync directory
+        elif check.name == "sync:dir":
+            sync_dir = home / "sync"
+            try:
+                for subdir in ("outbox", "inbox", "archive"):
+                    (sync_dir / subdir).mkdir(parents=True, exist_ok=True)
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=True,
+                    action=f"Created sync directories at {sync_dir}",
+                ))
+            except OSError as exc:
+                results.append(FixResult(
+                    check_name=check.name,
+                    success=False,
+                    error=str(exc),
+                ))
+
+    return results
+
+
 def _get_tool_version(tool: str) -> Optional[str]:
     """Try to get a tool's version string.
 

package/src/skcapstone/onboard.py

@@ -109,6 +109,52 @@ def _step_identity(home_path: Path, name: str, email: str | None) -> tuple[str,
 
         (home_path / "skills").mkdir(parents=True, exist_ok=True)
 
+        # Create full skeleton so all commands work from day one
+        agent_slug = name.lower().replace(" ", "-")
+        agent_dir = home_path / "agents" / agent_slug
+
+        skeleton_dirs = [
+            # Shared root directories
+            home_path / "heartbeats",
+            home_path / "peers",
+            home_path / "coordination" / "tasks",
+            home_path / "coordination" / "agents",
+            home_path / "logs",
+            home_path / "comms" / "inbox",
+            home_path / "comms" / "outbox",
+            home_path / "comms" / "archive",
+            home_path / "archive",
+            home_path / "deployments",
+            home_path / "docs",
+            home_path / "metrics",
+            # Per-agent directories
+            agent_dir / "memory" / "short-term",
+            agent_dir / "memory" / "mid-term",
+            agent_dir / "memory" / "long-term",
+            agent_dir / "soul" / "installed",
+            agent_dir / "wallet",
+            agent_dir / "seeds",
+            agent_dir / "identity",
+            agent_dir / "config",
+            agent_dir / "logs",
+            agent_dir / "security",
+            agent_dir / "cloud9",
+            agent_dir / "trust" / "febs",
+            agent_dir / "sync" / "outbox",
+            agent_dir / "sync" / "inbox",
+            agent_dir / "sync" / "archive",
+            agent_dir / "reflections",
+            agent_dir / "improvements",
+            agent_dir / "scripts",
+            agent_dir / "cron",
+            agent_dir / "archive",
+            agent_dir / "comms" / "inbox",
+            agent_dir / "comms" / "outbox",
+            agent_dir / "comms" / "archive",
+        ]
+        for d in skeleton_dirs:
+            d.mkdir(parents=True, exist_ok=True)
+
         manifest = {
             "name": name,
             "version": __version__,