swisscli 0.1.0__tar.gz

swisscli-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.py[cod]
+*$py.class
+*.egg-info/
+dist/
+build/
+.venv/

swisscli-0.1.0/AGENTS.md

@@ -0,0 +1,73 @@
+# swisscli — AGENTS.md
+
+## Build, install, test
+
+```bash
+pip install -e .                                    # editable install
+python -m build                                     # sdist + wheel
+python -m build && pip install dist/swisscli-0.1.0-py3-none-any.whl --force-reinstall
+swisscli --help                                     # verify
+```
+
+No test framework, no lint, no typecheck — manual verification only.
+
+## Architecture
+
+- **`cli.py`** — single Click command with `help_option_names=[]` and `ignore_unknown_options=True`. All args via `nargs=-1`. `--help`/`--version` handled in user code (lines 25-55), not by Click.
+- **`plugin.py`** — `Plugin` ABC, `Subcommand` (prefix/suffix args), `ArgMapper` (flag aliases), `PluginRegistry` (singleton dict keyed by `name`).
+- **`loader.py`** — `discover_plugins()` uses `pkgutil.walk_packages` over `swisscli.plugins`. Every subpackage is scanned. Any module with a top-level `plugin` attribute is registered.
+- **`__init__.py`** — version from `importlib.metadata` with fallback to `"0.1.0"`.
+
+## Discovery & registration
+
+- Plugin modules go under `src/swisscli/plugins/<category>/<tool>.py`.
+- Every plugin module **must** export `plugin = ClassName()` at module level — this is the sole discovery contract.
+- Categories are not hardcoded; they come from each plugin's `category` property.
+- Existing categories: `web-cli` (curl, wget), `ssl` (openssl, ssh-keygen), `package` (apt, dnf, yum, dpkg, rpm).
+
+## Two plugin patterns
+
+**Simple flag mapping** — override `arg_mapper` property, args pass through:
+```python
+class CurlPlugin(Plugin):
+    name = "curl"
+    category = "web-cli"
+    @property
+    def arg_mapper(self):
+        return ArgMapper({"--insecure": "-k"})
+plugin = CurlPlugin()
+```
+
+**Subcommand-based** — override `subcommands` property. Each `Subcommand` has `prefix_args` (inserted between tool name and user args) and optional `suffix_args` / `arg_mapper`:
+```python
+class OpenSslPlugin(Plugin):
+    name = "openssl"
+    category = "ssl"
+    @property
+    def subcommands(self):
+        return {
+            "show": Subcommand(
+                name="show", description="Show certificate details",
+                prefix_args=["x509", "-in"], suffix_args=["-text", "-noout"],
+            ),
+        }
+plugin = OpenSslPlugin()
+```
+
+## Fallback
+
+If `shutil.which(tool_name)` fails, `execute()` scans `PluginRegistry.all()` for another plugin in the **same `category`** that is available. First match wins (insertion order). Prints fallback notice to stderr.
+
+Example: on Debian, `swisscli dnf install curl` → `'dnf' not found, falling back to 'apt'`.
+
+## Help system
+
+- `swisscli --help` — tools grouped by category
+- `swisscli <tool> --help` — subcommands + arg mappings
+- `swisscli <tool> <subcommand> --help` — subcommand details + "Runs:" command preview
+- `--help` is handled manually in `cli.py`, not by Click. Unknown options pass through silently.
+
+## Style
+
+- No docstrings or comments in code.
+- `from __future__ import annotations` at top of `plugin.py`.

swisscli-0.1.0/PKG-INFO

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: swisscli
+Version: 0.1.0
+Summary: A plugin-based CLI wrapper ecosystem for common command-line tools
+Project-URL: Homepage, https://github.com/yourusername/swisscli
+Author-email: Your Name <you@example.com>
+License: MIT
+Requires-Python: >=3.9
+Requires-Dist: click>=8.0
+Description-Content-Type: text/markdown
+
+# swisscli
+
+A plugin-based CLI wrapper ecosystem for common command-line tools. swisscli wraps native tools like `curl`, `wget`, `openssl`, `ssh-keygen`, `apt`, `dnf`, `yum`, `dpkg`, and `rpm`, providing consistent argument naming, subcommand interfaces, and automatic fallback between tools in the same category.
+
+## Installation
+
+```bash
+git clone https://github.com/agonzalezrh/swisscli.git
+cd swisscli
+pip install .
+```
+
+Or install directly:
+
+```bash
+pip install swisscli
+```
+
+## Usage
+
+```bash
+swisscli --help                    # list tools grouped by category
+swisscli --version                 # show version
+swisscli <tool> --help             # tool-specific help
+swisscli <tool> <subcommand> --help  # subcommand details
+swisscli <tool> [ARGS]...          # run a tool
+```
+
+## Available tools
+
+### web-cli
+
+| Tool | Description |
+|------|-------------|
+| `curl` | HTTP requests with long-flag aliases (`--insecure` → `-k`, `--silent` → `-s`, `--location` → `-L`, etc.) |
+| `wget` | File downloads with long-flag aliases (`--insecure` → `--no-check-certificate`, `--quiet` → `-q`, etc.) |
+
+```bash
+swisscli curl --insecure --location https://example.com
+swisscli wget --output file.zip https://example.com/file.zip
+```
+
+### ssl
+
+| Tool | Subcommands | Description |
+|------|-------------|-------------|
+| `openssl` | `show`, `generate` | OpenSSL certificate toolkit |
+| `ssh-keygen` | `show`, `generate` | SSH key management tool |
+
+```bash
+swisscli openssl show cert.pem
+swisscli openssl generate --days 730 --out mycert.pem
+swisscli ssh-keygen show ~/.ssh/id_rsa
+swisscli ssh-keygen generate --type ed25519 --file mykey
+```
+
+### package
+
+| Tool | Subcommands | Description |
+|------|-------------|-------------|
+| `apt` | `install`, `remove`, `search`, `list` | Debian/Ubuntu package manager |
+| `dnf` | `install`, `remove`, `search`, `list` | RPM package manager (modern) |
+| `yum` | `install`, `remove`, `search`, `list` | RPM package manager (legacy) |
+| `dpkg` | `list`, `info`, `search`, `contents` | Debian low-level package manager |
+| `rpm` | `list`, `info`, `search`, `files` | RPM low-level package manager |
+
+```bash
+swisscli apt install curl
+swisscli apt remove --purge firefox
+swisscli apt search build-essential
+swisscli dpkg list
+swisscli dpkg info bash
+swisscli rpm list
+swisscli rpm files coreutils
+```
+
+## Fallback behavior
+
+If a tool binary is not found on the system, swisscli automatically falls back to another tool in the same category. For example, running `swisscli dnf install curl` on a Debian system will fall back to `apt install curl`. The fallback notice is printed to stderr.
+
+## Adding your own plugin
+
+Create a file at `src/swisscli/plugins/<category>/<tool>.py`. Define a `Plugin` subclass with a `name`, `description`, and `category`. Export a module-level `plugin = MyPlugin()` instance — auto-discovery picks it up on next run.
+
+Two patterns:
+- **Simple flag mapping** — override `arg_mapper` for long-flag aliases
+- **Subcommand-based** — override `subcommands` dict with `Subcommand` objects (prefix args, suffix args, optional arg mapper)
+
+## Architecture
+
+- **Plugin** — base class wrapping a CLI tool (argument mapping, execution, fallback)
+- **ArgMapper** — translates user-friendly long flags to native tool flags
+- **Subcommand** — defines prefix/suffix args injected between tool name and user args
+- **PluginRegistry** — singleton registry discovered automatically via `pkgutil.walk_packages`
+- **Categories** — plugins grouped by domain; fallback operates within the same category

swisscli-0.1.0/README.md

@@ -0,0 +1,95 @@
+# swisscli
+
+A plugin-based CLI wrapper ecosystem for common command-line tools. swisscli wraps native tools like `curl`, `wget`, `openssl`, `ssh-keygen`, `apt`, `dnf`, `yum`, `dpkg`, and `rpm`, providing consistent argument naming, subcommand interfaces, and automatic fallback between tools in the same category.
+
+## Installation
+
+```bash
+git clone https://github.com/agonzalezrh/swisscli.git
+cd swisscli
+pip install .
+```
+
+Or install directly:
+
+```bash
+pip install swisscli
+```
+
+## Usage
+
+```bash
+swisscli --help                    # list tools grouped by category
+swisscli --version                 # show version
+swisscli <tool> --help             # tool-specific help
+swisscli <tool> <subcommand> --help  # subcommand details
+swisscli <tool> [ARGS]...          # run a tool
+```
+
+## Available tools
+
+### web-cli
+
+| Tool | Description |
+|------|-------------|
+| `curl` | HTTP requests with long-flag aliases (`--insecure` → `-k`, `--silent` → `-s`, `--location` → `-L`, etc.) |
+| `wget` | File downloads with long-flag aliases (`--insecure` → `--no-check-certificate`, `--quiet` → `-q`, etc.) |
+
+```bash
+swisscli curl --insecure --location https://example.com
+swisscli wget --output file.zip https://example.com/file.zip
+```
+
+### ssl
+
+| Tool | Subcommands | Description |
+|------|-------------|-------------|
+| `openssl` | `show`, `generate` | OpenSSL certificate toolkit |
+| `ssh-keygen` | `show`, `generate` | SSH key management tool |
+
+```bash
+swisscli openssl show cert.pem
+swisscli openssl generate --days 730 --out mycert.pem
+swisscli ssh-keygen show ~/.ssh/id_rsa
+swisscli ssh-keygen generate --type ed25519 --file mykey
+```
+
+### package
+
+| Tool | Subcommands | Description |
+|------|-------------|-------------|
+| `apt` | `install`, `remove`, `search`, `list` | Debian/Ubuntu package manager |
+| `dnf` | `install`, `remove`, `search`, `list` | RPM package manager (modern) |
+| `yum` | `install`, `remove`, `search`, `list` | RPM package manager (legacy) |
+| `dpkg` | `list`, `info`, `search`, `contents` | Debian low-level package manager |
+| `rpm` | `list`, `info`, `search`, `files` | RPM low-level package manager |
+
+```bash
+swisscli apt install curl
+swisscli apt remove --purge firefox
+swisscli apt search build-essential
+swisscli dpkg list
+swisscli dpkg info bash
+swisscli rpm list
+swisscli rpm files coreutils
+```
+
+## Fallback behavior
+
+If a tool binary is not found on the system, swisscli automatically falls back to another tool in the same category. For example, running `swisscli dnf install curl` on a Debian system will fall back to `apt install curl`. The fallback notice is printed to stderr.
+
+## Adding your own plugin
+
+Create a file at `src/swisscli/plugins/<category>/<tool>.py`. Define a `Plugin` subclass with a `name`, `description`, and `category`. Export a module-level `plugin = MyPlugin()` instance — auto-discovery picks it up on next run.
+
+Two patterns:
+- **Simple flag mapping** — override `arg_mapper` for long-flag aliases
+- **Subcommand-based** — override `subcommands` dict with `Subcommand` objects (prefix args, suffix args, optional arg mapper)
+
+## Architecture
+
+- **Plugin** — base class wrapping a CLI tool (argument mapping, execution, fallback)
+- **ArgMapper** — translates user-friendly long flags to native tool flags
+- **Subcommand** — defines prefix/suffix args injected between tool name and user args
+- **PluginRegistry** — singleton registry discovered automatically via `pkgutil.walk_packages`
+- **Categories** — plugins grouped by domain; fallback operates within the same category

swisscli-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "swisscli"
+version = "0.1.0"
+description = "A plugin-based CLI wrapper ecosystem for common command-line tools"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+    {name = "Your Name", email = "you@example.com"},
+]
+requires-python = ">=3.9"
+dependencies = [
+    "click>=8.0",
+]
+
+[project.scripts]
+swisscli = "swisscli.cli:main"
+
+[project.urls]
+Homepage = "https://github.com/yourusername/swisscli"

swisscli-0.1.0/src/swisscli/__init__.py

@@ -0,0 +1,5 @@
+try:
+    from importlib.metadata import version as _version
+    __version__ = _version("swisscli")
+except Exception:
+    __version__ = "0.1.0"

swisscli-0.1.0/src/swisscli/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

swisscli-0.1.0/src/swisscli/cli.py

@@ -0,0 +1,74 @@
+import sys
+
+import click
+
+from . import __version__
+from .loader import discover_plugins
+from .plugin import PluginRegistry
+
+
+@click.command(context_settings=dict(
+    help_option_names=[],
+    ignore_unknown_options=True,
+))
+@click.argument("args", nargs=-1)
+def main(args):
+    """swisscli - CLI wrapper ecosystem."""
+
+    discover_plugins()
+
+    if not args:
+        click.echo("Usage: swisscli <tool> [ARGS]...")
+        click.echo("       swisscli --help")
+        sys.exit(1)
+
+    if args[0] in ("--help", "-h"):
+        _show_help()
+        return
+
+    if args[0] in ("--version", "-V"):
+        click.echo(f"swisscli version {__version__}")
+        return
+
+    tool = args[0]
+    tool_args = list(args[1:])
+
+    if tool_args and tool_args[0] in ("--help", "-h"):
+        plugin = PluginRegistry.get(tool)
+        if plugin:
+            click.echo(plugin.format_help())
+        else:
+            click.echo(f"Unknown tool: {tool}", err=True)
+        return
+
+    plugin = PluginRegistry.get(tool)
+    if plugin is None:
+        click.echo(f"Error: unknown tool '{tool}'", err=True)
+        click.echo("Run 'swisscli --help' for available tools.")
+        sys.exit(1)
+
+    if tool_args and tool_args[0] in plugin.subcommands:
+        sub_name = tool_args[0]
+        sub_args = tool_args[1:]
+        if sub_args and sub_args[0] in ("--help", "-h"):
+            click.echo(plugin.format_subcommand_help(plugin.subcommands[sub_name]))
+            return
+
+    sys.exit(plugin.execute(tool_args))
+
+
+def _show_help():
+    by_category = PluginRegistry.by_category()
+
+    click.echo("Usage: swisscli <tool> [ARGS]...")
+    click.echo()
+    click.echo("Available tools:")
+    click.echo()
+    for category in sorted(by_category):
+        tools = by_category[category]
+        click.echo(f"  {category}:")
+        for name in sorted(tools):
+            plugin = tools[name]
+            click.echo(f"    {name:<12} {plugin.description}")
+        click.echo()
+    click.echo("Run 'swisscli <tool> --help' for tool-specific help.")

swisscli-0.1.0/src/swisscli/loader.py

@@ -0,0 +1,30 @@
+import importlib
+import pkgutil
+import warnings
+
+from .plugin import PluginRegistry
+
+
+def _import_module(modname: str):
+    try:
+        return importlib.import_module(modname)
+    except Exception as exc:
+        warnings.warn(f"Failed to load plugin module '{modname}': {exc}")
+        return None
+
+
+def discover_plugins() -> None:
+    import swisscli.plugins as plugins_pkg
+
+    prefix = plugins_pkg.__name__ + "."
+    seen = set()
+
+    for importer, modname, ispkg in pkgutil.walk_packages(
+        plugins_pkg.__path__, prefix=prefix
+    ):
+        if ispkg or modname in seen:
+            continue
+        seen.add(modname)
+        mod = _import_module(modname)
+        if mod is not None and hasattr(mod, "plugin"):
+            PluginRegistry.register(mod.plugin)

swisscli-0.1.0/src/swisscli/plugin.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+import sys
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional
+
+import click
+
+
+class ArgMapper:
+    def __init__(self, mapping: Dict[str, str]):
+        self._mapping = mapping
+
+    def translate(self, args: List[str]) -> List[str]:
+        result = []
+        for arg in args:
+            result.append(self._mapping.get(arg, arg))
+        return result
+
+
+class Subcommand:
+    def __init__(
+        self,
+        name: str,
+        description: str,
+        prefix_args: Optional[List[str]] = None,
+        suffix_args: Optional[List[str]] = None,
+        arg_mapper: Optional[ArgMapper] = None,
+    ):
+        self.name = name
+        self.description = description
+        self.prefix_args = prefix_args or []
+        self.suffix_args = suffix_args or []
+        self.arg_mapper = arg_mapper
+
+    def translate_args(self, args: List[str]) -> List[str]:
+        if self.arg_mapper:
+            return self.arg_mapper.translate(args)
+        return list(args)
+
+    def build_command(self, tool_name: str, args: List[str]) -> List[str]:
+        return [tool_name, *self.prefix_args, *self.translate_args(args), *self.suffix_args]
+
+
+class Plugin(ABC):
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        ...
+
+    @property
+    @abstractmethod
+    def description(self) -> str:
+        ...
+
+    @property
+    def category(self) -> str:
+        return "general"
+
+    @property
+    def arg_mapper(self) -> Optional[ArgMapper]:
+        return None
+
+    @property
+    def subcommands(self) -> Dict[str, Subcommand]:
+        return {}
+
+    def translate_args(self, args: List[str]) -> List[str]:
+        if self.arg_mapper:
+            return self.arg_mapper.translate(args)
+        return list(args)
+
+    def build_command(self, args: List[str]) -> List[str]:
+        return [self.name, *self.translate_args(args)]
+
+    def _is_available(self) -> bool:
+        return shutil.which(self.name) is not None
+
+    def _get_fallback(self) -> Optional[Plugin]:
+        for plugin in PluginRegistry.all().values():
+            if plugin is not self and plugin.category == self.category and plugin._is_available():
+                return plugin
+        return None
+
+    def execute(self, args: List[str]) -> int:
+        if not self._is_available():
+            fallback = self._get_fallback()
+            if fallback is not None:
+                click.echo(
+                    f"'{self.name}' not found, falling back to '{fallback.name}'",
+                    err=True,
+                )
+                return fallback.execute(args)
+            click.echo(
+                f"Error: '{self.name}' not found and no fallback available in category '{self.category}'.",
+                err=True,
+            )
+            return 1
+
+        if args and args[0] in self.subcommands:
+            sub = self.subcommands[args[0]]
+            cmd = sub.build_command(self.name, args[1:])
+            return subprocess.call(cmd)
+
+        cmd = self.build_command(args)
+        return subprocess.call(cmd)
+
+    def format_help(self) -> str:
+        lines = [f"{self.name}: {self.description}", ""]
+        if self.subcommands:
+            lines.append("Subcommands:")
+            for name, sub in self.subcommands.items():
+                lines.append(f"  {name:<12} {sub.description}")
+            lines.append("")
+        if self.arg_mapper and self.arg_mapper._mapping:
+            lines.append("Argument mappings:")
+            for alias, native in self.arg_mapper._mapping.items():
+                lines.append(f"  {alias} \u2192 {native}")
+        lines.append("")
+        lines.append(f"Category: {self.category}")
+        return "\n".join(lines)
+
+    def format_subcommand_help(self, sub: Subcommand) -> str:
+        lines = [f"{self.name} {sub.name}: {sub.description}", ""]
+        if sub.arg_mapper and sub.arg_mapper._mapping:
+            lines.append("Argument mappings:")
+            for alias, native in sub.arg_mapper._mapping.items():
+                lines.append(f"  {alias} \u2192 {native}")
+            lines.append("")
+        lines.append(f"Runs: {' '.join(sub.build_command(self.name, ['<args>']))}")
+        return "\n".join(lines)
+
+
+class PluginRegistry:
+    _plugins: Dict[str, Plugin] = {}
+
+    @classmethod
+    def register(cls, plugin: Plugin) -> None:
+        cls._plugins[plugin.name] = plugin
+
+    @classmethod
+    def get(cls, name: str) -> Optional[Plugin]:
+        return cls._plugins.get(name)
+
+    @classmethod
+    def all(cls) -> Dict[str, Plugin]:
+        return dict(cls._plugins)
+
+    @classmethod
+    def by_category(cls) -> Dict[str, Dict[str, Plugin]]:
+        result: Dict[str, Dict[str, Plugin]] = {}
+        for name, plugin in cls._plugins.items():
+            cat = plugin.category
+            if cat not in result:
+                result[cat] = {}
+            result[cat][name] = plugin
+        return result

swisscli-0.1.0/src/swisscli/plugins/package/apt.py

@@ -0,0 +1,47 @@
+from swisscli.plugin import ArgMapper, Plugin, Subcommand
+
+
+class AptPlugin(Plugin):
+    name = "apt"
+    description = "Debian/Ubuntu package manager"
+    category = "package"
+
+    @property
+    def subcommands(self):
+        return {
+            "install": Subcommand(
+                name="install",
+                description="Install packages",
+                prefix_args=["install"],
+                arg_mapper=ArgMapper({
+                    "--yes": "-y",
+                    "--assume-yes": "-y",
+                    "--no-install-recommends": "--no-install-recommends",
+                    "--reinstall": "--reinstall",
+                }),
+            ),
+            "remove": Subcommand(
+                name="remove",
+                description="Remove packages",
+                prefix_args=["remove"],
+                arg_mapper=ArgMapper({
+                    "--yes": "-y",
+                    "--assume-yes": "-y",
+                    "--purge": "--purge",
+                    "--autoremove": "--autoremove",
+                }),
+            ),
+            "search": Subcommand(
+                name="search",
+                description="Search for packages",
+                prefix_args=["search"],
+            ),
+            "list": Subcommand(
+                name="list",
+                description="List installed packages",
+                prefix_args=["list", "--installed"],
+            ),
+        }
+
+
+plugin = AptPlugin()

swisscli-0.1.0/src/swisscli/plugins/package/dnf.py

@@ -0,0 +1,43 @@
+from swisscli.plugin import ArgMapper, Plugin, Subcommand
+
+
+class DnfPlugin(Plugin):
+    name = "dnf"
+    description = "RPM package manager (modern)"
+    category = "package"
+
+    @property
+    def subcommands(self):
+        return {
+            "install": Subcommand(
+                name="install",
+                description="Install packages",
+                prefix_args=["install"],
+                arg_mapper=ArgMapper({
+                    "--yes": "-y",
+                    "--assumeyes": "-y",
+                }),
+            ),
+            "remove": Subcommand(
+                name="remove",
+                description="Remove packages",
+                prefix_args=["remove"],
+                arg_mapper=ArgMapper({
+                    "--yes": "-y",
+                    "--assumeyes": "-y",
+                }),
+            ),
+            "search": Subcommand(
+                name="search",
+                description="Search for packages",
+                prefix_args=["search"],
+            ),
+            "list": Subcommand(
+                name="list",
+                description="List installed packages",
+                prefix_args=["list", "--installed"],
+            ),
+        }
+
+
+plugin = DnfPlugin()

swisscli-0.1.0/src/swisscli/plugins/package/dpkg.py

@@ -0,0 +1,35 @@
+from swisscli.plugin import Plugin, Subcommand
+
+
+class DpkgPlugin(Plugin):
+    name = "dpkg"
+    description = "Debian package manager (low-level)"
+    category = "package"
+
+    @property
+    def subcommands(self):
+        return {
+            "list": Subcommand(
+                name="list",
+                description="List installed packages",
+                prefix_args=["-l"],
+            ),
+            "info": Subcommand(
+                name="info",
+                description="Show package info",
+                prefix_args=["-s"],
+            ),
+            "search": Subcommand(
+                name="search",
+                description="Search which package owns a file",
+                prefix_args=["-S"],
+            ),
+            "contents": Subcommand(
+                name="contents",
+                description="List files installed by a package",
+                prefix_args=["-L"],
+            ),
+        }
+
+
+plugin = DpkgPlugin()

swisscli-0.1.0/src/swisscli/plugins/package/rpm.py

@@ -0,0 +1,35 @@
+from swisscli.plugin import Plugin, Subcommand
+
+
+class RpmPlugin(Plugin):
+    name = "rpm"
+    description = "RPM package manager (low-level)"
+    category = "package"
+
+    @property
+    def subcommands(self):
+        return {
+            "list": Subcommand(
+                name="list",
+                description="List installed packages",
+                prefix_args=["-qa"],
+            ),
+            "info": Subcommand(
+                name="info",
+                description="Show package info",
+                prefix_args=["-qi"],
+            ),
+            "search": Subcommand(
+                name="search",
+                description="Search installed packages",
+                prefix_args=["-q"],
+            ),
+            "files": Subcommand(
+                name="files",
+                description="List files in a package",
+                prefix_args=["-ql"],
+            ),
+        }
+
+
+plugin = RpmPlugin()

swisscli-0.1.0/src/swisscli/plugins/package/yum.py

@@ -0,0 +1,43 @@
+from swisscli.plugin import ArgMapper, Plugin, Subcommand
+
+
+class YumPlugin(Plugin):
+    name = "yum"
+    description = "RPM package manager (legacy)"
+    category = "package"
+
+    @property
+    def subcommands(self):
+        return {
+            "install": Subcommand(
+                name="install",
+                description="Install packages",
+                prefix_args=["install"],
+                arg_mapper=ArgMapper({
+                    "--yes": "-y",
+                    "--assumeyes": "-y",
+                }),
+            ),
+            "remove": Subcommand(
+                name="remove",
+                description="Remove packages",
+                prefix_args=["remove"],
+                arg_mapper=ArgMapper({
+                    "--yes": "-y",
+                    "--assumeyes": "-y",
+                }),
+            ),
+            "search": Subcommand(
+                name="search",
+                description="Search for packages",
+                prefix_args=["search"],
+            ),
+            "list": Subcommand(
+                name="list",
+                description="List installed packages",
+                prefix_args=["list", "installed"],
+            ),
+        }
+
+
+plugin = YumPlugin()

swisscli-0.1.0/src/swisscli/plugins/ssl/openssl.py

@@ -0,0 +1,37 @@
+from swisscli.plugin import ArgMapper, Plugin, Subcommand
+
+
+class OpenSslPlugin(Plugin):
+    name = "openssl"
+    description = "OpenSSL certificate toolkit"
+    category = "ssl"
+
+    @property
+    def subcommands(self):
+        return {
+            "show": Subcommand(
+                name="show",
+                description="Show certificate details",
+                prefix_args=["x509", "-in"],
+                suffix_args=["-text", "-noout"],
+            ),
+            "generate": Subcommand(
+                name="generate",
+                description="Generate a self-signed certificate",
+                prefix_args=[
+                    "req", "-x509", "-newkey", "rsa:4096",
+                    "-keyout", "key.pem", "-out", "cert.pem",
+                    "-days", "365", "-nodes",
+                    "-subj", "/CN=SelfSigned",
+                ],
+                arg_mapper=ArgMapper({
+                    "--days": "-days",
+                    "--keyout": "-keyout",
+                    "--out": "-out",
+                    "--subj": "-subj",
+                }),
+            ),
+        }
+
+
+plugin = OpenSslPlugin()

swisscli-0.1.0/src/swisscli/plugins/ssl/ssh_keygen.py

@@ -0,0 +1,31 @@
+from swisscli.plugin import ArgMapper, Plugin, Subcommand
+
+
+class SshKeygenPlugin(Plugin):
+    name = "ssh-keygen"
+    description = "SSH key management tool"
+    category = "ssl"
+
+    @property
+    def subcommands(self):
+        return {
+            "show": Subcommand(
+                name="show",
+                description="Show SSH key fingerprint",
+                prefix_args=["-l", "-f"],
+            ),
+            "generate": Subcommand(
+                name="generate",
+                description="Generate an SSH key pair",
+                prefix_args=["-t", "rsa", "-b", "4096", "-f", "key", "-N", ""],
+                arg_mapper=ArgMapper({
+                    "--type": "-t",
+                    "--bits": "-b",
+                    "--file": "-f",
+                    "--comment": "-C",
+                }),
+            ),
+        }
+
+
+plugin = SshKeygenPlugin()

swisscli-0.1.0/src/swisscli/plugins/web/curl.py

@@ -0,0 +1,21 @@
+from swisscli.plugin import ArgMapper, Plugin
+
+
+class CurlPlugin(Plugin):
+    name = "curl"
+    description = "Wrapper around curl for HTTP requests"
+    category = "web-cli"
+
+    @property
+    def arg_mapper(self):
+        return ArgMapper({
+            "--insecure": "-k",
+            "--silent": "-s",
+            "--location": "-L",
+            "--output": "-o",
+            "--header": "-H",
+            "--data": "-d",
+        })
+
+
+plugin = CurlPlugin()

swisscli-0.1.0/src/swisscli/plugins/web/wget.py

@@ -0,0 +1,19 @@
+from swisscli.plugin import ArgMapper, Plugin
+
+
+class WgetPlugin(Plugin):
+    name = "wget"
+    description = "Wrapper around wget for downloading files"
+    category = "web-cli"
+
+    @property
+    def arg_mapper(self):
+        return ArgMapper({
+            "--insecure": "--no-check-certificate",
+            "--quiet": "-q",
+            "--output": "-O",
+            "--timeout": "-T",
+        })
+
+
+plugin = WgetPlugin()