python-jcli 0.1.0__py3-none-any.whl → 1.0.1__py3-none-any.whl

jcli/{plugins/skills.py → specs/plugins/jcli_commands.py}

@@ -1,4 +1,14 @@
-"""Jcli skills management commands."""
+"""Top-level command plugins for jcli 2.0: skills, completion.
+
+Migrated verbatim from jcli v1:
+
+* ``skills``  — jcli/plugins/skills.py
+* ``completion`` — jcli/cli.py ``add_completion_command``
+
+Each group is registered as a cliyard command plugin
+(``@register_command``), so ``create_cli`` attaches it to the top-level
+Click group.  Command semantics and output formats are unchanged from v1.
+"""
 
 from __future__ import annotations
 
@@ -8,14 +18,20 @@ from typing import Any
 
 import click
 
+from cliyard.plugin import register_command
+
 from jcli.cli_helpers import get_formatter
 
-# ------------------------------------------------------------------
-# Constants
-# ------------------------------------------------------------------
 
-# Bundled skills directory (ships with jcli package)
-BUNDLED_SKILLS_DIR = Path(__file__).parent.parent / "skills" / "jcli"
+# =====================================================================
+# Skills commands (verbatim from jcli/plugins/skills.py)
+# =====================================================================
+
+# Bundled skills directory (ships with jcli package):
+# <repo-root>/jcli/skills/jcli/*  — this plugin lives in <repo-root>/jcli/specs/plugins/
+BUNDLED_SKILLS_DIR = (
+    Path(__file__).resolve().parent.parent.parent.parent / "jcli" / "skills" / "jcli"
+)
 
 # Default install directory for opencode
 DEFAULT_INSTALL_DIR = Path.home() / ".config" / "opencode" / "skills"
@@ -24,11 +40,6 @@ DEFAULT_INSTALL_DIR = Path.home() / ".config" / "opencode" / "skills"
 FRONTMATTER_PATTERN = re.compile(r"^---\s*\n(.*?)\n---\s*\n", re.DOTALL)
 
 
-# ------------------------------------------------------------------
-# Helpers
-# ------------------------------------------------------------------
-
-
 def parse_skill_metadata(skill_dir: Path) -> dict[str, Any]:
     """Parse SKILL.md frontmatter to extract metadata.
 
@@ -59,9 +70,12 @@ def parse_skill_metadata(skill_dir: Path) -> dict[str, Any]:
     frontmatter = match.group(1)
 
     # Simple YAML parsing without pyyaml dependency
-    for line in frontmatter.split("\n"):
-        line = line.strip()
+    lines = frontmatter.split("\n")
+    i = 0
+    while i < len(lines):
+        line = lines[i].strip()
         if not line or line.startswith("#"):
+            i += 1
             continue
 
         if line.startswith("name:"):
@@ -70,14 +84,45 @@ def parse_skill_metadata(skill_dir: Path) -> dict[str, Any]:
             metadata["version"] = line.split(":", 1)[1].strip().strip("'\"")
         elif line.startswith("description:"):
             desc = line.split(":", 1)[1].strip().strip("'\"")
+            if desc in ("|", ">", ""):
+                # YAML block scalar: collect following indented lines
+                parts = []
+                j = i + 1
+                while j < len(lines) and (
+                    lines[j].startswith(" ") or lines[j].startswith("\t")
+                ):
+                    parts.append(lines[j].strip())
+                    j += 1
+                if parts:
+                    desc = " ".join(parts)
+                    i = j - 1  # continue after the block scalar
             metadata["description"] = desc
         elif line.startswith("- ") and "allowed-tools" in frontmatter:
             tool = line[2:].strip().strip("'\"")
             metadata["allowed_tools"].append(tool)
+        i += 1
 
     return metadata
 
 
+def _is_jcli_skill(metadata: dict[str, Any]) -> bool:
+    """Return True if the skill belongs to jcli.
+
+    A skill is considered jcli's own when:
+    - it is a symlink into the bundled skills directory
+      (``source == "bundled (symlink)"``), or
+    - its name starts with the ``jcli-`` prefix, or
+    - its path contains a ``jcli`` path segment (e.g. inside BUNDLED_SKILLS_DIR).
+    """
+    if metadata.get("source") == "bundled (symlink)":
+        return True
+    if str(metadata.get("name", "")).startswith("jcli-"):
+        return True
+    if "jcli" in Path(str(metadata.get("path", ""))).parts:
+        return True
+    return False
+
+
 def get_bundled_skills() -> list[dict[str, Any]]:
     """Get all bundled skills from the skills directory."""
     skills = []
@@ -149,8 +194,8 @@ def install_skill(
 
     skill_dest = target_dir / name
 
-    # Check if already installed
-    if skill_dest.exists():
+    # Path.exists() is False for a broken symlink; is_symlink() catches it
+    if skill_dest.exists() or skill_dest.is_symlink():
         if force:
             # Remove existing
             if skill_dest.is_symlink():
@@ -182,7 +227,8 @@ def uninstall_skill(name: str, install_dir: Path | None = None) -> bool:
     target_dir = install_dir or DEFAULT_INSTALL_DIR
     skill_path = target_dir / name
 
-    if not skill_path.exists():
+    # Path.exists() is False for a broken symlink; is_symlink() catches it
+    if not skill_path.exists() and not skill_path.is_symlink():
         raise click.ClickException(f"Skill '{name}' not found in {target_dir}.")
 
     if skill_path.is_symlink():
@@ -196,46 +242,44 @@ def uninstall_skill(name: str, install_dir: Path | None = None) -> bool:
     return True
 
 
-# ------------------------------------------------------------------
-# Click group
-# ------------------------------------------------------------------
-
-
 @click.group("skills", help="Manage jcli skills (list, install, uninstall).")
 def skills_group() -> None:
     """Skills management commands."""
 
 
-# ------------------------------------------------------------------
-# list
-# ------------------------------------------------------------------
-
-
 @skills_group.command("list")
 @click.option("--installed", "-i", is_flag=True, help="Show only installed skills.")
 @click.option("--bundled", "-b", is_flag=True, help="Show only bundled skills.")
 @click.option("--dir", "install_dir", type=click.Path(exists=False), help="Custom install directory.")
 @click.pass_context
-def list_cmd(ctx: click.Context, installed: bool, bundled: bool, install_dir: str | None) -> None:
+def skills_list_cmd(ctx: click.Context, installed: bool, bundled: bool, install_dir: str | None) -> None:
     """List all available skills."""
     fmt = get_formatter(ctx)
     target_dir = Path(install_dir) if install_dir else DEFAULT_INSTALL_DIR
 
     skills_to_show = []
 
-    if not installed:
-        # Show bundled skills
-        bundled_skills = get_bundled_skills()
-        skills_to_show.extend(bundled_skills)
-
-    if not bundled:
-        # Show installed skills
-        installed_skills = get_installed_skills(target_dir)
-        # Avoid duplicates if both bundled and installed
-        existing_names = {s["name"] for s in skills_to_show}
-        for skill in installed_skills:
-            if skill["name"] not in existing_names:
+    if installed and bundled:
+        # Both flags explicitly given: bundled + jcli installed (dedup by name)
+        seen: set[str] = set()
+        for skill in get_bundled_skills():
+            skills_to_show.append(skill)
+            seen.add(skill["name"])
+        for skill in get_installed_skills(target_dir):
+            if _is_jcli_skill(skill) and skill["name"] not in seen:
                 skills_to_show.append(skill)
+                seen.add(skill["name"])
+    elif installed:
+        # Only jcli installed skills
+        skills_to_show.extend(
+            s for s in get_installed_skills(target_dir) if _is_jcli_skill(s)
+        )
+    elif bundled:
+        # Only bundled skills
+        skills_to_show.extend(get_bundled_skills())
+    else:
+        # Default: only bundled (jcli's own skills)
+        skills_to_show.extend(get_bundled_skills())
 
     if not skills_to_show:
         fmt.print_info("No skills found.")
@@ -254,18 +298,13 @@ def list_cmd(ctx: click.Context, installed: bool, bundled: bool, install_dir: st
     fmt.print_table(headers, rows, title="Jcli Skills")
 
 
-# ------------------------------------------------------------------
-# install
-# ------------------------------------------------------------------
-
-
 @skills_group.command("install")
 @click.argument("name", required=False)
 @click.option("--all", "-a", "install_all", is_flag=True, help="Install all bundled skills.")
 @click.option("--force", "-f", is_flag=True, help="Force install (overwrite existing).")
 @click.option("--dir", "install_dir", type=click.Path(exists=False), help="Custom install directory.")
 @click.pass_context
-def install_cmd(ctx: click.Context, name: str | None, install_all: bool, force: bool, install_dir: str | None) -> None:
+def skills_install_cmd(ctx: click.Context, name: str | None, install_all: bool, force: bool, install_dir: str | None) -> None:
     """Install a skill.
 
     NAME is the skill name to install (from bundled skills).
@@ -311,16 +350,11 @@ def install_cmd(ctx: click.Context, name: str | None, install_all: bool, force:
     fmt.print_success(f"Skill '{name}' installed to {target_dir / name}")
 
 
-# ------------------------------------------------------------------
-# uninstall
-# ------------------------------------------------------------------
-
-
 @skills_group.command("uninstall")
 @click.argument("name")
 @click.option("--dir", "install_dir", type=click.Path(exists=False), help="Custom install directory.")
 @click.pass_context
-def uninstall_cmd(ctx: click.Context, name: str, install_dir: str | None) -> None:
+def skills_uninstall_cmd(ctx: click.Context, name: str, install_dir: str | None) -> None:
     """Uninstall a skill.
 
     NAME is the skill name to uninstall.
@@ -339,17 +373,12 @@ def uninstall_cmd(ctx: click.Context, name: str, install_dir: str | None) -> Non
     fmt.print_success(f"Skill '{name}' uninstalled from {target_dir}")
 
 
-# ------------------------------------------------------------------
-# get
-# ------------------------------------------------------------------
-
-
 @skills_group.command("get")
 @click.argument("name")
 @click.option("--installed", "-i", is_flag=True, help="Get from installed skills.")
 @click.option("--dir", "install_dir", type=click.Path(exists=False), help="Custom install directory.")
 @click.pass_context
-def get_cmd(ctx: click.Context, name: str, installed: bool, install_dir: str | None) -> None:
+def skills_get_cmd(ctx: click.Context, name: str, installed: bool, install_dir: str | None) -> None:
     """Show skill details and SKILL.md content."""
     fmt = get_formatter(ctx)
     target_dir = Path(install_dir) if install_dir else DEFAULT_INSTALL_DIR
@@ -389,11 +418,43 @@ def get_cmd(ctx: click.Context, name: str, installed: bool, install_dir: str | N
     fmt.console.print(content)
 
 
-# ------------------------------------------------------------------
-# Registration
-# ------------------------------------------------------------------
+# =====================================================================
+# Completion command (verbatim from jcli/cli.py add_completion_command)
+# =====================================================================
+
+
+def build_completion_group(cli: click.Group) -> click.Group:
+    """Build the ``completion show`` group attached to *cli*."""
+    from click.shell_completion import BashComplete, FishComplete, ZshComplete
+
+    @click.group()
+    def completion() -> None:
+        """Shell completion support for jcli."""
+
+    @completion.command()
+    @click.argument("shell", type=click.Choice(["bash", "zsh", "fish"]))
+    def show(shell: str) -> None:
+        """Output shell completion script for the specified shell."""
+        shell_cls = {"bash": BashComplete, "zsh": ZshComplete, "fish": FishComplete}
+        complete = shell_cls[shell](cli, {}, "jcli", "_JCLI_COMPLETE")
+        click.echo(complete.source(), nl=False)
+
+    cli.add_command(completion)
+    return completion
+
+
+# =====================================================================
+# cliyard command plugin registration
+# =====================================================================
+
+
+@register_command("skills")
+def _register_skills(cli: click.Group, ctx: Any) -> None:
+    """Attach the skills command group to the top-level CLI."""
+    cli.add_command(skills_group)
 
 
-def register(parent_group: click.Group) -> None:
-    """Register the skills subgroup under the parent Click group."""
-    parent_group.add_command(skills_group)
+@register_command("completion")
+def _register_completion(cli: click.Group, ctx: Any) -> None:
+    """Attach the completion command group to the top-level CLI."""
+    build_completion_group(cli)

jcli/specs/plugins/jenkins_auth.py

@@ -0,0 +1,75 @@
+"""Jenkins auth steps: Basic Auth + Crumb (CSRF)."""
+import base64
+import os
+
+import requests
+
+from cliyard.plugin import register_auth_step
+
+
+def _config_path() -> str:
+    """Resolve the jcli config file path at call time.
+
+    Prefers ``jcli.sdk.config.DEFAULT_CONFIG_FILE`` (so tests can point it
+    elsewhere via monkeypatch) and falls back to ``~/.jcli/config.yaml``
+    when the SDK is not importable.
+    """
+    try:
+        from jcli.sdk.config import DEFAULT_CONFIG_FILE
+
+        return str(DEFAULT_CONFIG_FILE)
+    except Exception:
+        return os.path.expanduser("~/.jcli/config.yaml")
+
+
+def _load_profile():
+    import yaml
+    config_path = _config_path()
+    if not os.path.exists(config_path):
+        raise RuntimeError(f"config not found: {config_path}")
+    with open(config_path, "r", encoding="utf-8") as f:
+        cfg = yaml.safe_load(f) or {}
+    name = os.environ.get("JCLI_PROFILE") or cfg.get("active_profile", "default")
+    profile = dict(cfg.get("profiles", {}).get(name, {}))
+    for env_key, field in (("JCLI_URL", "url"), ("JCLI_USERNAME", "username"), ("JCLI_API_TOKEN", "api_token")):
+        if os.environ.get(env_key):
+            profile[field] = os.environ[env_key]
+    return profile
+
+
+@register_auth_step("jenkins_basic")
+class JenkinsBasicAuth:
+    """Set Basic Auth header from ~/.jcli/config.yaml profile."""
+
+    def execute(self, auth_state, config, http_client):
+        profile = _load_profile()
+        username = profile.get("username", "")
+        token = profile.get("api_token", "")
+        if not username or not token:
+            raise RuntimeError("missing username/api_token in profile")
+        raw = f"{username}:{token}".encode()
+        http_client.default_headers["Authorization"] = "Basic " + base64.b64encode(raw).decode()
+        auth_state["username"] = username
+        return {"username": username}
+
+
+@register_auth_step("jenkins_crumb")
+class JenkinsCrumb:
+    """Fetch Jenkins crumb and inject as header. Tolerate 404 (CSRF disabled)."""
+
+    def execute(self, auth_state, config, http_client):
+        url = f"{http_client.base_url}/crumbIssuer/api/json"
+        try:
+            resp = http_client._session.get(url, headers=http_client.default_headers, timeout=10)
+        except requests.RequestException:
+            return {}
+        if resp.status_code == 404:
+            return {}  # CSRF disabled
+        if resp.status_code != 200:
+            raise RuntimeError(f"crumb fetch failed: {resp.status_code}")
+        data = resp.json()
+        field = data.get("crumbRequestField")
+        value = data.get("crumb")
+        if field and value:
+            http_client.default_headers[field] = value
+        return {"crumb": value}