soothe-cli 0.1.0__py3-none-any.whl

soothe_cli/tui/skills/__init__.py

@@ -0,0 +1,5 @@
+"""Skills discovery and invocation for TUI (stub from deepagents-cli migration).
+
+This module provides skill discovery and invocation functionality for the TUI.
+Full implementation should integrate with Soothe skills system.
+"""

soothe_cli/tui/skills/invocation.py

@@ -0,0 +1,74 @@
+"""Skills discovery and invocation helpers for the Soothe Textual TUI."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections import OrderedDict
+from typing import TYPE_CHECKING
+
+from soothe_sdk.client import fetch_skills_catalog, websocket_url_from_config
+
+from soothe_cli.tui.skills.load import ExtendedSkillMetadata
+
+if TYPE_CHECKING:
+    from soothe_cli.config.cli_config import CLIConfig
+
+logger = logging.getLogger(__name__)
+
+
+async def discover_skills_async(
+    daemon_config: CLIConfig | None = None,
+) -> list[ExtendedSkillMetadata]:
+    """Discover skills from daemon RPC (IG-174 Phase 2).
+
+    Fetches wire-safe skill metadata from daemon via WebSocket RPC.
+    Daemon handles all skill discovery (built-in, user, project, etc.)
+    and returns wire-safe metadata. No local filesystem access.
+
+    Args:
+        daemon_config: Daemon config for WebSocket URL construction.
+
+    Returns:
+        List of skill metadata dicts sorted by ascending precedence
+        (built-in first, winning entry last). Empty list if daemon
+        unavailable.
+    """
+    from soothe_sdk.client import WebSocketClient
+
+    if daemon_config is None:
+        logger.warning("No daemon_config provided for skills discovery; returning empty catalog")
+        return []
+
+    ws_url = websocket_url_from_config(daemon_config)
+    client = WebSocketClient(url=ws_url)
+
+    by_name: OrderedDict[str, ExtendedSkillMetadata] = OrderedDict()
+
+    try:
+        await client.connect()
+        skills_wire = await fetch_skills_catalog(client, timeout=15.0)
+        await client.close()
+
+        # Build by_name mapping from wire-safe metadata
+        for skill_meta in skills_wire:
+            name = skill_meta.get("name")
+            if name:
+                by_name[name] = skill_meta
+    except Exception as e:
+        logger.warning(f"Failed to fetch skills from daemon: {e}")
+        return []
+
+    return list(by_name.values())
+
+
+def discover_skills(
+    daemon_config: CLIConfig | None = None,
+) -> list[ExtendedSkillMetadata]:
+    """Backward-compatible sync wrapper for async skills discovery."""
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(discover_skills_async(daemon_config=daemon_config))
+    msg = "discover_skills() cannot be called from a running event loop; use discover_skills_async() instead."
+    raise RuntimeError(msg)

soothe_cli/tui/skills/load.py

@@ -0,0 +1,93 @@
+"""Skills loading utilities for the Soothe Textual TUI."""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Sequence
+from pathlib import Path
+from typing import TypedDict
+
+logger = logging.getLogger(__name__)
+
+
+class ExtendedSkillMetadata(TypedDict):
+    """Wire-safe skill metadata from daemon RPC (IG-174 Phase 2).
+
+    This TypedDict represents skill metadata fetched from daemon via WebSocket RPC.
+    All fields are wire-safe (no Path objects, use str representations).
+    """
+
+    name: str
+    description: str
+    source: str  # "builtin", "user", "project", "agents", "claude"
+    path: str | None  # Wire-safe path representation (not Path object)
+    tags: list[str]
+    tools: list[str] | None
+    default_model: str | None
+    requires: list[str] | None
+
+
+def _is_under_allowed_roots(target: Path, roots: Sequence[Path]) -> bool:
+    """Return True if `target` is equal to or nested under one of `roots`."""
+    t = target.resolve()
+    for root in roots:
+        try:
+            t.relative_to(root.resolve())
+        except ValueError:
+            continue
+        else:
+            return True
+    return False
+
+
+def load_skill_content(
+    skill_path: str | Path, *, allowed_roots: Sequence[Path] | None = None
+) -> str | None:
+    """Read `SKILL.md` for a skill directory with optional path containment checks.
+
+    Args:
+        skill_path: Path to the skill directory **or** to a `SKILL.md` file.
+        allowed_roots: Resolved directories that may contain the target file.
+            When empty or ``None``, any resolved path is accepted (tests only —
+            production callers should pass roots from daemon RPC).
+
+    Returns:
+        File contents as a string, or ``None`` only when the file is missing.
+
+    Raises:
+        PermissionError: When ``allowed_roots`` is non-empty and the resolved
+            `SKILL.md` path lies outside every allowed root.
+        OSError: Propagated from the filesystem when the file cannot be read.
+    """
+    raw = Path(skill_path)
+    skill_md = raw / "SKILL.md" if raw.is_dir() else raw
+    resolved_md = skill_md.resolve()
+
+    if allowed_roots:
+        roots = [Path(r).resolve() for r in allowed_roots]
+        if roots and not _is_under_allowed_roots(resolved_md, roots):
+            msg = f"Refusing to read skill file outside allowed directories: {resolved_md}"
+            raise PermissionError(msg)
+
+    if not resolved_md.is_file():
+        return None
+
+    return resolved_md.read_text(encoding="utf-8")
+
+
+def strip_skill_frontmatter(content: str) -> str:
+    """Remove optional YAML frontmatter from SKILL markdown content."""
+    if not content.startswith("---\n"):
+        return content
+    end = content.find("\n---\n", 4)
+    if end == -1:
+        return content
+    return content[end + 5 :]
+
+
+# Re-export for callers that import from this module
+__all__ = [
+    "ExtendedSkillMetadata",
+    "load_skill_content",
+    "strip_skill_frontmatter",
+]