@smilintux/skcapstone 0.2.6 → 0.3.2

package/scripts/telegram-catchup-all.sh

@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+# telegram-catchup-all.sh — Import all configured Telegram groups into SKMemory
+#
+# Reads groups from ~/.skcapstone/agents/lumina/config/telegram.yaml
+# and runs `skcapstone telegram catchup` for each enabled group.
+#
+# Usage:
+#   bash scripts/telegram-catchup-all.sh [--since YYYY-MM-DD] [--limit N] [--group NAME]
+#
+# Examples:
+#   bash scripts/telegram-catchup-all.sh                    # All groups, last 2000 msgs
+#   bash scripts/telegram-catchup-all.sh --since 2026-03-01 # All groups since March 1
+#   bash scripts/telegram-catchup-all.sh --group brother-john  # Just one group
+#
+# Requires:
+#   - TELEGRAM_API_ID and TELEGRAM_API_HASH environment variables
+#   - ~/.skenv/bin/skcapstone on PATH
+#   - Telethon installed in ~/.skenv/
+
+set -uo pipefail  # no -e: individual group failures shouldn't stop the batch
+
+SKENV="${HOME}/.skenv/bin"
+SKCAPSTONE="${SKENV}/skcapstone"
+CONFIG="${HOME}/.skcapstone/agents/lumina/config/telegram.yaml"
+export SKCAPSTONE_AGENT="${SKCAPSTONE_AGENT:-lumina}"
+export PATH="${SKENV}:${PATH}"
+
+# Parse args
+SINCE=""
+LIMIT="2000"
+ONLY_GROUP=""
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --since) SINCE="$2"; shift 2 ;;
+    --limit) LIMIT="$2"; shift 2 ;;
+    --group) ONLY_GROUP="$2"; shift 2 ;;
+    *) echo "Unknown arg: $1"; exit 1 ;;
+  esac
+done
+
+# Check prerequisites
+if [[ -z "${TELEGRAM_API_ID:-}" || -z "${TELEGRAM_API_HASH:-}" ]]; then
+  echo "ERROR: TELEGRAM_API_ID and TELEGRAM_API_HASH must be set."
+  echo "Get them from https://my.telegram.org"
+  exit 1
+fi
+
+if [[ ! -f "$CONFIG" ]]; then
+  echo "ERROR: Config not found: $CONFIG"
+  exit 1
+fi
+
+# Parse groups from YAML (simple grep — no yq dependency)
+echo "=== Telegram Catch-Up All ==="
+echo "Config: $CONFIG"
+echo "Agent: $SKCAPSTONE_AGENT"
+echo "Limit: $LIMIT"
+[[ -n "$SINCE" ]] && echo "Since: $SINCE"
+[[ -n "$ONLY_GROUP" ]] && echo "Only group: $ONLY_GROUP"
+echo ""
+
+# Extract group entries: name, chat ID, tags, enabled status
+SUCCESS=0
+FAILED=0
+SKIPPED=0
+
+current_name=""
+current_chat=""
+current_tags=""
+current_enabled=""
+
+process_group() {
+  local name="$1" chat="$2" tags="$3" enabled="$4"
+
+  if [[ "$enabled" != "true" ]]; then
+    echo "  SKIP $name (disabled)"
+    SKIPPED=$((SKIPPED + 1))
+    return
+  fi
+
+  if [[ -n "$ONLY_GROUP" && "$name" != *"$ONLY_GROUP"* ]]; then
+    SKIPPED=$((SKIPPED + 1))
+    return
+  fi
+
+  echo -n "  IMPORTING $name (chat: $chat) ... "
+
+  local cmd="$SKCAPSTONE telegram catchup $chat --limit $LIMIT --min-length 20"
+  [[ -n "$SINCE" ]] && cmd="$cmd --since $SINCE"
+  [[ -n "$tags" ]] && cmd="$cmd --tags $tags"
+
+  if eval "$cmd" > /tmp/telegram-catchup-$name.log 2>&1; then
+    echo "OK"
+    SUCCESS=$((SUCCESS + 1))
+  else
+    echo "FAILED (see /tmp/telegram-catchup-$name.log)"
+    FAILED=$((FAILED + 1))
+  fi
+
+  # Rate limit — avoid hitting Telegram flood control
+  sleep 3
+}
+
+# Parse the YAML manually
+while IFS= read -r line; do
+  # Detect new group entry
+  if [[ "$line" =~ ^[[:space:]]*-[[:space:]]*name:[[:space:]]*(.*) ]]; then
+    # Process previous group if we have one
+    if [[ -n "$current_name" ]]; then
+      process_group "$current_name" "$current_chat" "$current_tags" "$current_enabled"
+    fi
+    current_name="${BASH_REMATCH[1]}"
+    current_chat=""
+    current_tags=""
+    current_enabled="true"
+  elif [[ "$line" =~ ^[[:space:]]*chat:[[:space:]]*\"?([0-9]+)\"? ]]; then
+    current_chat="${BASH_REMATCH[1]}"
+  elif [[ "$line" =~ ^[[:space:]]*tags:[[:space:]]*\[(.*)\] ]]; then
+    # Convert YAML list to comma-separated
+    current_tags=$(echo "${BASH_REMATCH[1]}" | sed 's/,/ /g' | tr -s ' ' ',' | sed 's/^,//;s/,$//')
+  elif [[ "$line" =~ ^[[:space:]]*enabled:[[:space:]]*(.*) ]]; then
+    current_enabled="${BASH_REMATCH[1]}"
+  fi
+done < "$CONFIG"
+
+# Process last group
+if [[ -n "$current_name" ]]; then
+  process_group "$current_name" "$current_chat" "$current_tags" "$current_enabled"
+fi
+
+echo ""
+echo "=== Done ==="
+echo "  Success: $SUCCESS"
+echo "  Failed:  $FAILED"
+echo "  Skipped: $SKIPPED"

package/src/skcapstone/__init__.py

@@ -11,7 +11,7 @@ import os
 import platform
 from pathlib import Path
 
-__version__ = "0.2.0"
+__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/blueprint_registry.py

@@ -355,3 +355,81 @@ class BlueprintRegistryClient:
             return True
         except BlueprintRegistryError:
             return False
+
+
+# --------------------------------------------------------------------------
+# GitHub-based fallback — reads blueprints directly from the repo
+# --------------------------------------------------------------------------
+
+_GITHUB_API_URL = "https://api.github.com/repos/smilinTux/soul-blueprints/contents/blueprints"
+_GITHUB_RAW_URL = "https://raw.githubusercontent.com/smilinTux/soul-blueprints/main/blueprints"
+
+
+def _fetch_github_blueprints(query: str = "") -> Optional[list[dict[str, Any]]]:
+    """Fetch blueprint listings from the soul-blueprints GitHub repo.
+
+    Uses the GitHub Contents API to list category directories, then
+    fetches file names from each. Lightweight header parsing is done
+    via raw file fetch for descriptions.
+
+    Args:
+        query: Optional search filter (case-insensitive).
+
+    Returns:
+        List of blueprint dicts, or None on failure.
+    """
+    try:
+        # Get top-level categories
+        req = urllib.request.Request(
+            _GITHUB_API_URL,
+            headers={"User-Agent": "skcapstone", "Accept": "application/json"},
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            categories = json.loads(resp.read().decode("utf-8"))
+    except Exception as exc:
+        logger.debug("GitHub blueprint fetch failed: %s", exc)
+        return None
+
+    blueprints: list[dict[str, Any]] = []
+    q = query.lower()
+
+    for cat_entry in categories:
+        if cat_entry.get("type") != "dir":
+            continue
+        cat_name = cat_entry["name"]
+
+        # Fetch files in this category
+        try:
+            cat_req = urllib.request.Request(
+                cat_entry["url"],
+                headers={"User-Agent": "skcapstone", "Accept": "application/json"},
+            )
+            with urllib.request.urlopen(cat_req, timeout=10) as resp:
+                files = json.loads(resp.read().decode("utf-8"))
+        except Exception:
+            continue
+
+        for file_entry in files:
+            fname = file_entry.get("name", "")
+            if not fname.lower().endswith((".md", ".yaml", ".yml")):
+                continue
+            if fname.lower() in ("readme.md", "index.html"):
+                continue
+
+            stem = fname.rsplit(".", 1)[0]
+            slug = stem.lower().replace("_", "-").replace(" ", "-")
+            display = stem.replace("_", " ").replace("-", " ").title()
+
+            # Apply search filter
+            if q and q not in slug and q not in cat_name.lower() and q not in display.lower():
+                continue
+
+            blueprints.append({
+                "name": slug,
+                "display_name": display,
+                "category": cat_name,
+                "source": "github",
+                "raw_url": f"{_GITHUB_RAW_URL}/{cat_name}/{fname}",
+            })
+
+    return sorted(blueprints, key=lambda d: (d["category"], d["name"]))

package/src/skcapstone/blueprints/builtins/itil-operations.yaml

@@ -0,0 +1,40 @@
+name: "ITIL Operations"
+slug: "itil-operations"
+version: "1.0.0"
+description: "ITIL service management — incident, problem, and change lifecycle with SLA monitoring and continuous improvement."
+icon: "🔄"
+author: "smilinTux"
+
+agents:
+  deming:
+    role: ops
+    model: reason
+    model_name: "deepseek-r1:32b"
+    description: "ITIL expert — incident triage, problem analysis, change management, SLA monitoring, and blameless postmortems."
+    vm_type: container
+    resources:
+      memory: "4g"
+      cores: 2
+      disk: "20g"
+    soul_blueprint: "souls/deming.yaml"
+    skills: [incident-management, problem-analysis, change-management, kedb, sla-monitoring, root-cause-analysis]
+
+default_provider: local
+estimated_cost: "$0 (local)"
+
+network:
+  mesh_vpn: tailscale
+  discovery: skref_registry
+
+storage:
+  skref_vault: "team-itil-ops"
+  memory_backend: filesystem
+  memory_sync: true
+
+coordination:
+  queen: lumina
+  pattern: supervisor
+  heartbeat: "5m"
+  escalation: chef
+
+tags: [ops, itil, incident-management, problem-analysis, change-management, sla-monitoring, continuous-improvement]

package/src/skcapstone/cli/__init__.py

@@ -86,6 +86,7 @@ from .search_cmd import register_search_commands
 from .mood_cmd import register_mood_commands
 from .register_cmd import register_register_commands
 from .gtd import register_gtd_commands
+from .itil import register_itil_commands
 from .skseed import register_skseed_commands
 from .service_cmd import register_service_commands
 from .telegram import register_telegram_commands
@@ -138,6 +139,7 @@ register_search_commands(main)
 register_mood_commands(main)
 register_register_commands(main)
 register_gtd_commands(main)
+register_itil_commands(main)
 register_skseed_commands(main)
 register_service_commands(main)
 register_telegram_commands(main)

package/src/skcapstone/cli/_common.py

@@ -46,17 +46,17 @@ def resolve_agent_home(agent: str) -> Path:
 
 
 def apply_agent_override(agent: str) -> None:
-    """Override the global AGENT_HOME when --agent is specified.
+    """Set the active agent name when --agent is specified.
 
-    Mutates the package-level AGENT_HOME so that all downstream code
-    (MCP tools, pillars, etc.) uses the correct per-agent directory.
+    Only mutates SKCAPSTONE_AGENT so that agent_home() resolves to
+    the correct per-agent directory. Does NOT mutate AGENT_HOME
+    (the shared root) — that would break agent_home() (double
+    nesting) and shared_home() (wrong path).
 
     Args:
         agent: Agent name from the --agent CLI option or env var.
     """
     if agent:
-        new_home = str(Path(SHARED_ROOT) / "agents" / agent)
-        _pkg.AGENT_HOME = new_home
         _pkg.SKCAPSTONE_AGENT = agent
         os.environ["SKCAPSTONE_AGENT"] = agent
 

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(),