agencode 0.1.0__py3-none-any.whl

agencli/skills/loader.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from agencli.skills.manager import (
+    SKILL_FILE_NAME,
+    installed_skills_root,
+    named_skill_source_root,
+    skills_dir_has_legacy_layout,
+)
+
+_INSTALLED_ALIASES = {"*", "all", "installed", "local"}
+
+
+def resolve_skill_sources(skills: list[str], skills_dir: str | Path) -> list[str]:
+    base_dir = Path(skills_dir).expanduser().resolve()
+    resolved: list[str] = []
+    seen: set[str] = set()
+
+    def add(source: str) -> None:
+        if source not in seen:
+            seen.add(source)
+            resolved.append(source)
+
+    for raw in skills:
+        token = raw.strip()
+        if not token:
+            continue
+        lowered = token.lower()
+        if lowered in _INSTALLED_ALIASES:
+            installed_root = installed_skills_root(base_dir)
+            if installed_root.exists():
+                add(installed_root.as_posix())
+            if skills_dir_has_legacy_layout(base_dir):
+                add(base_dir.as_posix())
+            continue
+        if _is_backend_virtual_source(token):
+            add(_normalize_virtual_source(token))
+            continue
+        if not _looks_like_path(token):
+            named_root = named_skill_source_root(base_dir) / token
+            if named_root.exists():
+                add(named_root.resolve().as_posix())
+                continue
+        add(_resolve_filesystem_source(token))
+
+    return resolved
+
+
+def _is_backend_virtual_source(value: str) -> bool:
+    return value.startswith("/") and ":" not in value and "\\" not in value
+
+
+def _looks_like_path(value: str) -> bool:
+    return ":" in value or "\\" in value or "/" in value or value.startswith(".")
+
+
+def _normalize_virtual_source(value: str) -> str:
+    normalized = value.rstrip("/")
+    return f"{normalized}/" if normalized else "/"
+
+
+def _resolve_filesystem_source(value: str) -> str:
+    path = Path(value).expanduser()
+    if not path.exists():
+        raise ValueError(
+            f"Unknown skill source `{value}`. Use `installed`, an installed skill name, or a filesystem path."
+        )
+
+    resolved = path.resolve()
+    if resolved.is_file():
+        if resolved.name != SKILL_FILE_NAME:
+            raise ValueError(f"Skill path `{value}` must point to a directory or `{SKILL_FILE_NAME}` file.")
+        return resolved.parent.parent.as_posix()
+    if (resolved / SKILL_FILE_NAME).exists():
+        return resolved.parent.as_posix()
+    return resolved.as_posix()

agencli/skills/manager.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+import re
+import shutil
+
+import yaml
+
+SKILL_FILE_NAME = "SKILL.md"
+_INSTALLED_DIR_NAME = "installed"
+_BY_NAME_DIR_NAME = "by-name"
+_FRONTMATTER_PATTERN = re.compile(r"^---\s*\n(.*?)\n---\s*(?:\n|$)", re.DOTALL)
+
+
+@dataclass(slots=True)
+class InstalledSkill:
+    name: str
+    description: str
+    path: Path
+    allowed_tools: list[str] = field(default_factory=list)
+    license: str | None = None
+    compatibility: str | None = None
+
+
+def install_skill(source: str | Path, skills_dir: str | Path, *, overwrite: bool = False) -> InstalledSkill:
+    source_dir = _coerce_skill_directory(source)
+    skill = read_skill(source_dir)
+    base_dir = Path(skills_dir).expanduser().resolve()
+    installed_dir = installed_skills_root(base_dir)
+    named_dir = named_skill_source_root(base_dir)
+    installed_dir.mkdir(parents=True, exist_ok=True)
+    named_dir.mkdir(parents=True, exist_ok=True)
+
+    canonical_target = installed_dir / skill.name
+    named_target = named_dir / skill.name / skill.name
+    _copy_skill_tree(source_dir, canonical_target, overwrite=overwrite)
+    _copy_skill_tree(source_dir, named_target, overwrite=overwrite)
+    return read_skill(canonical_target)
+
+
+def list_installed_skills(skills_dir: str | Path) -> list[InstalledSkill]:
+    base_dir = Path(skills_dir).expanduser().resolve()
+    skills: dict[str, InstalledSkill] = {}
+    for skill_dir in _iter_installed_skill_dirs(base_dir):
+        skill = read_skill(skill_dir)
+        skills[skill.name] = skill
+    return [skills[name] for name in sorted(skills)]
+
+
+def read_skill(path: str | Path) -> InstalledSkill:
+    skill_dir = _coerce_skill_directory(path)
+    skill_file = skill_dir / SKILL_FILE_NAME
+    raw = skill_file.read_text(encoding="utf-8")
+    metadata = _parse_frontmatter(raw, skill_file)
+
+    name = str(metadata.get("name", "")).strip() or skill_dir.name
+    description = str(metadata.get("description", "")).strip()
+    if not description:
+        raise ValueError(f"Skill `{skill_file}` is missing a description in YAML frontmatter.")
+
+    raw_tools = metadata.get("allowed-tools") or metadata.get("allowed_tools") or ""
+    if isinstance(raw_tools, str):
+        allowed_tools = [tool.strip(",") for tool in raw_tools.split() if tool.strip(",")]
+    elif isinstance(raw_tools, list):
+        allowed_tools = [str(tool).strip() for tool in raw_tools if str(tool).strip()]
+    else:
+        allowed_tools = []
+
+    return InstalledSkill(
+        name=name,
+        description=description,
+        path=skill_dir.resolve(),
+        allowed_tools=allowed_tools,
+        license=str(metadata.get("license", "")).strip() or None,
+        compatibility=str(metadata.get("compatibility", "")).strip() or None,
+    )
+
+
+def installed_skills_root(skills_dir: str | Path) -> Path:
+    return Path(skills_dir).expanduser().resolve() / _INSTALLED_DIR_NAME
+
+
+def named_skill_source_root(skills_dir: str | Path) -> Path:
+    return Path(skills_dir).expanduser().resolve() / _BY_NAME_DIR_NAME
+
+
+def skills_dir_has_legacy_layout(skills_dir: str | Path) -> bool:
+    base_dir = Path(skills_dir).expanduser().resolve()
+    if not base_dir.exists():
+        return False
+    for child in base_dir.iterdir():
+        if not child.is_dir() or child.name in {_INSTALLED_DIR_NAME, _BY_NAME_DIR_NAME}:
+            continue
+        if (child / SKILL_FILE_NAME).exists():
+            return True
+    return False
+
+
+def _iter_installed_skill_dirs(skills_dir: Path) -> list[Path]:
+    skill_dirs: dict[str, Path] = {}
+
+    installed_dir = installed_skills_root(skills_dir)
+    if installed_dir.exists():
+        for child in installed_dir.iterdir():
+            if child.is_dir() and (child / SKILL_FILE_NAME).exists():
+                skill_dirs[child.name] = child
+
+    if skills_dir.exists():
+        for child in skills_dir.iterdir():
+            if not child.is_dir() or child.name in {_INSTALLED_DIR_NAME, _BY_NAME_DIR_NAME}:
+                continue
+            if (child / SKILL_FILE_NAME).exists():
+                skill_dirs.setdefault(child.name, child)
+
+    return list(skill_dirs.values())
+
+
+def _coerce_skill_directory(path: str | Path) -> Path:
+    candidate = Path(path).expanduser().resolve()
+    if candidate.is_file():
+        if candidate.name != SKILL_FILE_NAME:
+            raise ValueError(f"Expected `{SKILL_FILE_NAME}` or a skill directory, got `{candidate}`.")
+        candidate = candidate.parent
+    if not candidate.is_dir():
+        raise ValueError(f"Skill source `{candidate}` is not a directory.")
+    if not (candidate / SKILL_FILE_NAME).exists():
+        raise ValueError(f"Skill directory `{candidate}` does not contain `{SKILL_FILE_NAME}`.")
+    return candidate
+
+
+def _parse_frontmatter(content: str, skill_file: Path) -> dict:
+    normalized = content.replace("\r\n", "\n")
+    match = _FRONTMATTER_PATTERN.match(normalized)
+    if not match:
+        raise ValueError(f"Skill `{skill_file}` is missing YAML frontmatter.")
+    loaded = yaml.safe_load(match.group(1))
+    if not isinstance(loaded, dict):
+        raise ValueError(f"Skill `{skill_file}` has invalid YAML frontmatter.")
+    return loaded
+
+
+def _copy_skill_tree(source_dir: Path, target_dir: Path, *, overwrite: bool) -> None:
+    source_dir = source_dir.resolve()
+    target_dir = target_dir.resolve()
+    if source_dir == target_dir:
+        return
+    if target_dir.exists():
+        if not overwrite:
+            raise FileExistsError(f"Skill destination `{target_dir}` already exists.")
+        shutil.rmtree(target_dir)
+    target_dir.parent.mkdir(parents=True, exist_ok=True)
+    shutil.copytree(source_dir, target_dir)

agencli/tools/__init__.py

@@ -0,0 +1 @@
+"""Tool loaders and local tool definitions for AgenCLI."""

agencli/tools/mcp.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import asyncio
+from concurrent.futures import ThreadPoolExecutor
+import logging
+import shutil
+from typing import Any
+
+from agencli.mcp.client import MCPToolClient
+
+logger = logging.getLogger(__name__)
+
+
+async def load_mcp_tools_async(
+    mcp_config_path: str,
+    server_names: list[str] | None = None,
+    *,
+    diagnostics: list[str] | None = None,
+) -> list[Any]:
+    client = MCPToolClient(mcp_config_path)
+    server_map = client.load_server_map()
+    requested_servers = server_names or list(server_map)
+    if not requested_servers:
+        return []
+
+    resolved_tools: list[Any] = []
+    for server_name in requested_servers:
+        if server_name not in server_map:
+            continue
+        try:
+            resolved_tools.extend(await client.get_tools(server_names=[server_name]))
+        except Exception as exc:
+            message = _format_mcp_error(server_name, server_map[server_name], exc)
+            if diagnostics is not None:
+                if message not in diagnostics:
+                    diagnostics.append(message)
+            else:
+                logger.warning(message)
+    return resolved_tools
+
+
+def _run_tool_request(client: MCPToolClient, server_names: list[str] | None = None) -> list[Any]:
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(client.get_tools(server_names=server_names))
+
+    with ThreadPoolExecutor(max_workers=1) as executor:
+        future = executor.submit(asyncio.run, client.get_tools(server_names=server_names))
+        return future.result()
+
+
+def _format_mcp_error(server_name: str, server_config: dict[str, Any], exc: Exception) -> str:
+    command = server_config.get("command") or ""
+    if command.lower().startswith("npx") and shutil.which(command) is None and shutil.which(f"{command}.cmd") is None:
+        return (
+            f"Skipping MCP server `{server_name}` because `{command}` is not available. "
+            "Install Node.js/npm or update the MCP config."
+        )
+    if command.lower().startswith("npx") and isinstance(exc, OSError) and getattr(exc, "errno", None) == 9:
+        return (
+            f"Skipping MCP server `{server_name}` because Windows could not open `{command}` cleanly. "
+            "Install or repair Node.js/npm, or update the MCP config."
+        )
+    if isinstance(exc, FileNotFoundError):
+        if command.lower().startswith("npx"):
+            return (
+                f"Skipping MCP server `{server_name}` because `{command}` is not available. "
+                "Install Node.js/npm or update the MCP config."
+            )
+        if command:
+            return f"Skipping MCP server `{server_name}` because command `{command}` was not found."
+    return f"Skipping MCP server `{server_name}` because it could not start: {exc}"
+
+
+def load_mcp_tools(
+    mcp_config_path: str,
+    server_names: list[str] | None = None,
+    *,
+    diagnostics: list[str] | None = None,
+) -> list[Any]:
+    try:
+        asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(load_mcp_tools_async(mcp_config_path, server_names=server_names, diagnostics=diagnostics))
+
+    client = MCPToolClient(mcp_config_path)
+    server_map = client.load_server_map()
+    requested_servers = server_names or list(server_map)
+    if not requested_servers:
+        return []
+
+    resolved_tools: list[Any] = []
+    for server_name in requested_servers:
+        if server_name not in server_map:
+            continue
+        try:
+            resolved_tools.extend(_run_tool_request(client, server_names=[server_name]))
+        except Exception as exc:
+            message = _format_mcp_error(server_name, server_map[server_name], exc)
+            if diagnostics is not None:
+                if message not in diagnostics:
+                    diagnostics.append(message)
+            else:
+                logger.warning(message)
+    return resolved_tools

agencli/tui/__init__.py

@@ -0,0 +1 @@
+"""Textual UI for AgenCLI."""