@smilintux/skcapstone 0.4.5 → 0.9.0

package/src/skcapstone/cli/skills_cmd.py

@@ -3,9 +3,13 @@
 from __future__ import annotations
 
 import json
+import logging
 import sys
+import urllib.request
+from typing import Optional
 
 import click
+import yaml
 
 from ._common import AGENT_HOME, console
 from ..registry_client import get_registry_client
@@ -13,18 +17,65 @@ from ..registry_client import get_registry_client
 from rich.panel import Panel
 from rich.table import Table
 
+logger = logging.getLogger(__name__)
+
+# Raw catalog.yaml from the skskills GitHub repo (always fresh)
+_GITHUB_CATALOG_URL = (
+    "https://raw.githubusercontent.com/smilinTux/skskills/main/catalog.yaml"
+)
+
+
+def _fetch_github_catalog(query: str = "") -> Optional[list[dict]]:
+    """Fetch catalog.yaml from the skskills GitHub repo.
+
+    Returns:
+        List of skill entry dicts, or None on failure.
+    """
+    try:
+        req = urllib.request.Request(_GITHUB_CATALOG_URL, headers={"User-Agent": "skcapstone"})
+        with urllib.request.urlopen(req, timeout=5) as resp:
+            raw = yaml.safe_load(resp.read().decode("utf-8"))
+    except Exception as exc:
+        logger.debug("GitHub catalog fetch failed: %s", exc)
+        return None
+
+    entries = []
+    q = query.lower()
+    for item in raw.get("skills", []):
+        name = item.get("name", "")
+        desc = item.get("description", "").strip()
+        tags = item.get("tags", [])
+
+        if q and not (
+            q in name.lower()
+            or q in desc.lower()
+            or any(q in t.lower() for t in tags)
+        ):
+            continue
+
+        entries.append({
+            "name": name,
+            "description": desc,
+            "tags": tags,
+            "category": item.get("category", ""),
+            "pip": item.get("pip", ""),
+            "git": item.get("git", ""),
+        })
+
+    return entries
+
 
 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.
+        """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.
+        Fetches the latest skill catalog from GitHub. Falls back to the
+        locally installed catalog if offline.
 
-        Set SKSKILLS_REGISTRY_URL to override the default registry.
+        Set SKSKILLS_REGISTRY_URL to override with a custom registry server.
         """
 
     @skills.command("list")
@@ -36,11 +87,12 @@ def register_skills_commands(main: click.Group) -> None:
         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.
+    @click.option("--offline", is_flag=True, help="Use local catalog only (no network).")
+    def skills_list(query: str, registry: str | None, json_out: bool, offline: bool) -> None:
+        """List skills available in the catalog.
 
-        Without --query all skills are shown. With --query only skills
-        matching the name, description, or tags are returned.
+        Pulls the latest catalog from the skskills GitHub repo.
+        Falls back to local catalog if offline or fetch fails.
 
         Examples:
 
@@ -49,19 +101,28 @@ def register_skills_commands(main: click.Group) -> None:
             skcapstone skills list --query syncthing
 
             skcapstone skills list --query identity --json
+
+            skcapstone skills list --offline
         """
-        # Try remote registry first, fall back to local catalog
         skill_entries = None
-        source = "remote"
-
-        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)
+        source = "github"
+
+        # 1. Try custom registry server if configured
+        if registry:
+            client = get_registry_client(registry)
+            if client is not None:
+                try:
+                    skill_entries = client.search(query) if query else client.list_skills()
+                    source = "remote"
+                except Exception:
+                    pass
+
+        # 2. Try GitHub raw catalog (always fresh, no server needed)
+        if skill_entries is None and not offline:
+            skill_entries = _fetch_github_catalog(query)
+            source = "github"
+
+        # 3. Fall back to local catalog (bundled with skskills package)
         if skill_entries is None:
             try:
                 from skskills.catalog import SkillCatalog
@@ -74,7 +135,6 @@ def register_skills_commands(main: click.Group) -> None:
                 skill_entries = [
                     {
                         "name": e.name,
-                        "version": "",
                         "description": e.description,
                         "tags": e.tags,
                         "category": e.category,
@@ -83,10 +143,10 @@ def register_skills_commands(main: click.Group) -> None:
                     }
                     for e in entries
                 ]
-                source = "catalog"
+                source = "local"
             except ImportError:
                 console.print(
-                    "[bold red]skskills not installed.[/] "
+                    "[bold red]skskills not installed and GitHub unreachable.[/] "
                     "Run: pip install skskills"
                 )
                 sys.exit(1)
@@ -103,11 +163,15 @@ def register_skills_commands(main: click.Group) -> None:
             console.print(f"\n  [dim]No skills found{suffix}.[/]\n")
             return
 
+        source_labels = {
+            "github": "",
+            "remote": "  [dim](registry)[/]",
+            "local": "  [dim](local — offline)[/]",
+        }
         label = f"[bold]{len(skill_entries)}[/] skill(s)"
         if query:
             label += f" matching [cyan]'{query}'[/]"
-        if source == "catalog":
-            label += "  [dim](local catalog)[/]"
+        label += source_labels.get(source, "")
 
         table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
         table.add_column("Name", style="cyan")
@@ -118,13 +182,13 @@ def register_skills_commands(main: click.Group) -> None:
         for s in skill_entries:
             table.add_row(
                 s.get("name", ""),
-                s.get("category", s.get("version", "")),
+                s.get("category", ""),
                 s.get("description", ""),
                 ", ".join(s.get("tags", [])),
             )
 
         console.print()
-        console.print(Panel(label, title="Skills Registry", border_style="bright_blue"))
+        console.print(Panel(label, title="Skills Catalog", border_style="bright_blue"))
         console.print(table)
         console.print()
 

package/src/skcapstone/cli/soul.py

@@ -517,22 +517,36 @@ def register_soul_commands(main: click.Group) -> None:
     @soul_registry.command("list")
     @click.option("--url", default=None, help="Registry API base URL.")
     def registry_list(url):
-        """List all blueprints in the remote registry."""
-        from ..blueprint_registry import BlueprintRegistryClient, BlueprintRegistryError
+        """List all blueprints in the remote registry.
 
-        kwargs = {}
+        Pulls from the soul-blueprints GitHub repo. Falls back to
+        the souls.skworld.io API if --url is set.
+        """
+        from ..blueprint_registry import (
+            BlueprintRegistryClient,
+            BlueprintRegistryError,
+            _fetch_github_blueprints,
+        )
+
+        blueprints = None
+        source = "github"
+
+        # If custom URL, try the API server first
         if url:
-            kwargs["base_url"] = url
-        client = BlueprintRegistryClient(**kwargs)
+            try:
+                client = BlueprintRegistryClient(base_url=url)
+                blueprints = client.list_blueprints()
+                source = "registry"
+            except BlueprintRegistryError:
+                pass
 
-        try:
-            blueprints = client.list_blueprints()
-        except BlueprintRegistryError as e:
-            console.print(f"\n  [red]Registry error:[/] {e}\n")
-            sys.exit(1)
+        # Default: pull from GitHub repo
+        if blueprints is None:
+            blueprints = _fetch_github_blueprints()
+            source = "github"
 
         if not blueprints:
-            console.print("\n  [dim]No blueprints found in the registry.[/]\n")
+            console.print("\n  [dim]No blueprints found.[/]\n")
             return
 
         table = Table(show_header=True, header_style="bold", box=None, padding=(0, 2))
@@ -547,27 +561,38 @@ def register_soul_commands(main: click.Group) -> None:
                 bp.get("category", ""),
             )
 
+        source_label = "" if source == "github" else "  [dim](registry)[/]"
         console.print()
         console.print(table)
-        console.print(f"\n  [dim]{len(blueprints)} blueprint(s) in registry[/]\n")
+        console.print(f"\n  [dim]{len(blueprints)} blueprint(s){source_label}[/]\n")
 
     @soul_registry.command("search")
     @click.argument("query")
     @click.option("--url", default=None, help="Registry API base URL.")
     def registry_search(query, url):
-        """Search the remote registry for blueprints."""
-        from ..blueprint_registry import BlueprintRegistryClient, BlueprintRegistryError
+        """Search the remote registry for blueprints.
 
-        kwargs = {}
+        Searches the soul-blueprints GitHub repo by name and category.
+        """
+        from ..blueprint_registry import (
+            BlueprintRegistryClient,
+            BlueprintRegistryError,
+            _fetch_github_blueprints,
+        )
+
+        results = None
+
+        # If custom URL, try the API server first
         if url:
-            kwargs["base_url"] = url
-        client = BlueprintRegistryClient(**kwargs)
+            try:
+                client = BlueprintRegistryClient(base_url=url)
+                results = client.search_blueprints(query)
+            except BlueprintRegistryError:
+                pass
 
-        try:
-            results = client.search_blueprints(query)
-        except BlueprintRegistryError as e:
-            console.print(f"\n  [red]Registry error:[/] {e}\n")
-            sys.exit(1)
+        # Default: search GitHub repo
+        if results is None:
+            results = _fetch_github_blueprints(query)
 
         if not results:
             console.print(f"\n  [dim]No blueprints matching '{query}'.[/]\n")
@@ -577,14 +602,12 @@ def register_soul_commands(main: click.Group) -> None:
         table.add_column("Name", style="cyan", no_wrap=True)
         table.add_column("Display Name", style="bold")
         table.add_column("Category", style="yellow")
-        table.add_column("Vibe", style="dim")
 
         for bp in results:
             table.add_row(
                 bp.get("name", "?"),
                 bp.get("display_name", ""),
                 bp.get("category", ""),
-                (bp.get("vibe", "") or "")[:60],
             )
 
         console.print()

package/src/skcapstone/consciousness_config.py

@@ -117,3 +117,30 @@ def write_default_config(home: Path) -> Path:
     config_path.write_text(header + content, encoding="utf-8")
     logger.info("Wrote default consciousness config to %s", config_path)
     return config_path
+
+
+def load_dreaming_config(
+    home: Path,
+    config_path: Optional[Path] = None,
+):
+    """Load dreaming config from the consciousness.yaml ``dreaming:`` section.
+
+    Args:
+        home: Agent home directory.
+        config_path: Explicit path to config file (overrides default).
+
+    Returns:
+        DreamingConfig (defaults if section is missing or unparseable).
+    """
+    from .dreaming import DreamingConfig
+
+    yaml_path = config_path or (home / "config" / CONFIG_FILENAME)
+    if not yaml_path.exists():
+        return DreamingConfig()
+    try:
+        raw = yaml.safe_load(yaml_path.read_text(encoding="utf-8"))
+        if raw and isinstance(raw, dict) and "dreaming" in raw:
+            return DreamingConfig.model_validate(raw["dreaming"])
+    except Exception as exc:
+        logger.warning("Failed to parse dreaming config: %s", exc)
+    return DreamingConfig()

package/src/skcapstone/coordination.py

@@ -123,6 +123,7 @@ class AgentFile(BaseModel):
     claimed_tasks: list[str] = Field(default_factory=list)
     completed_tasks: list[str] = Field(default_factory=list)
     capabilities: list[str] = Field(default_factory=list)
+    itil_claims: list[str] = Field(default_factory=list)
     notes: str = ""
 
 

package/src/skcapstone/daemon.py

@@ -1145,16 +1145,35 @@ class DaemonService:
             logger.debug("Auto-journal write failed: %s", exc)
 
         try:
-            from .memory_engine import store as mem_store
-            mem_store(
-                self.config.home,
-                f"Received message from {sender}: {preview}",
-                tags=["skcomm-received"],
-                source="daemon",
-            )
-            logger.debug("Memory stored for incoming message from %s", sender)
+            self._store_skcomm_receipt(sender, preview)
+            logger.debug("SKComm receipt stored for incoming message from %s", sender)
         except Exception as exc:
-            logger.debug("Auto-journal memory store failed: %s", exc)
+            logger.debug("SKComm receipt store failed: %s", exc)
+
+    def _store_skcomm_receipt(self, sender: str, preview: str) -> None:
+        """Write a skcomm receipt to the skcomm/received/ directory.
+
+        These are transport bookkeeping, NOT persistent memories, so they
+        go to ``~/.skcapstone/agents/{agent}/skcomm/received/`` instead of
+        polluting the memory/ tree that skmemory indexes.
+        """
+        import json
+        import uuid
+        from datetime import datetime, timezone
+
+        agent_name = os.environ.get("SKCAPSTONE_AGENT", "lumina")
+        recv_dir = self.config.home / "agents" / agent_name / "skcomm" / "received"
+        recv_dir.mkdir(parents=True, exist_ok=True)
+
+        receipt_id = uuid.uuid4().hex[:12]
+        receipt = {
+            "id": receipt_id,
+            "sender": sender,
+            "preview": preview,
+            "received_at": datetime.now(timezone.utc).isoformat(),
+        }
+        path = recv_dir / f"{receipt_id}.json"
+        path.write_text(json.dumps(receipt, indent=2), encoding="utf-8")
 
     def _healing_loop(self) -> None:
         """Periodically run self-healing diagnostics (every 5 min)."""