painapple-code 1.0.0__py3-none-any.whl

painapple_code/routes/api_plugins.py

@@ -0,0 +1,275 @@
+"""Plugins Manager API.
+
+Endpoints for browsing the plugin marketplace and managing installed plugins.
+
+Backed by the `claude plugins` CLI:
+  claude plugins list --available --json   → { installed: [...], available: [...] }
+  claude plugins install <id>
+  claude plugins uninstall <id>
+  claude plugins enable <id>
+  claude plugins disable <id>
+
+Component inventory (skills/agents/commands/hooks) is computed by walking the
+marketplace directory on disk, since `claude plugins details` has no --json.
+"""
+from __future__ import annotations
+
+import asyncio
+import json
+import re
+from pathlib import Path
+from typing import Any, Optional
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+
+router = APIRouter(prefix="/api/plugins", tags=["plugins"])
+
+# Forbid a leading '-'/'.' so a plugin id can't smuggle a CLI option.
+PLUGIN_ID_RE = re.compile(r"^(?![-.])[a-zA-Z0-9_./-]+@[a-zA-Z0-9_./-]+$")
+CLI_TIMEOUT_SEC = 120  # install pulls from git; allow some slack
+
+
+# ---------- helpers ---------------------------------------------------------
+
+
+def _validate_plugin_id(plugin_id: str) -> None:
+    """Reject anything that isn't shaped like `<plugin>@<marketplace>`."""
+    if not PLUGIN_ID_RE.match(plugin_id):
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid plugin id {plugin_id!r}",
+        )
+
+
+async def _run_claude(*args: str) -> tuple[int, str, str]:
+    """Spawn `claude` with the given args; return (returncode, stdout, stderr)."""
+    try:
+        from painapple_code.utils.proc import resolve_binary
+        proc = await asyncio.create_subprocess_exec(
+            resolve_binary("claude"), *args,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        out, err = await asyncio.wait_for(
+            proc.communicate(), timeout=CLI_TIMEOUT_SEC
+        )
+    except asyncio.TimeoutError:
+        raise HTTPException(status_code=504, detail=f"claude plugins {args[0]} timed out")
+    except FileNotFoundError:
+        raise HTTPException(status_code=500, detail="`claude` CLI not on PATH")
+    return proc.returncode or 0, out.decode("utf-8", "replace"), err.decode("utf-8", "replace")
+
+
+def _plugin_dir(plugin_id: str) -> Optional[Path]:
+    """Return the marketplace directory for `<plugin>@<marketplace>`, or None."""
+    name, _, marketplace = plugin_id.partition("@")
+    if not name or not marketplace:
+        return None
+    candidate = (
+        Path.home() / ".claude" / "plugins" / "marketplaces"
+        / marketplace / "plugins" / name
+    )
+    return candidate if candidate.is_dir() else None
+
+
+def _component_inventory(plugin_dir: Path) -> dict[str, int]:
+    """Count plugin components by walking the on-disk plugin directory.
+
+    Mirrors how Claude Code itself discovers components — folder-form skills,
+    flat `.md` agents/commands, and a single `hooks.json` or `hooks/hooks.json`.
+    """
+    counts = {"skills": 0, "agents": 0, "commands": 0, "hooks": 0, "mcp_servers": 0}
+
+    skills_dir = plugin_dir / "skills"
+    if skills_dir.is_dir():
+        counts["skills"] = sum(
+            1 for d in skills_dir.iterdir()
+            if d.is_dir() and (d / "SKILL.md").is_file()
+        )
+
+    for kind, subdir, suffix in (
+        ("agents", "agents", ".md"),
+        ("commands", "commands", ".md"),
+    ):
+        d = plugin_dir / subdir
+        if d.is_dir():
+            counts[kind] = sum(
+                1 for f in d.iterdir()
+                if f.is_file() and f.suffix == suffix and not f.name.startswith(".")
+            )
+
+    for hooks_path in (plugin_dir / "hooks.json", plugin_dir / "hooks" / "hooks.json"):
+        if hooks_path.is_file():
+            try:
+                data = json.loads(hooks_path.read_text("utf-8"))
+                hooks = data.get("hooks") if isinstance(data, dict) else None
+                if isinstance(hooks, list):
+                    counts["hooks"] = len(hooks)
+                elif isinstance(hooks, dict):
+                    counts["hooks"] = sum(
+                        len(v) if isinstance(v, list) else 1
+                        for v in hooks.values()
+                    )
+            except (OSError, json.JSONDecodeError):
+                pass
+            break
+
+    mcp_path = plugin_dir / ".mcp.json"
+    if mcp_path.is_file():
+        try:
+            data = json.loads(mcp_path.read_text("utf-8"))
+            servers = data.get("mcpServers") if isinstance(data, dict) else None
+            if isinstance(servers, dict):
+                counts["mcp_servers"] = len(servers)
+        except (OSError, json.JSONDecodeError):
+            pass
+
+    return counts
+
+
+def _plugin_manifest(plugin_dir: Path) -> dict[str, Any]:
+    """Read `plugin.json` for author/version/license info."""
+    for path in (
+        plugin_dir / ".claude-plugin" / "plugin.json",
+        plugin_dir / "plugin.json",
+    ):
+        if path.is_file():
+            try:
+                return json.loads(path.read_text("utf-8"))
+            except (OSError, json.JSONDecodeError):
+                return {}
+    return {}
+
+
+# ---------- endpoints -------------------------------------------------------
+
+
+@router.get("")
+async def list_plugins(available: bool = True):
+    """Return installed + (optionally) available plugins, with components inventory.
+
+    Default includes the marketplace catalog so the widget can render a unified
+    list with install/uninstall buttons. Set `?available=false` to skip the
+    catalog fetch (faster — no remote refresh).
+    """
+    args = ["plugins", "list", "--json"]
+    if available:
+        args.insert(2, "--available")
+    rc, out, err = await _run_claude(*args)
+    if rc != 0:
+        raise HTTPException(status_code=502, detail=f"claude plugins list failed: {err.strip() or out.strip()}")
+
+    try:
+        data = json.loads(out)
+    except json.JSONDecodeError as e:
+        raise HTTPException(status_code=502, detail=f"unparseable CLI output: {e}")
+
+    # --available returns {installed, available}; without it returns a flat list
+    if available and isinstance(data, dict):
+        installed = data.get("installed") or []
+        available_list = data.get("available") or []
+    else:
+        installed = data if isinstance(data, list) else []
+        available_list = []
+
+    installed_by_id: dict[str, dict[str, Any]] = {it["id"]: it for it in installed if "id" in it}
+
+    def _enrich(item: dict[str, Any], is_installed: bool) -> dict[str, Any]:
+        # `available` items use `pluginId`, installed items use `id`. Normalize.
+        plugin_id = item.get("id") or item.get("pluginId") or ""
+        plugin_dir = _plugin_dir(plugin_id) if plugin_id else None
+        components = _component_inventory(plugin_dir) if plugin_dir else {
+            "skills": 0, "agents": 0, "commands": 0, "hooks": 0, "mcp_servers": 0,
+        }
+        manifest = _plugin_manifest(plugin_dir) if plugin_dir else {}
+        inst = installed_by_id.get(plugin_id, {})
+        return {
+            "id": plugin_id,
+            "name": item.get("name") or plugin_id.split("@", 1)[0],
+            "description": item.get("description") or manifest.get("description") or "",
+            "marketplace": item.get("marketplaceName") or (plugin_id.split("@", 1)[1] if "@" in plugin_id else ""),
+            "source": item.get("source"),
+            "install_count": item.get("installCount"),
+            "installed": is_installed,
+            "enabled": inst.get("enabled") if is_installed else None,
+            "version": inst.get("version") or manifest.get("version"),
+            "scope": inst.get("scope"),
+            "installed_at": inst.get("installedAt"),
+            "install_path": inst.get("installPath"),
+            "author": manifest.get("author"),
+            "components": components,
+        }
+
+    items: list[dict[str, Any]] = []
+    seen: set[str] = set()
+    # Installed first (so they sort to the top before any UI-side reorder)
+    for it in installed:
+        pid = it.get("id")
+        if not pid:
+            continue
+        items.append(_enrich(it, is_installed=True))
+        seen.add(pid)
+    for it in available_list:
+        pid = it.get("pluginId") or it.get("id")
+        if not pid or pid in seen:
+            continue
+        items.append(_enrich(it, is_installed=False))
+
+    return {
+        "plugins": items,
+        "counts": {
+            "installed": sum(1 for p in items if p["installed"]),
+            "enabled": sum(1 for p in items if p.get("enabled")),
+            "available": len(items),
+        },
+    }
+
+
+class PluginActionBody(BaseModel):
+    plugin_id: str
+
+
+async def _plugin_action(verb: str, plugin_id: str) -> dict[str, Any]:
+    """Run `claude plugins <verb> <plugin_id>` and surface stdout/stderr."""
+    _validate_plugin_id(plugin_id)
+    rc, out, err = await _run_claude("plugins", verb, plugin_id)
+    ok = rc == 0
+    if not ok:
+        raise HTTPException(
+            status_code=400,
+            detail={
+                "verb": verb,
+                "plugin_id": plugin_id,
+                "stdout": out.strip(),
+                "stderr": err.strip(),
+                "returncode": rc,
+            },
+        )
+    return {
+        "ok": True,
+        "verb": verb,
+        "plugin_id": plugin_id,
+        "stdout": out.strip(),
+        "stderr": err.strip(),
+    }
+
+
+@router.post("/install")
+async def install_plugin(payload: PluginActionBody):
+    return await _plugin_action("install", payload.plugin_id)
+
+
+@router.post("/uninstall")
+async def uninstall_plugin(payload: PluginActionBody):
+    return await _plugin_action("uninstall", payload.plugin_id)
+
+
+@router.post("/enable")
+async def enable_plugin(payload: PluginActionBody):
+    return await _plugin_action("enable", payload.plugin_id)
+
+
+@router.post("/disable")
+async def disable_plugin(payload: PluginActionBody):
+    return await _plugin_action("disable", payload.plugin_id)

painapple_code/routes/api_project_config.py

@@ -0,0 +1,418 @@
+"""
+Project Config API Routes - project-specific configuration & slash commands.
+
+These endpoints manage:
+- Project-specific configuration (get/put/patch)
+- Project rename (human-friendly display name)
+- Project slash commands (cached list, descriptions, source paths)
+
+Also exposes module-level helpers used by `routes.api_commands`:
+- `_cli_command_descriptions()` (lazily extracted from the Claude CLI binary, memoized)
+- `_get_command_descriptions` (CLI defaults + .md frontmatter overrides)
+"""
+
+import asyncio
+import contextlib
+import functools
+import json
+import logging
+import mmap
+import re
+from pathlib import Path
+
+from fastapi import APIRouter, Request
+from pydantic import BaseModel
+
+from painapple_code import paths
+from painapple_code.session_store import SessionStore
+from painapple_code.utils.file_paths import safe_resolve
+
+logger = logging.getLogger(__name__)
+
+router = APIRouter(tags=["app:project-config"])
+
+
+# ═══════════════════════════════════════════════════════════════════
+# Project Config API
+# ═══════════════════════════════════════════════════════════════════
+
+@router.get("/api/project/config")
+async def get_project_config(cwd: str):
+    """Get project-specific configuration (merged with global)."""
+    resolved_cwd = str(safe_resolve(cwd))
+    config = paths.load_project_config(resolved_cwd)
+
+    project_hash = paths.get_project_hash(resolved_cwd)
+    project_dir = paths.get_project_dir(resolved_cwd)
+
+    return {
+        "config": config,
+        "project": {
+            "hash": project_hash,
+            "path": resolved_cwd,
+            "name": Path(resolved_cwd).name,
+            "has_shadow_git": (project_dir / "shadow-git").exists(),
+            "color": paths.get_project_color(resolved_cwd),
+        }
+    }
+
+
+@router.put("/api/project/config")
+async def update_project_config(cwd: str, request: Request):
+    """Update project-specific configuration."""
+    resolved_cwd = str(safe_resolve(cwd))
+    body = await request.json()
+
+    paths.save_project_config(resolved_cwd, body)
+
+    return await get_project_config(cwd)
+
+
+@router.patch("/api/project/config")
+async def patch_project_config(cwd: str, request: Request):
+    """Partially update project configuration (merge with existing)."""
+    resolved_cwd = str(safe_resolve(cwd))
+    body = await request.json()
+
+    config_path = paths.get_project_config_path(resolved_cwd)
+    existing = {}
+    if config_path.exists():
+        try:
+            existing = json.loads(config_path.read_text(encoding="utf-8"))
+        except Exception:
+            pass
+
+    def deep_merge(base, update):
+        result = base.copy()
+        for key, value in update.items():
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = deep_merge(result[key], value)
+            else:
+                result[key] = value
+        return result
+
+    merged = deep_merge(existing, body)
+    paths.save_project_config(resolved_cwd, merged)
+
+    return await get_project_config(cwd)
+
+
+class ProjectRenameRequest(BaseModel):
+    name: str
+
+
+@router.post("/api/project/rename")
+async def rename_project(cwd: str, request: ProjectRenameRequest):
+    """Set a human-friendly display name for a project."""
+    resolved_cwd = str(safe_resolve(cwd))
+    paths.set_project_display_name(resolved_cwd, request.name)
+
+    return {
+        "success": True,
+        "project_path": resolved_cwd,
+        "display_name": paths.get_project_display_name(resolved_cwd),
+        "directory_name": Path(resolved_cwd).name,
+    }
+
+
+class ProjectColorRequest(BaseModel):
+    # Empty string / null clears the override (revert to the deterministic
+    # hash color). Any non-hex value is normalized/rejected server-side.
+    color: str = ""
+
+
+@router.get("/api/project/colors")
+async def get_project_colors():
+    """Bulk map of project path → custom color for every project with one set.
+
+    A single fetch feeds the synchronous client-side `getProjectColor`
+    override lookups across the UI (tabs, welcome cards, pickers).
+    """
+    return {"colors": paths.list_project_colors()}
+
+
+@router.post("/api/project/color")
+async def set_project_color(cwd: str, request: ProjectColorRequest):
+    """Assign (or clear) a custom color for a project.
+
+    Stored under `display.color`; an empty/invalid color clears the override.
+    """
+    resolved_cwd = str(safe_resolve(cwd))
+    stored = paths.set_project_color(resolved_cwd, request.color)
+
+    return {
+        "success": True,
+        "project_path": resolved_cwd,
+        "color": stored,
+    }
+
+
+def _get_user_command_names(cwd: str) -> list[str]:
+    """Get names of user-defined commands from ~/.claude/commands/ and {cwd}/.claude/commands/."""
+    names = set()
+    dirs = [
+        Path.home() / ".claude" / "commands",
+        Path(cwd) / ".claude" / "commands",
+    ]
+    for d in dirs:
+        if d.is_dir():
+            for f in d.iterdir():
+                if f.is_file() and f.suffix == ".md":
+                    names.add(f.stem)
+    return sorted(names)
+
+
+_MAX_SCAN_BYTES = 500 * 1024 * 1024
+
+
+@contextlib.contextmanager
+def _mapped_bytes(path: Path):
+    """The file's bytes as a scannable buffer, mmap'd when possible.
+
+    `re` takes any buffer, so mapping instead of `read_bytes()` keeps the
+    ~100-300MB CLI bundle in the page cache the OS already has it in,
+    rather than copying all of it into the server's heap. Falls back to a
+    real read where mmap isn't available (some network filesystems), and
+    yields b"" for an unreadable or implausibly large file.
+    """
+    try:
+        size = path.stat().st_size
+    except OSError:
+        yield b""
+        return
+    if size > _MAX_SCAN_BYTES:
+        # Kept as a cap rather than removed: this scans whatever `claude`
+        # resolves to on PATH, and half a gigabyte is already ~4x the real
+        # bundle, so anything past it is a wrong file, not a big one — and
+        # the scan is on the request path. But it is no longer SILENT; it
+        # used to look identical to "the CLI has no commands", which is
+        # what `strings` (unbounded) would never have reported.
+        logger.warning(
+            f"Skipping slash-command extraction: {path} is {size} bytes, "
+            f"over the {_MAX_SCAN_BYTES}-byte scan cap"
+        )
+        yield b""
+        return
+    try:
+        with open(path, "rb") as fh:
+            try:
+                with mmap.mmap(fh.fileno(), 0, access=mmap.ACCESS_READ) as mm:
+                    yield mm
+                    return
+            except (OSError, ValueError):
+                fh.seek(0)
+                yield fh.read()
+    except OSError:
+        yield b""
+
+
+# `name:"xxx",description:"yyy"` / `…,description:'yyy'` as it appears in
+# the CLI's embedded JS, matched against the raw binary.
+#
+# There is no `strings` pass in front of this any more, and none is needed.
+# The point of extracting printable runs first was to stop `[^"]+` from
+# swallowing NUL and other binary noise into a description; restricting the
+# body to printable ASCII does that directly — `[ -!#-~]` is 0x20..0x7e
+# minus `"`, `[ -&(-~]` the same minus `'`. Every other byte of the pattern
+# is printable too, so a match still can't span the boundary `strings`
+# would have cut at, and the result is byte-identical (verified against the
+# old implementation over the real 294MB bundle: same 95 commands, same
+# descriptions) for ~1/40th of the work — 2.13s to 0.05s, because the old
+# form built a ~100MB str of every printable run before searching it.
+_COMMAND_DEF = re.compile(
+    rb'name:"([a-z][a-z0-9-]*)",description:(?:"([ -!#-~]+)"|\'([ -&(-~]+)\')'
+)
+
+
+@functools.lru_cache(maxsize=1)
+def _cli_command_descriptions() -> dict[str, str]:
+    """Extract slash command descriptions from the Claude CLI binary.
+
+    Parses `name:"xxx",description:"yyy"` and `name:"xxx",description:'yyy'` patterns
+    from the embedded JS. Some skills use single-quoted descriptions because their
+    text contains double quotes (e.g. update-config's description references
+    "from now on when X" in quotes).
+
+    Lazily computed on first use and cached for the server's lifetime —
+    scanning the ~100MB CLI bundle takes a couple of seconds, which must
+    not happen at import time (it made every `painapple` CLI invocation
+    slow) and must not happen on the event loop. Blocking: call it through
+    `cli_command_descriptions()` from async code, never directly.
+    """
+    import shutil
+    descriptions = {}
+    try:
+        claude_bin = shutil.which("claude")
+        if claude_bin:
+            real_path = Path(claude_bin).resolve()
+            # Was `strings <binary>`: absent on Windows and on any Linux
+            # without binutils, and a whole subprocess to do what one regex
+            # pass does. No dependency, and it can't hang.
+            with _mapped_bytes(real_path) as data:
+                # Group 2 = double-quoted body, group 3 = single-quoted.
+                for m in _COMMAND_DEF.finditer(data):
+                    name = m.group(1).decode("ascii")
+                    # Skip non-command entries (CLI args, system tools, etc.)
+                    if name.startswith("--") or name in ("command", "count", "duration", "definition"):
+                        continue
+                    # Keep first match for duplicates (real command defs
+                    # appear before library defs). Checked before the decode
+                    # work rather than after it.
+                    if name in descriptions:
+                        continue
+                    raw = m.group(2) if m.group(2) is not None else m.group(3)
+                    # Decode unicode escapes like &ndash;
+                    desc = raw.decode("ascii").encode("utf-8").decode(
+                        "unicode_escape", errors="replace"
+                    )
+                    # Truncate multi-line descriptions (skills with trigger rules)
+                    if "\n" in desc:
+                        desc = desc.split("\n")[0].rstrip()
+                    descriptions[name] = desc
+    except Exception:
+        pass
+    return descriptions
+
+
+async def cli_command_descriptions() -> dict[str, str]:
+    """Async accessor for `_cli_command_descriptions` — the only safe one.
+
+    The scan reads and regexes the whole Claude CLI bundle: measured ~2.2s
+    in-process, and it was being called straight from `async def` handlers,
+    so every WS frame, turn heartbeat and unrelated request stalled behind
+    it. (The `strings` subprocess it replaced was slower in wall-clock but
+    released the GIL, so it never had this effect.) Same
+    `asyncio.to_thread` shape as the `--version` probe in
+    api_app_config.
+
+    The `functools.lru_cache` underneath means only the first call pays;
+    concurrent first calls can duplicate the work, which costs CPU but not
+    correctness (the memo converges on one of the identical results).
+    """
+    return await asyncio.to_thread(_cli_command_descriptions)
+
+
+def _get_command_descriptions(cwd: str) -> dict[str, str]:
+    """Get descriptions for commands from CLI binary + .md frontmatter."""
+    descriptions = dict(_cli_command_descriptions())
+    # User command .md frontmatter descriptions override CLI defaults
+    dirs = [
+        Path.home() / ".claude" / "commands",
+        Path(cwd) / ".claude" / "commands",
+    ]
+    for d in dirs:
+        if d.is_dir():
+            for f in d.iterdir():
+                if f.is_file() and f.suffix == ".md":
+                    try:
+                        text = f.read_text(encoding="utf-8", errors="replace")
+                        # Parse YAML frontmatter: --- ... description: ... ---
+                        if text.startswith("---"):
+                            end = text.find("---", 3)
+                            if end != -1:
+                                for line in text[3:end].splitlines():
+                                    line = line.strip()
+                                    if line.startswith("description:"):
+                                        desc = line[len("description:"):].strip().strip('"').strip("'")
+                                        if desc:
+                                            descriptions[f.stem] = desc
+                                        break
+                    except Exception:
+                        pass
+    return descriptions
+
+
+def _get_command_sources(cwd: str) -> dict[str, str]:
+    """Resolve command names to source file paths.
+
+    Search order (first match wins — project beats global, commands beat skills):
+      1. {cwd}/.claude/commands/{name}.md
+      2. ~/.claude/commands/{name}.md
+      3. {cwd}/.claude/skills/{name}/SKILL.md
+      4. ~/.claude/skills/{name}/SKILL.md
+      5. ~/.claude/plugins/marketplaces/ * /plugins/ * /commands/{name}.md
+      6. ~/.claude/plugins/marketplaces/ * /plugins/ * /skills/{name}/SKILL.md
+
+    Returns a dict mapping command name (without leading /) to absolute file path.
+    Commands whose source is baked into the CLI binary (e.g. /loop, /compact)
+    or stored in browser localStorage (user custom commands) are not listed.
+    """
+    sources: dict[str, str] = {}
+    cwd_path = Path(cwd)
+    home = Path.home()
+
+    def _add(name: str, path: Path):
+        if name not in sources and path.is_file():
+            sources[name] = str(path)
+
+    # 1 & 2: command files
+    for base in (cwd_path, home):
+        cmd_dir = base / ".claude" / "commands"
+        if cmd_dir.is_dir():
+            for f in cmd_dir.iterdir():
+                if f.is_file() and f.suffix == ".md":
+                    _add(f.stem, f)
+
+    # 3 & 4: skill files
+    for base in (cwd_path, home):
+        skill_root = base / ".claude" / "skills"
+        if skill_root.is_dir():
+            for skill_dir in skill_root.iterdir():
+                if skill_dir.is_dir():
+                    skill_file = skill_dir / "SKILL.md"
+                    if skill_file.is_file():
+                        _add(skill_dir.name, skill_file)
+
+    # 5 & 6: plugin marketplace commands/skills
+    plugins_root = home / ".claude" / "plugins" / "marketplaces"
+    if plugins_root.is_dir():
+        for marketplace in plugins_root.iterdir():
+            plugins_dir = marketplace / "plugins"
+            if not plugins_dir.is_dir():
+                continue
+            for plugin in plugins_dir.iterdir():
+                # Plugin commands
+                cmd_dir = plugin / "commands"
+                if cmd_dir.is_dir():
+                    for f in cmd_dir.iterdir():
+                        if f.is_file() and f.suffix == ".md":
+                            _add(f.stem, f)
+                # Plugin skills
+                skill_root = plugin / "skills"
+                if skill_root.is_dir():
+                    for skill_dir in skill_root.iterdir():
+                        if skill_dir.is_dir():
+                            skill_file = skill_dir / "SKILL.md"
+                            if skill_file.is_file():
+                                _add(skill_dir.name, skill_file)
+    return sources
+
+
+@router.get("/api/project/commands")
+async def get_project_commands(cwd: str):
+    """Get cached slash commands for a project (by CWD).
+
+    Folder-form skills (resolving to `SKILL.md`) are filtered out — they
+    are surfaced through the `~` skills picker instead, so `/` autocomplete
+    only shows true slash commands.
+    """
+    resolved_cwd = str(safe_resolve(cwd))
+    commands = SessionStore.get_project_commands(resolved_cwd)
+    user_commands = _get_user_command_names(resolved_cwd)
+    # Warm the binary scan off the event loop; the sync call below then
+    # hits the memo instead of stalling the loop for ~2s.
+    await cli_command_descriptions()
+    descriptions = _get_command_descriptions(resolved_cwd)
+    sources = _get_command_sources(resolved_cwd)
+    # Drop names whose source is a folder-form skill — those go through `~`.
+    filtered_commands = [
+        name for name in commands
+        if not sources.get(name, "").endswith("SKILL.md")
+    ]
+    return {
+        "cwd": resolved_cwd,
+        "commands": filtered_commands,
+        "user_commands": user_commands,
+        "descriptions": descriptions,
+        "sources": sources,
+    }