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

jcli/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.0"
+__version__ = "1.0.0"

jcli/cli.py

@@ -1,78 +1,572 @@
-"""Jenkins CLI - Command line interface for managing Jenkins."""
+"""Jenkins CLI - Command line interface for managing Jenkins.
+
+jcli 2.0 wrapper: the Click CLI is generated from the cliyard YAML specs
+(``specs/``) and this module layers the global options on top:
+
+* ``-f/--format`` — table / json / yaml / csv (default ``table``)
+* ``-p/--profile`` — pick a profile from ``~/.jcli/config.yaml``
+* ``-d/--debug`` — enable DEBUG logging on stderr
+* ``-s/--server`` — handled by cliyard's runner pre-extraction
+  (:func:`cliyard.runtime.runner.extract_server_override`); it is *not*
+  redefined here to avoid conflicting with cliyard.
+
+The global ``-f`` is injected into each subcommand callback only when the
+subcommand did not explicitly set its own ``--format`` on the command line
+(cliyard's ``_make_callback`` pops ``format`` from kwargs, so a plain default
+would shadow the global override).
+"""
+
+from __future__ import annotations
 
 import logging
+import os
 import sys
+from pathlib import Path
+from typing import Any, Callable
 
 import click
+from click.core import ParameterSource
+
+from cliyard.runtime import create_cli
+from cliyard.runtime.runner import extract_server_override
 
 from jcli import __version__
-from jcli.plugins import register_commands
 
 logger = logging.getLogger("jcli")
 
+#: Formats accepted by the global ``-f/--format`` option (superset of
+#: cliyard's built-ins, adding ``yaml``).
+GLOBAL_FORMATS = ("table", "json", "yaml", "csv")
 
-@click.group()
-@click.version_option(version=__version__, prog_name="jcli")
-@click.option(
-    "-f",
-    "--format",
-    "output_format",
-    default="table",
-    type=click.Choice(["table", "json", "yaml"]),
-    help="Output format.",
-)
-@click.option("-p", "--profile", default=None, help="Configuration profile name.")
-@click.option("-s", "--server", default=None, help="Jenkins server URL.")
-@click.option("-d", "--debug", is_flag=True, default=False, help="Enable debug output.")
-@click.pass_context
-def cli(ctx, output_format, profile, server, debug):
-    """Jenkins CLI - Manage Jenkins from the command line."""
-    ctx.ensure_object(dict)
-    ctx.obj["format"] = output_format
-    ctx.obj["profile"] = profile
-    ctx.obj["server"] = server
-    ctx.obj["debug"] = debug
-
-    # Configure debug logging when --debug / -d is set
-    if debug:
-        logging.basicConfig(
-            level=logging.DEBUG,
-            format="%(asctime)s %(name)s %(levelname)s %(message)s",
-            stream=sys.stderr,
-        )
-        logger.debug("Debug logging enabled")
-    else:
-        # Ensure WARNING+ level when not in debug mode
-        logging.basicConfig(level=logging.WARNING, stream=sys.stderr)
+#: Env var to override the cliyard spec directory (mainly for tests/dev).
+SPEC_DIR_ENV = "JCLI_SPEC_DIR"
+
+
+# ---------------------------------------------------------------------------
+# Spec directory & base_url resolution
+# ---------------------------------------------------------------------------
+
+
+def _default_spec_dir() -> Path:
+    """Locate the cliyard YAML spec directory.
+
+    Priority: ``$JCLI_SPEC_DIR`` > package-local ``specs/`` > repo-root
+    ``specs/`` (editable/dev layout).
+    """
+    env = os.environ.get(SPEC_DIR_ENV)
+    if env:
+        return Path(env)
+    pkg_specs = Path(__file__).resolve().parent / "specs"
+    if pkg_specs.is_dir():
+        return pkg_specs
+    repo_specs = Path(__file__).resolve().parent.parent / "specs"
+    if repo_specs.is_dir():
+        return repo_specs
+    return pkg_specs
+
+
+def extract_profile_override(argv: list[str]) -> str | None:
+    """Read a ``--profile``/``-p`` value from *argv* without removing it.
+
+    The top-level ``-p/--profile`` Click option parses the flag normally; this
+    only previews the value so the base_url can be resolved before the CLI tree
+    is built.  ``--profile X``, ``--profile=X``, ``-p X`` and ``-p=X`` forms
+    are supported.
+    """
+    profile: str | None = None
+    i = 0
+    while i < len(argv):
+        arg = argv[i]
+        if arg in ("--profile", "-p") and i + 1 < len(argv) and not argv[i + 1].startswith("-"):
+            profile = argv[i + 1]
+            i += 2
+            continue
+        if arg.startswith("--profile="):
+            profile = arg.split("=", 1)[1]
+            i += 1
+            continue
+        if arg.startswith("-p=") and len(arg) > 3:
+            profile = arg[3:]
+            i += 1
+            continue
+        i += 1
+    return profile
+
+
+def _read_profile_url(profile_name: str | None) -> str | None:
+    """Read a profile URL from ``~/.jcli/config.yaml`` (read-only, no creation)."""
+    import yaml as _yaml
+
+    from jcli.sdk.config import DEFAULT_CONFIG_FILE, ENV_PROFILE
+
+    try:
+        if not DEFAULT_CONFIG_FILE.exists():
+            return None
+        cfg = _yaml.safe_load(DEFAULT_CONFIG_FILE.read_text(encoding="utf-8"))
+    except Exception:
+        return None
+    if not isinstance(cfg, dict):
+        return None
+    name = profile_name or os.environ.get(ENV_PROFILE) or cfg.get("active_profile") or "default"
+    profiles = cfg.get("profiles")
+    if not isinstance(profiles, dict):
+        return None
+    profile = profiles.get(name)
+    if not isinstance(profile, dict):
+        return None
+    url = profile.get("url")
+    return url if isinstance(url, str) and url.strip() else None
+
+
+def resolve_base_url(server_override: str | None, profile_name: str | None) -> str | None:
+    """Resolve the base_url handed to ``create_cli(base_url_override=...)``.
+
+    Precedence: ``-s/--server`` > ``JCLI_URL`` env > profile ``url`` from
+    ``~/.jcli/config.yaml``.  ``None`` lets cliyard fall back to the spec's
+    ``server.base_url``.
+    """
+    if server_override:
+        return server_override
+    env_url = os.environ.get("JCLI_URL")
+    if env_url:
+        return env_url
+    return _read_profile_url(profile_name)
+
+
+# ---------------------------------------------------------------------------
+# Global options & format injection
+# ---------------------------------------------------------------------------
+
+
+def add_global_options(cli: click.Group) -> None:
+    """Attach global options (``-f/--format``, ``-p/--profile``, ``-d/--debug``).
+
+    Values are stored in ``ctx.obj`` so wrapped subcommand callbacks can read
+    them.  ``-s/--server`` is intentionally *not* added here — cliyard's
+    ``create_cli`` already registers it on the top-level group (with a root
+    callback that stores the override into ``ctx.obj["server"]``); that
+    behavior is preserved by the combined callback below.
+
+    Note: ``Group.callback`` is a plain attribute in Click 8.4 (the
+    ``@cli.callback`` decorator form is gone), so the callback and its options
+    are assigned explicitly.
+    """
+    cli.params.extend(
+        [
+            click.Option(
+                ["-f", "--format", "output_format"],
+                default="table",
+                type=click.Choice(GLOBAL_FORMATS),
+                help="Output format.",
+                show_default=True,
+            ),
+            click.Option(["-p", "--profile"], default=None, help="Configuration profile name."),
+            click.Option(["-d", "--debug"], is_flag=True, default=False, help="Enable debug output."),
+        ]
+    )
+
+    @click.pass_context
+    def _global_options(
+        ctx: click.Context,
+        output_format: str,
+        profile: str | None,
+        debug: bool,
+        **extra: Any,
+    ) -> None:
+        ctx.ensure_object(dict)
+
+        # Preserve cliyard's root-callback behavior: the native --server/-s
+        # option (registered by create_cli) is stored for subcommands.
+        server = extra.get("server")
+        if server:
+            ctx.obj["server"] = server
+
+        ctx.obj["format"] = output_format
+        ctx.obj["profile"] = profile
+        ctx.obj["debug"] = debug
+
+        if debug:
+            logging.basicConfig(
+                level=logging.DEBUG,
+                format="%(asctime)s %(name)s %(levelname)s %(message)s",
+                stream=sys.stderr,
+                force=True,
+            )
+            logger.debug("Debug logging enabled")
+        else:
+            logging.basicConfig(level=logging.WARNING, stream=sys.stderr, force=True)
+
+    cli.callback = _global_options
+
+
+def _make_format_injector(callback: Callable[..., Any]) -> Callable[..., Any]:
+    """Wrap a subcommand callback so the global ``-f/--format`` is applied.
+
+    cliyard's ``_make_callback`` pops ``format`` from kwargs and falls back to
+    the method's own default — a default therefore shadows a global override.
+    We inspect the parameter source and only inject the global format when the
+    subcommand did not explicitly pass ``--format`` on the command line.
+
+    cliyard's callbacks also swallow every exception and print the message to
+    the console without re-raising, so connection failures / API errors would
+    otherwise exit 0.  The wrapped callback captures stdout, recognises the
+    ``Error:``/``错误:`` markers and re-emits them on stderr with a non-zero
+    exit code.
+
+    Note: ``ctx.exit(1)`` (not ``return 1``) is required — Click >= 8.4
+    ignores a plain integer return value from the top-level callback and
+    always exits with ``ctx.exit_code`` (default 0).
+    """
+    import io
+
+    def wrapped(**kwargs: Any) -> Any:
+        ctx = click.get_current_context()
+        root = ctx.find_root()
+        global_format = (root.obj or {}).get("format")
+        if global_format:
+            try:
+                source = ctx.get_parameter_source("format")
+            except Exception:
+                source = ParameterSource.DEFAULT
+            if source in (None, ParameterSource.DEFAULT, ParameterSource.DEFAULT_MAP):
+                kwargs["format"] = global_format
+
+        buffer = io.StringIO()
+        real_stdout = sys.stdout
+        sys.stdout = buffer
+        try:
+            result = callback(**kwargs)
+        finally:
+            sys.stdout = real_stdout
+
+        output = buffer.getvalue()
+        if output.startswith(("错误:", "Error:")):
+            click.echo(output, err=True, nl=False)
+            ctx.exit(1)
+        if output:
+            click.echo(output, nl=False)
+        return result
+
+    wrapped.__name__ = getattr(callback, "__name__", "callback")
+    wrapped.__doc__ = getattr(callback, "__doc__", None)
+    return wrapped
 
 
-# Register all plugin subcommands
-register_commands(cli)
+def wrap_subcommand_callbacks(command: click.Command) -> None:
+    """Recursively wrap leaf-command callbacks to inherit the global format."""
+    if isinstance(command, click.Group):
+        for sub in command.commands.values():
+            wrap_subcommand_callbacks(sub)
+        return
+    if any(getattr(p, "name", None) == "format" for p in command.params):
+        command.callback = _make_format_injector(command.callback)
 
 
-@click.group()
-def completion():
-    """Shell completion support for jcli."""
-    pass
+def add_completion_command(cli: click.Group) -> None:
+    """Attach the ``completion show`` command (kept from jcli v1)."""
 
+    @click.group()
+    def completion() -> None:
+        """Shell completion support for jcli."""
 
-@completion.command()
-@click.argument("shell", type=click.Choice(["bash", "zsh", "fish"]))
-def show(shell):
-    """Output shell completion script for the specified shell."""
-    from click.shell_completion import BashComplete, ZshComplete, FishComplete
+    @completion.command()
+    @click.argument("shell", type=click.Choice(["bash", "zsh", "fish"]))
+    def show(shell: str) -> None:
+        """Output shell completion script for the specified shell."""
+        from click.shell_completion import BashComplete, FishComplete, ZshComplete
 
-    shell_cls = {"bash": BashComplete, "zsh": ZshComplete, "fish": FishComplete}
-    complete = shell_cls[shell](cli, {}, "jcli", "_JCLI_COMPLETE")
-    click.echo(complete.source(), nl=False)
+        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)
 
-cli.add_command(completion)
 
+def set_group_help(cli: click.Group) -> None:
+    """Propagate each command's ``short_help`` to its ``help`` text.
 
-def main():
+    cliyard only sets ``short_help`` (from the YAML ``description``), so
+    ``jcli job --help`` / ``jcli plugin list --help`` would otherwise render
+    without the description line.  jcli v1 printed it, so keep that
+    behaviour: the top-level help lists commands via ``short_help``
+    (unchanged), while per-command ``--help`` pages show the description.
+    """
+    stack = list(cli.commands.values())
+    while stack:
+        command = stack.pop()
+        if isinstance(command, click.Group):
+            stack.extend(command.commands.values())
+        if command.short_help and not command.help:
+            command.help = command.short_help
+
+
+# ---------------------------------------------------------------------------
+# CLI construction & entry point
+# ---------------------------------------------------------------------------
+
+# Commands belonging to jcli.  cliyard auto-registers ``auth`` (built-in)
+# and any global plugins found in ~/.cliyard/plugins/ (other projects), so
+# only whitelisted top-level commands are kept on the jcli command surface.
+_ALLOWED_TOP_LEVEL_COMMANDS = {
+    "job", "build", "node", "plugin", "credential", "pipeline", "view",
+    "system", "skills", "completion", "auth",
+}
+
+
+def _prune_non_jcli_commands(cli: click.Group) -> None:
+    """Drop top-level commands that are not part of jcli."""
+    for name in list(cli.commands.keys()):
+        if name not in _ALLOWED_TOP_LEVEL_COMMANDS:
+            cli.commands.pop(name)
+
+
+def _mask_token(token: str) -> str:
+    """Mask an API token for display (``abcd****wxyz``)."""
+    if len(token) > 8:
+        return f"{token[:4]}****{token[-4:]}"
+    return "****" if token else "-"
+
+
+def _add_jcli_auth_commands(cli: click.Group) -> None:
+    """Register the jcli-native ``auth`` command group.
+
+    Replaces cliyard's built-in ``auth``, which writes ``~/.cliyard/
+    credentials.yaml`` and is unrelated to jcli's actual authentication
+    source.  This group reads/writes ``~/.jcli/config.yaml`` through the
+    same :class:`jcli.sdk.config.Config` class as ``jcli config``, so the
+    two command families share a single configuration source.
+    """
+    import copy
+
+    from jcli.sdk.config import (
+        DEFAULT_CONFIG_TEMPLATE,
+        DEFAULT_PROFILE_NAME,
+        ProfileNotFoundError,
+        Config,
+    )
+
+    @click.group()
+    def auth() -> None:
+        """Manage Jenkins authentication profiles."""
+
+    def _get_config() -> Config:
+        return Config().load()
+
+    @auth.command("add")
+    @click.option("-n", "--name", default=DEFAULT_PROFILE_NAME, help="Profile name.")
+    @click.option("-u", "--username", required=True, help="Jenkins username.")
+    @click.option(
+        "-p",
+        "--password",
+        "api_token",
+        required=True,
+        help="Jenkins API token (Jenkins Basic Auth = username:token).",
+    )
+    @click.option("-e", "--endpoint", "url", required=True, help="Jenkins server URL.")
+    @click.option("--default", "set_default", is_flag=True, help="Set as the active profile.")
+    def auth_add(name: str, username: str, api_token: str, url: str, set_default: bool) -> None:
+        """Add (or update) an authentication profile in ~/.jcli/config.yaml."""
+        cfg = _get_config()
+        has_custom = any(p != DEFAULT_PROFILE_NAME for p in cfg.list_profiles())
+        cfg.add_profile(name=name, url=url, username=username, api_token=api_token)
+        if set_default or not has_custom:
+            cfg.set_active_profile(name)
+        click.echo(f"Profile '{name}' added ({'active' if cfg.get_active_profile_name() == name else 'inactive'}).")
+
+    @auth.command("status")
+    @click.pass_context
+    def auth_status(ctx: click.Context) -> None:
+        """List configured authentication profiles (tokens masked)."""
+        from jcli.sdk.output.formatter import get_formatter
+
+        fmt = get_formatter(ctx.find_root())
+        cfg = _get_config()
+        profiles = cfg.list_profiles()
+        active_name = cfg.get_active_profile_name()
+
+        if not profiles:
+            fmt.print_info("No profiles configured. Run 'jcli auth add' to create one.")
+            return
+
+        headers = ["Name", "URL", "Username", "Token", "Active"]
+        rows = []
+        for name, data in profiles.items():
+            rows.append(
+                [
+                    name,
+                    data.get("url", ""),
+                    data.get("username", ""),
+                    _mask_token(data.get("api_token", "")),
+                    "✓" if name == active_name else "",
+                ]
+            )
+        fmt.print_table(headers, rows, title="Profiles")
+
+    def _auth_use(profile: str) -> None:
+        cfg = _get_config()
+        try:
+            cfg.set_active_profile(profile)
+        except ProfileNotFoundError:
+            click.echo(f"Error: Profile '{profile}' not found", err=True)
+            available = ", ".join(cfg.list_profiles())
+            if available:
+                click.echo(f"Available profiles: {available}", err=True)
+            raise click.exceptions.Exit(1)
+        click.echo(f"Active profile set to '{profile}'")
+
+    @auth.command("use")
+    @click.argument("profile")
+    def auth_use(profile: str) -> None:
+        """Switch the active authentication profile."""
+        _auth_use(profile)
+
+    @auth.command("switch", hidden=True)
+    @click.argument("profile")
+    def auth_switch(profile: str) -> None:
+        """Alias of ``auth use``."""
+        _auth_use(profile)
+
+    @auth.command("rm")
+    @click.argument("name", required=False)
+    @click.option("--all", "clear_all", is_flag=True, help="Remove all profiles and reset to the default template.")
+    def auth_rm(name: str | None, clear_all: bool) -> None:
+        """Remove an authentication profile (or all with --all)."""
+        cfg = _get_config()
+        if name:
+            try:
+                cfg.remove_profile(name)
+            except ProfileNotFoundError:
+                click.echo(f"Error: Profile '{name}' not found", err=True)
+                raise click.exceptions.Exit(1)
+            click.echo(f"Profile '{name}' removed")
+        elif clear_all:
+            cfg._data = copy.deepcopy(DEFAULT_CONFIG_TEMPLATE)
+            cfg.save()
+            click.echo("All profiles removed, config reset to the default template.")
+        else:
+            active = cfg.get_active_profile_name()
+            click.echo(f"Active profile: {active} (use 'jcli auth rm NAME' or 'jcli auth rm --all')")
+
+    @auth.command("set")
+    @click.argument("name")
+    @click.argument("field", type=click.Choice(["url", "username", "api_token", "description"]))
+    @click.argument("value")
+    def auth_set(name: str, field: str, value: str) -> None:
+        """Set a configuration field (url/username/api_token/description) for a profile."""
+        cfg = _get_config()
+        try:
+            data = cfg.get_profile(name)
+        except ProfileNotFoundError:
+            click.echo(f"Error: Profile '{name}' not found", err=True)
+            raise click.exceptions.Exit(1)
+        data[field] = value
+        cfg.add_profile(
+            name=name,
+            url=data.get("url", ""),
+            username=data.get("username", ""),
+            api_token=data.get("api_token", ""),
+            description=data.get("description", ""),
+        )
+        click.echo(f"Updated profile '{name}': {field} = {value}")
+
+    @auth.command("show")
+    @click.argument("name", required=False)
+    def auth_show(name: str | None) -> None:
+        """Show profile details (default: active profile, token masked)."""
+        cfg = _get_config()
+        if name is None:
+            name = cfg.get_active_profile_name()
+        try:
+            data = cfg.get_profile(name)
+        except ProfileNotFoundError:
+            click.echo(f"Error: Profile '{name}' not found", err=True)
+            raise click.exceptions.Exit(1)
+        active_name = cfg.get_active_profile_name()
+        is_active = " (active)" if name == active_name else ""
+        click.echo(f"Profile: {name}{is_active}")
+        fields = [
+            ("url", "URL"),
+            ("username", "Username"),
+            ("api_token", "API Token"),
+            ("description", "Description"),
+        ]
+        for key, label in fields:
+            value = data.get(key, "")
+            display = _mask_token(value) if key == "api_token" else value
+            click.echo(f"  {label}: {display}")
+
+    cli.add_command(auth)
+
+
+def _build_cli(spec_dir: Path, server: str | None, profile: str | None) -> click.Group:
+    """Create the cliyard CLI and apply the jcli wrapper layer."""
+    base_url = resolve_base_url(server, profile)
+    cli = create_cli(str(spec_dir), version=__version__, base_url_override=base_url)
+    cli.commands.pop("auth", None)
+    _add_jcli_auth_commands(cli)
+    add_global_options(cli)
+    add_completion_command(cli)
+    wrap_subcommand_callbacks(cli)
+    set_group_help(cli)
+    _prune_non_jcli_commands(cli)
+    return cli
+
+
+def create_jcli_cli(argv: list[str] | None = None) -> click.Group:
+    """Build the jcli Click CLI from the YAML specs (wrapper included).
+
+    With *argv* left ``None`` the real ``sys.argv`` is used and
+    ``-s/--server`` is stripped from it (cliyard's runner pre-extraction).
+    Tests pass an explicit argv to avoid touching ``sys.argv``.
+    """
+    if argv is None:
+        argv = sys.argv[1:]
+        cleaned, server = extract_server_override(argv)
+        if cleaned != argv:
+            sys.argv = [sys.argv[0]] + cleaned
+        profile = extract_profile_override(cleaned)
+    else:
+        cleaned, server = extract_server_override(list(argv))
+        profile = extract_profile_override(argv)
+    return _build_cli(_default_spec_dir(), server, profile)
+
+
+def main() -> None:
     """CLI entry point."""
-    cli()
+    try:
+        cli = create_jcli_cli()
+    except Exception as exc:
+        click.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
+
+    try:
+        code = cli(standalone_mode=False)
+        sys.exit(code if code is not None else 0)
+    except SystemExit as e:
+        sys.exit(int(e.code) if e.code is not None else 0)
+    except click.exceptions.ClickException as exc:
+        click.echo(exc.format_message(), err=True)
+        sys.exit(exc.exit_code)
+    except Exception as exc:
+        click.echo(f"Error: {exc}", err=True)
+        sys.exit(1)
+
+
+class _LazyCLI:
+    """Lazy proxy so ``from jcli.cli import cli`` keeps working (tests/scripts).
+
+    Each access rebuilds the CLI from the current specs, so no stale state is
+    cached.  The real entry point is :func:`main` (console script target).
+    """
+
+    def __call__(self, *args: Any, **kwargs: Any) -> Any:
+        return create_jcli_cli(sys.argv[1:])(*args, **kwargs)
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(create_jcli_cli(sys.argv[1:]), name)
+
+
+cli = _LazyCLI()
 
 
 if __name__ == "__main__":

jcli/plugins/skills.py

@@ -59,9 +59,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 +73,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 +183,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 +216,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():
@@ -223,19 +258,27 @@ def list_cmd(ctx: click.Context, installed: bool, bundled: bool, install_dir: st
 
     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.")

jcli/skills/jcli/SKILL.md

@@ -30,7 +30,7 @@ jcli -f yaml job list     # YAML 输出
 
 | 技能 | 说明 |
 |------|------|
-| [jcli-config](config/SKILL.md) | 配置管理 - Jenkins 连接配置、多实例管理 |
+| [jcli-auth](auth/SKILL.md) | 认证配置管理 - Jenkins 连接 profile 添加、切换、查看、删除 |
 | [jcli-job](job/SKILL.md) | Job 管理 - Job 创建、删除、复制、启用/禁用 |
 | [jcli-build](build/SKILL.md) | 构建管理 - 构建触发、查看、停止、队列 |
 | [jcli-node](node/SKILL.md) | 节点管理 - Jenkins Agent 节点管理 |
@@ -40,6 +40,19 @@ jcli -f yaml job list     # YAML 输出
 | [jcli-view](view/SKILL.md) | 视图管理 - 视图创建、删除、查看 |
 | [jcli-system](system/SKILL.md) | 系统管理 - 系统信息、重启、安静模式 |
 
+## 认证配置（auth）
+
+```bash
+jcli auth add -n <name> -u <user> -p <token> -e <url>   # 添加配置（token 即 Jenkins API Token）
+jcli auth status                                        # 查看所有配置（token 掩码）
+jcli auth use <name>                                    # 切换 active profile
+jcli auth set <name> <field> <value>                    # 修改字段（url/username/api_token/description）
+jcli auth show [name]                                   # 查看单个配置详情
+jcli auth rm <name>                                     # 删除配置
+```
+
+详细用法见 [jcli-auth](auth/SKILL.md)。
+
 ## Skills 命令
 
 ```bash
@@ -70,4 +83,4 @@ jcli completion show fish                  # Fish 补全脚本
 
 - 源码: `/data/git-project/jcli`
 - 配置: `~/.jcli/config.yaml`
-- 技能文档: `/data/git-project/jcli/skills/jcli/`
+- 技能文档: `/data/git-project/jcli/jcli/skills/jcli/`

jcli/skills/jcli/auth/SKILL.md

@@ -0,0 +1,86 @@
+---
+name: jcli-auth
+version: 1.0.0
+description: |
+  jcli 认证配置管理 - 管理 Jenkins 连接 profile 的添加、切换、查看、删除等操作。
+allowed-tools:
+  - Bash
+  - Read
+---
+
+# jcli-auth
+
+管理 jcli 的认证配置 profile，支持多 Jenkins 实例。
+
+## 前提条件
+
+- Python >= 3.10
+- Jenkins 2.x 或更高版本
+- 已安装 jcli：`pip install -e /data/git-project/jcli`
+
+## 配置文件位置
+
+`~/.jcli/config.yaml`
+
+## 配置结构
+
+```yaml
+active_profile: default
+profiles:
+  default:
+    url: https://jenkins.example.com
+    username: admin
+    api_token: your-api-token-here
+    description: Default Jenkins instance
+```
+
+## 命令参考
+
+```bash
+jcli auth add -n <name> -u <user> -p <token> -e <url>   # 添加（或更新）配置
+jcli auth add -n <name> ... --default                   # 添加并设为 active profile
+jcli auth status                                        # 列出所有配置（token 掩码）
+jcli auth use <name>                                    # 切换 active profile
+jcli auth set <name> <field> <value>                    # 修改字段（url/username/api_token/description）
+jcli auth show [name]                                   # 查看单个配置详情（默认 active）
+jcli auth rm <name>                                     # 删除配置
+jcli auth rm --all                                      # 删除所有配置（重置为模板）
+```
+
+## 常见用例
+
+### 添加新 profile
+
+```bash
+jcli auth add -n dev -u admin -p your-api-token -e https://jenkins-dev.example.com
+```
+
+### 修改配置
+
+```bash
+jcli auth set dev api_token your-token
+jcli auth set dev description "Development Jenkins"
+```
+
+### 切换 profile
+
+```bash
+jcli auth use dev
+```
+
+### 查看配置
+
+```bash
+jcli auth status
+jcli auth show
+jcli auth show dev
+```
+
+## 环境变量覆盖
+
+| 变量 | 覆盖字段 |
+|------|---------|
+| `JCLI_URL` | url |
+| `JCLI_USERNAME` | username |
+| `JCLI_API_TOKEN` | api_token |
+| `JCLI_PROFILE` | active_profile |

jcli/skills/jcli/credential/SKILL.md

@@ -21,10 +21,12 @@ allowed-tools:
 ## 命令参考
 
 ```bash
-jcli credential list                       # 列出凭据
-jcli credential get <id>                   # 查看凭据详情
-jcli credential create <id> -f config.xml  # 从 XML 创建凭据
-jcli credential delete <id>                # 删除凭据
+jcli credential list [store] [domain]     # 列出凭据（默认 store=system, domain=_）
+jcli credential list --depth 2            # 递归列出凭据
+jcli credential get <id> [store]          # 查看凭据详情
+jcli credential create <config.xml> [store] [domain]  # 从 XML 文件创建凭据
+jcli credential update <config.xml> <id> [store]      # 更新凭据
+jcli credential delete <id> [store] [domain]          # 删除凭据
 ```
 
 ## 常见用例
@@ -43,5 +45,12 @@ jcli credential get my-credential-id
 
 ```bash
 # 从 XML 配置文件创建凭据
-jcli credential create my-credential-id -f credential-config.xml
+jcli credential create credential-config.xml
+```
+
+### 更新凭据
+
+```bash
+# 从 XML 文件更新已有凭据
+jcli credential update credential-config.xml my-credential-id
 ```

jcli/skills/jcli/job/SKILL.md

@@ -23,13 +23,16 @@ allowed-tools:
 ```bash
 jcli job list                              # 列出所有 Job
 jcli job get <name>                        # 查看 Job 详情
-jcli job create <name> -f config.xml       # 从 XML 创建 Job
-jcli job delete <name>                     # 删除 Job（需确认）
-jcli job delete <name> --yes               # 删除 Job（跳过确认）
+jcli job create <name> --config-file config.xml  # 从 XML 创建 Job
+jcli job delete <name>                     # 删除 Job
 jcli job copy <from> <to>                  # 复制 Job
+jcli job rename <old> <new>                # 重命名 Job
 jcli job enable <name>                     # 启用 Job
 jcli job disable <name>                    # 禁用 Job
 jcli job config <name>                     # 查看 Job XML 配置
+jcli job update <config.xml> <name>        # 用 XML 更新 Job 配置
+jcli job create-folder <name>              # 创建文件夹
+jcli job delete-folder <name>              # 删除文件夹（含内容）
 ```
 
 ## 常见用例
@@ -51,5 +54,18 @@ done
 ### 从 XML 创建 Job
 
 ```bash
-jcli job create my-new-job -f job-config.xml
+jcli job create my-new-job --config-file job-config.xml
+```
+
+### 参数化创建 Job
+
+```bash
+# 从 git 仓库创建 freestyle 构建
+jcli job create my-freestyle --job-type freestyle --git-url git@github.com:org/repo.git --git-branch main
+
+# 创建 Pipeline 构建（使用仓库根目录的 Jenkinsfile）
+jcli job create my-pipeline --job-type pipeline --git-url git@github.com:org/repo.git --script "pipeline { agent any; stages { stage('Build') { steps { echo 'hi' } } } }"
+
+# 定时构建
+jcli job create my-scheduled --job-type freestyle --git-url git@github.com:org/repo.git --cron "H/15 * * * *"
 ```

jcli/skills/jcli/node/SKILL.md

@@ -23,8 +23,10 @@ allowed-tools:
 ```bash
 jcli node list                             # 列出所有节点
 jcli node get <name>                       # 查看节点详情
+jcli node create <name>                    # 创建节点（JNLP 启动器）
+jcli node create <name> --num-executors 2 --remote-fs /data/jenkins --labels linux  # 指定参数创建
 jcli node delete <name>                    # 删除节点
-jcli node toggle <name> --message "维护"   # 节点离线
+jcli node toggle <name> --offline-message "维护"  # 节点离线（带原因）
 jcli node toggle <name>                    # 节点上线
 ```
 
@@ -34,7 +36,7 @@ jcli node toggle <name>                    # 节点上线
 
 ```bash
 # 节点离线（带维护原因）
-jcli node toggle agent-01 --message "系统升级维护"
+jcli node toggle agent-01 --offline-message "系统升级维护"
 
 # 节点恢复上线
 jcli node toggle agent-01

jcli/skills/jcli/pipeline/SKILL.md

@@ -23,7 +23,7 @@ allowed-tools:
 ```bash
 jcli pipeline stages <job> <build>         # 查看阶段信息
 jcli pipeline log <job> <build> <node-id>  # 查看步骤日志
-jcli pipeline validate -f Jenkinsfile      # 验证 Jenkinsfile
+jcli pipeline validate <Jenkinsfile>       # 验证 Jenkinsfile（位置参数，文件路径）
 jcli pipeline pending <job> <build>        # 查看待处理输入
 ```
 
@@ -46,8 +46,8 @@ jcli pipeline log my-job 42 15
 ### 验证 Jenkinsfile
 
 ```bash
-# 验证 Jenkinsfile 语法
-jcli pipeline validate -f Jenkinsfile
+# 验证 Jenkinsfile 语法（传入文件路径）
+jcli pipeline validate Jenkinsfile
 ```
 
 ### 查看待处理输入

jcli/skills/jcli/plugin/SKILL.md

@@ -25,7 +25,10 @@ jcli plugin list                           # 列出已安装插件
 jcli plugin get <name>                     # 查看插件详情
 jcli plugin install <name>                 # 安装插件
 jcli plugin install git@4.15.0             # 安装指定版本
+jcli plugin install <name1> <name2>        # 一次安装多个插件
 jcli plugin uninstall <name>               # 卸载插件
+jcli plugin restart <name>                 # 重启插件
+jcli plugin check-updates                  # 检查插件更新
 ```
 
 ## 常见用例

jcli/skills/jcli/system/SKILL.md

@@ -27,7 +27,10 @@ jcli system restart                        # 安全重启 Jenkins
 jcli system quiet-down                     # 进入安静模式
 jcli system quiet-down --reason "维护"     # 带原因的安静模式
 jcli system cancel-quiet-down              # 取消安静模式
-jcli system script "println('hello')"      # 执行 Groovy 脚本
+jcli system script <script>                # 执行 Groovy 脚本（位置参数）
+jcli system users                          # 列出所有 Jenkins 用户
+jcli system token <username>               # 为用户生成 API token
+jcli system token <username> --token-name <name>  # 指定 token 名称
 ```
 
 ## 常见用例
@@ -62,9 +65,19 @@ jcli system restart
 ### 执行 Groovy 脚本
 
 ```bash
-# 执行简单的 Groovy 脚本
+# 执行简单的 Groovy 脚本（SCRIPT 为位置参数）
 jcli system script "println('Hello from jcli')"
 
 # 获取所有节点信息
 jcli system script "Jenkins.instance.computers.each { println it.name }"
 ```
+
+### 用户与 Token
+
+```bash
+# 列出所有用户
+jcli system users
+
+# 为指定用户生成 API token
+jcli system token admin
+```

jcli/skills/jcli/view/SKILL.md

@@ -23,7 +23,8 @@ allowed-tools:
 ```bash
 jcli view list                             # 列出所有视图
 jcli view get <name>                       # 查看视图详情
-jcli view create <name> -f config.xml      # 从 XML 创建视图
+jcli view create <config.xml> <name>       # 从 XML 文件创建视图（XML 在前，名称在后）
+jcli view update <config.xml> <name>       # 用 XML 更新视图配置
 jcli view delete <name>                    # 删除视图
 ```
 
@@ -42,6 +43,6 @@ jcli view get my-view
 ### 创建视图
 
 ```bash
-# 从 XML 配置文件创建视图
-jcli view create my-view -f view-config.xml
+# 从 XML 配置文件创建视图（XML 文件路径在前，视图名在后）
+jcli view create view-config.xml my-view
 ```

{python_jcli-0.1.0.dist-info → python_jcli-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-jcli
-Version: 0.1.0
+Version: 1.0.0
 Summary: Python Jenkins CLI tool
 License: MIT
 Requires-Python: >=3.10
@@ -9,6 +9,7 @@ Requires-Dist: click>=8.1.0
 Requires-Dist: requests~=2.31.0
 Requires-Dist: pyyaml~=6.0.1
 Requires-Dist: rich>=13.7.1
+Requires-Dist: cliyard>=0.6.0
 Provides-Extra: dev
 Requires-Dist: pytest>=7.0; extra == "dev"
 Requires-Dist: pytest-cov>=4.0; extra == "dev"
@@ -23,10 +24,37 @@ A command-line tool for managing Jenkins servers. jcli wraps the Jenkins REST AP
 ## Features
 
 - **8 command modules** covering jobs, builds, nodes, plugins, credentials, pipelines, views, and system management
+- **Spec-driven CLI**: commands are declared as cliyard YAML specs in `specs/` and generated at runtime, no hand-written Click groups
 - **Multiple output formats**: human-readable tables (default, via Rich), JSON, and YAML
 - **Multi-profile support** via `~/.jcli/config.yaml` with environment variable overrides
 - **Automatic CSRF (Crumb) handling** for Jenkins servers with CSRF protection enabled
-- **Built with Click and Rich** for a polished terminal experience
+- **Built on cliyard and Rich** for a polished, maintainable terminal experience
+
+## Architecture
+
+jcli 2.0 is driven by [cliyard](https://pypi.org/project/cliyard/) YAML specs instead of hand-written Click command groups. At startup, `jcli/cli.py` locates the spec directory (`JCLI_SPEC_DIR` env var > package-local `specs/` > repo-root `specs/`) and calls `cliyard.runtime.create_cli()` to build the whole command tree. Commands stay declarative: adding or changing a command is an edit to a YAML file, not Python plumbing.
+
+```
+specs/
+  _auth.yaml          Server auth chain (basic auth + crumb, as cliyard plugins)
+  resources/          One YAML spec per Jenkins domain
+    job.yaml          job list/get/create/config/copy/enable/disable/delete
+    build.yaml        build list/get/trigger/replay/log/stop/queue
+    node.yaml         node list/get/delete/toggle
+    plugin.yaml       plugin list/get/install/uninstall
+    credential.yaml   credential list/get/create/delete
+    pipeline.yaml     pipeline stages/log/pending/validate
+    view.yaml         view list/get/create/delete
+    system.yaml       system info/load/quiet-down/restart/script
+  plugins/            Python method plugins for non-trivial logic
+    jenkins_auth.py         Basic + crumb authentication
+    jenkins_methods.py      Build trigger/replay, node create
+    jenkins_pipeline_validate.py  Jenkinsfile validation
+    jenkins_plugin.py       Plugin install/uninstall/update-center
+    jenkins_system.py       Groovy script, quiet-down, restart
+```
+
+A resource spec maps a command name to either a plain HTTP call (method, path, params, output mapping) or a `plugin:` reference. The auth chain in `_auth.yaml` injects `Authorization` and crumb headers into every request.
 
 ## Requirements
 
@@ -147,6 +175,21 @@ Every command accepts these global flags before the subcommand:
 -s, --server TEXT               Jenkins server URL
 ```
 
+### auth — Manage authentication profiles
+
+Profiles are stored in `~/.jcli/config.yaml` (token shown masked).
+
+```
+jcli auth add -n NAME -u USER -p TOKEN -e URL     Add (or update) a profile
+jcli auth add -n NAME ... --default               ... and make it active
+jcli auth status                                  List profiles (tokens masked)
+jcli auth use NAME                                Switch the active profile
+jcli auth rm NAME                                 Remove a profile
+jcli auth rm --all                                Remove all profiles (reset template)
+jcli auth set NAME FIELD VALUE                    Set url/username/api_token/description
+jcli auth show [NAME]                             Show a profile's details (default: active)
+```
+
 ### job — Manage Jenkins jobs
 
 ```
@@ -166,6 +209,9 @@ jcli job delete JOB_NAME                    Delete a job
 jcli build list JOB_NAME                    List recent builds for a job
 jcli build get JOB_NAME BUILD_NUMBER        Show details for a specific build
 jcli build trigger JOB_NAME                 Trigger a new build
+jcli build rebuild JOB_NAME BUILD_NUMBER  Rebuild reusing previous parameters
+jcli build rebuild JOB_NAME BUILD_NUMBER --set KEY=VAL   ... and override values (repeatable)
+jcli build replay JOB_NAME BUILD_NUMBER JENKINSFILE   Replay a build with a custom Jenkinsfile
 jcli build log JOB_NAME BUILD_NUMBER        Show console log for a build
 jcli build stop JOB_NAME BUILD_NUMBER       Stop a running build
 jcli build queue                            Show the current build queue
@@ -268,23 +314,20 @@ pytest --cov=jcli --cov-report=term-missing
 
 ```
 jcli/
-  cli.py              Main CLI entry point (Click group)
+  cli.py              Entry point: builds the Click CLI from cliyard YAML specs
+  cli_helpers.py      Global option injection and profile/format plumbing
   __init__.py         Version
-  plugins/            Command modules (one per Jenkins domain)
-    job.py
-    build.py
-    node.py
-    plugin.py
-    credential.py
-    pipeline.py
-    view.py
-    system.py
+  plugins/            Legacy hand-written command modules (kept for SDK compatibility)
   sdk/                Shared libraries
     client.py         Jenkins REST API client (HTTP, auth, crumb)
     config.py         Configuration management (YAML, env vars)
     output/
       formatter.py    Table/JSON/YAML output formatting
     exceptions.py     Typed exceptions
+specs/                cliyard YAML specs (command definitions)
+  _auth.yaml          Auth chain: basic + crumb plugins
+  resources/          One YAML per Jenkins domain (job, build, node, ...)
+  plugins/            Python method plugins for non-trivial logic
 tests/                pytest test suite
 ```
 
@@ -293,6 +336,7 @@ tests/                pytest test suite
 | Package          | Purpose                     |
 |-----------------|-----------------------------|
 | click >= 8.1.0   | CLI framework               |
+| cliyard >= 0.6.0 | Spec-driven CLI engine (YAML command generation) |
 | requests ~= 2.31 | HTTP client                 |
 | pyyaml ~= 6.0.1  | YAML config parsing         |
 | rich >= 13.7.1   | Terminal formatting (tables) |

{python_jcli-0.1.0.dist-info → python_jcli-1.0.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
-jcli/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+jcli/__init__.py,sha256=J-j-u0itpEFT6irdmWmixQqYMadNl1X91TxUmoiLHMI,22
 jcli/__main__.py,sha256=ARL8XYr45T4pIf0gnyCCbK8uljcn1LF7TKcFapxHt_k,34
-jcli/cli.py,sha256=Ep6OFwyx4eVdbMbVcXrebPboMQuXarkYuxTILTst3eM,2135
+jcli/cli.py,sha256=cg45uwYAW2IsdilPffCBSWK7RE2ragnKJ2xiYp9_m94,21175
 jcli/cli_helpers.py,sha256=8GsvEwmaqS8p9Rpx7d_b3_i_Pwag8zsJNNbunxgNXS0,1831
 jcli/plugins/__init__.py,sha256=I6vTpfYO3gIwHoNu5V-sOIdpT_g-bAy4RXR3TW3-k1U,1054
 jcli/plugins/build.py,sha256=60F0UPMFy_eZznBeAIM0XwCcQ3pAuJJjacGaCXxOlcI,6032
@@ -10,7 +10,7 @@ jcli/plugins/job.py,sha256=dq5jbAn8ZjtYNqJlo7u-0iORubMdZMB2sj4GVK01xoU,12872
 jcli/plugins/node.py,sha256=nwUDYvev9R_BOoYHVmNvNp3vhrmZAXVFN2z_-F_iO7I,4776
 jcli/plugins/pipeline.py,sha256=vTtLk0tPiMSwy2CsCEmtQMhbt9baFoxAqGCSyHtOmOc,3049
 jcli/plugins/plugin.py,sha256=0LMaPjr5jpZokOLENt0rDi_Klk4JYcw8uUzZUceDYvk,4713
-jcli/plugins/skills.py,sha256=WAJJN9_r9kgS2FCjoZeeQZhTrU9ZF0zUu3wpLwniHs4,13177
+jcli/plugins/skills.py,sha256=5Nw3kPLbx82-8ackdXVLnIL09jziv53jhMZ2sCqYihk,14921
 jcli/plugins/system.py,sha256=2ojwBOsaiuNKmuiTLvU6GpLeSI3-kccy1QjpHuX_8vE,4938
 jcli/plugins/view.py,sha256=eH7pCe7Tw1rC4kVBZDxHqVd3ZrXYLlVxNGPjWvhgw8Q,4475
 jcli/sdk/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -28,17 +28,17 @@ jcli/sdk/system.py,sha256=L5PHlrjs-5_PFFOQ9IBA-vMwgQyqq33TfJidTcs0VSQ,6022
 jcli/sdk/view.py,sha256=5Poo50l3eY9ivef3hs0CyL-K39qDk39XQuX7gEHHRlA,2300
 jcli/sdk/output/__init__.py,sha256=Rt0F77oq24tqHvTDV4HyWKAjDtOyPOh9m7ucFy7B77s,70
 jcli/sdk/output/formatter.py,sha256=OUjQxeD-2iSNncuuRaLa01qLi899ux3F39KNkc8ik2Q,3876
-jcli/skills/jcli/SKILL.md,sha256=DM471dAnNguIzQKHMEBG3u6YafEzh9j3MesR8facQNQ,2384
-jcli/skills/jcli/config/SKILL.md,sha256=AHGfoitHRNPI0PyfKNrmOAG-k55RQOUacrDPfHiVDrI,1728
-jcli/skills/jcli/credential/SKILL.md,sha256=vOo2HWoVwv1IeQqALe7nOhwZ-qp4uLabanB4L8y14h8,943
-jcli/skills/jcli/job/SKILL.md,sha256=x8ytgCuHbwG1sspwLhzsd06AW4nw5M42ioHFqJi8yd8,1322
-jcli/skills/jcli/node/SKILL.md,sha256=E_r4aYjIr213qiTS6KGz08tV08hdsc8tlIzKZucrsts,1034
-jcli/skills/jcli/pipeline/SKILL.md,sha256=0cffcYTy-FzlqffosR-adSR7zne3Yfq08TEn1Yd6eCY,1177
-jcli/skills/jcli/plugin/SKILL.md,sha256=ybzQacz2-k0H9sTm4CwAEG40unT-Ndx1ngFrSv19KwA,986
-jcli/skills/jcli/system/SKILL.md,sha256=d2EkJSQnjaZFQ2MHWniHPxpHLGtZ9iDVy3jC2zev4zw,1538
-jcli/skills/jcli/view/SKILL.md,sha256=e-huIcHxr-A3tKFUkjQIV6mT2O9RKlSmEJ6HJ9NylyI,895
-python_jcli-0.1.0.dist-info/METADATA,sha256=1FUFhHyJ7BY_SC8xws-JjdaXFSBXsuQellAgHE90OWk,9276
-python_jcli-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
-python_jcli-0.1.0.dist-info/entry_points.txt,sha256=g-Gb8voGH3Ru4NEoCUMJXJiMZMapdAfYi6Xt1phyFi4,39
-python_jcli-0.1.0.dist-info/top_level.txt,sha256=WFqrbWSEfhvQfbN2m-_Wi5KKCwv1_23LhzPUqo7AdQc,5
-python_jcli-0.1.0.dist-info/RECORD,,
+jcli/skills/jcli/SKILL.md,sha256=X9xHxRvNa4F3hUN8bhckBXAJZx2MWY58hGqqd0y158M,3040
+jcli/skills/jcli/auth/SKILL.md,sha256=4_DLD51SwKTXh2Xi0UiQbqG4uXw7qIKv2SOOopS2Qn0,1996
+jcli/skills/jcli/credential/SKILL.md,sha256=3VsVdGalsIySvGfFO79IdL0b5OjF7kJBS9_4P56Wt2A,1244
+jcli/skills/jcli/job/SKILL.md,sha256=bmGyiyLXS2n395bA31gehcMRe094SUBq-FzUlUDvpQM,2066
+jcli/skills/jcli/node/SKILL.md,sha256=k4qi6ApspdIlBcxb0v2ItPrPwT7d9AnFq4N-vGhGcqY,1247
+jcli/skills/jcli/pipeline/SKILL.md,sha256=kUwnxBCUx53zi7efVgtJg9ainO-YuX3griaCqoUyzxU,1231
+jcli/skills/jcli/plugin/SKILL.md,sha256=--1t5LekIHAtnCWUnsQ9BKkPIgAQ7n-p7_QGd8H2jbI,1178
+jcli/skills/jcli/system/SKILL.md,sha256=SHdcLbaJyifjt4KJlmdcHdYLsFGwpF-6lqiWdYpw3co,1932
+jcli/skills/jcli/view/SKILL.md,sha256=f2QZEzvFocIlR7Yh0RKnp5y4sijwUJU_1fxiW7gKJcA,1047
+python_jcli-1.0.0.dist-info/METADATA,sha256=9A7W8m365rFW8_iTXqwPA9VFDE-YUmNvdLR-7BKH7qs,12497
+python_jcli-1.0.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+python_jcli-1.0.0.dist-info/entry_points.txt,sha256=g-Gb8voGH3Ru4NEoCUMJXJiMZMapdAfYi6Xt1phyFi4,39
+python_jcli-1.0.0.dist-info/top_level.txt,sha256=WFqrbWSEfhvQfbN2m-_Wi5KKCwv1_23LhzPUqo7AdQc,5
+python_jcli-1.0.0.dist-info/RECORD,,

{python_jcli-0.1.0.dist-info → python_jcli-1.0.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (82.0.1)
+Generator: setuptools (83.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

jcli/skills/jcli/config/SKILL.md

@@ -1,81 +0,0 @@
----
-name: jcli-config
-version: 1.0.0
-description: |
-  jcli 配置管理 - 管理 Jenkins 连接配置，支持多实例管理。
-allowed-tools:
-  - Bash
-  - Read
----
-
-# jcli-config
-
-管理 jcli 的连接配置，支持多 Jenkins 实例。
-
-## 前提条件
-
-- Python >= 3.10
-- Jenkins 2.x 或更高版本
-- 已安装 jcli：`pip install -e /data/git-project/jcli`
-
-## 初始化配置
-
-```bash
-jcli config init
-```
-
-## 配置文件位置
-
-`~/.jcli/config.yaml`
-
-## 配置结构
-
-```yaml
-active_profile: default
-profiles:
-  default:
-    url: https://jenkins.example.com
-    username: admin
-    api_token: your-api-token-here
-    description: Default Jenkins instance
-```
-
-## 多实例管理
-
-```bash
-# 添加新 profile
-jcli config add dev --url https://jenkins-dev.example.com --username admin
-
-# 修改配置
-jcli config set dev api_token your-token
-jcli config set dev description "Development Jenkins"
-
-# 切换 profile
-jcli config use dev
-
-# 查看配置
-jcli config show
-jcli config list
-```
-
-## 环境变量覆盖
-
-| 变量 | 覆盖字段 |
-|------|---------|
-| `JCLI_URL` | url |
-| `JCLI_USERNAME` | username |
-| `JCLI_API_TOKEN` | api_token |
-| `JCLI_PROFILE` | active_profile |
-
-## 命令参考
-
-```bash
-jcli config init                           # 初始化配置文件
-jcli config show                           # 查看当前配置
-jcli config show --profile dev             # 查看指定 profile
-jcli config list                           # 列出所有 profiles
-jcli config add <name> --url URL           # 添加新 profile
-jcli config set <name> <field> <value>     # 修改配置
-jcli config use <name>                     # 切换 active profile
-jcli config delete <name>                  # 删除 profile
-```