lazyops-cli 1.0.0__py3-none-any.whl

commands/list.py

@@ -0,0 +1,22 @@
+import typer
+
+from registry.catalog import CatalogError, iter_installed_workflows
+
+
+def register(app:typer.Typer):
+    
+    @app.command("list",help="List all commands")
+    def list_workflows():
+        try:
+            items = iter_installed_workflows()
+        except CatalogError as exc:
+            typer.secho(str(exc), fg=typer.colors.RED, err=True)
+            raise typer.Exit(1)
+        if not items:
+            typer.echo("No workflows found.")
+            typer.echo("Install packs: lazyops pack add aws")
+            return
+        for i, item in enumerate(items, start=1):
+            wf = item["workflow"]
+            name = wf.get("name", item["plugin"])
+            typer.echo(f"{i}. {item['pack']}/{item['plugin']} — {name}")

commands/pack.py

@@ -0,0 +1,75 @@
+import typer
+
+from registry import packs as pack_registry
+from registry.fetch import FetchError, list_pack_plugins
+from registry.source import SourceError, get_source
+
+pack_app = typer.Typer(help="Manage installed workflow packs (aws,kubernetes,...)")
+
+def register(app: typer.Typer):
+    app.add_typer(pack_app,name="pack")
+
+@pack_app.command("add")
+def pack_add(name:str=typer.Argument(...,help="Pack id eg. aws")):
+    try:
+        pack_registry.add_pack(name)
+    except pack_registry.PackError as exc:
+        typer.secho(str(exc),fg=typer.colors.RED, err=True)
+        raise typer.Exit(1)
+
+    typer.secho(f"Installed pack: {name}", fg=typer.colors.GREEN)
+    typer.secho("Run workflow with: lazyops run <pack>/<plugin>")
+
+@pack_app.command("list")
+def pack_list(pack: str | None = typer.Argument(None, help="Optional pack id to list plugins")):
+    if pack is None:
+        items = pack_registry.list_packs()
+        if not items:
+            typer.echo("No packs installed.")
+            typer.echo("Install one: lazyops pack add aws")
+            return
+        try:
+            source = get_source()
+        except SourceError as exc:
+            typer.secho(str(exc), fg=typer.colors.RED, err=True)
+            raise typer.Exit(1)
+        for name in items:
+            try:
+                plugins = list_pack_plugins(
+                    source["url"],
+                    source["ref"],
+                    source.get("path_prefix", "plugins"),
+                    name,
+                )
+                typer.echo(f"{name} ({len(plugins)} plugins)")
+            except FetchError as exc:
+                typer.echo(f"{name} (failed to list: {exc})")
+    else:
+        try:
+            source = get_source()
+            plugins = list_pack_plugins(
+                source["url"],
+                source["ref"],
+                source.get("path_prefix", "plugins"),
+                pack,
+            )
+        except SourceError as exc:
+            typer.secho(str(exc), fg=typer.colors.RED, err=True)
+            raise typer.Exit(1)
+        except FetchError as exc:
+            typer.secho(str(exc), fg=typer.colors.RED, err=True)
+            raise typer.Exit(1)
+        if not plugins:
+            typer.echo(f"No plugins found in pack: {pack}")
+            return
+        for plugin in plugins:
+            typer.echo(f"{pack}/{plugin}")
+
+@pack_app.command("remove")
+def pack_remove(name: str = typer.Argument(..., help="Pack id to remove")):
+    try:
+        pack_registry.remove_pack(name)
+    except pack_registry.PackError as exc:
+        typer.secho(str(exc), fg=typer.colors.RED, err=True)
+        raise typer.Exit(1)
+    typer.secho(f"Removed pack: {name}", fg=typer.colors.GREEN)

commands/run.py

@@ -0,0 +1,185 @@
+import os
+import shutil
+import subprocess
+
+import typer
+import yaml
+
+from registry.discover import read_workflow
+from registry.fetch import FetchError, fetch_pack_dir, fetch_plugin_dir, list_pack_plugins
+from registry.packs import list_packs, pack_installed
+from registry.paths import PROJECT_ROOT, venv_python
+from registry.source import SourceError, get_source
+
+
+def _parse_target(target:str)-> tuple[str,str]:
+    if "/" not in target:
+        raise typer.BadParameter("Use pack/plugin format, eg. aws/addpatchclasstag")
+
+    pack,plugin = target.split("/",1)
+    if not pack or not plugin:
+        raise typer.BadParameter("Use pack/plugin format, e.g. aws/addpatchclasstag")
+    return pack,plugin
+
+def _run_target(pack: str, plugin: str, extra_args: list[str]) -> None:
+    if not pack_installed(pack):
+        typer.secho(
+            f"Pack not installed: {pack}. Run: lazyops pack add {pack}",
+            fg=typer.colors.RED,
+            err=True,
+        )
+        raise typer.Exit(1)
+
+    try:
+        source = get_source()
+    except SourceError as exc:
+        typer.secho(str(exc), fg=typer.colors.RED, err=True)
+        raise typer.Exit(1)
+
+    tmp_root = None
+    workflow_dir = None
+    try:
+        workflow_dir = fetch_plugin_dir(
+            url=source["url"],
+            ref=source["ref"],
+            path_prefix=source.get("path_prefix", "plugins"),
+            pack=pack,
+            plugin=plugin,
+        )
+        tmp_root = workflow_dir.parent.parent
+
+        workflow_path = workflow_dir / "workflow.yaml"
+        workflow = read_workflow(workflow_path)
+        entrypoint = workflow_dir / workflow["entrypoint"]
+        inputs = list(extra_args or [])
+
+        env = os.environ.copy()
+        env.setdefault("LAZYOPS_ROOT", str(PROJECT_ROOT))
+        env.setdefault("WORKFLOW_ID", workflow.get("id", plugin))
+        env.setdefault("WORKFLOW_ROOT", str(workflow_dir))
+        env.setdefault("WORKFLOW_RUNTIME", workflow["runtime"])
+        env.setdefault("WORKFLOW_VERSION", workflow.get("version", "1.0.0"))
+        env.setdefault("WORKFLOW_PACK", pack)
+        env.setdefault("WORKFLOW_PLUGIN", plugin)
+        env.setdefault("WORKFLOW_SOURCE_REF", source["ref"])
+
+        if workflow["runtime"] == "bash":
+            cmd = ["bash", str(entrypoint)] + inputs
+        elif workflow["runtime"] == "python":
+            cmd = [venv_python(), str(entrypoint)] + inputs
+        elif workflow["runtime"] == "node":
+            cmd = ["node", str(entrypoint)] + inputs
+        else:
+            typer.secho(f"Unsupported runtime: {workflow['runtime']}", fg=typer.colors.RED, err=True)
+            raise typer.Exit(1)
+
+        subprocess.run(cmd, check=True, env=env, cwd=workflow_dir)
+
+    except FetchError as exc:
+        typer.secho(f"Failed to fetch workflow: {exc}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(1)
+    finally:
+        if tmp_root is not None:
+            shutil.rmtree(tmp_root, ignore_errors=True)
+
+
+def _pick_index(prompt: str, max_index: int) -> int:
+    while True:
+        raw = typer.prompt(prompt)
+        try:
+            choice = int(raw)
+        except ValueError:
+            typer.secho(f"Enter a number between 1 and {max_index}", fg=typer.colors.RED)
+            continue
+        if 1 <= choice <= max_index:
+            return choice - 1
+        typer.secho(f"Enter a number between 1 and {max_index}", fg=typer.colors.RED)
+
+
+def _interactive_run() -> tuple[str, str]:
+    packs = list_packs()
+    if not packs:
+        typer.secho("No packs installed. Run: lazyops pack add aws", fg=typer.colors.RED, err=True)
+        raise typer.Exit(1)
+
+    try:
+        source = get_source()
+    except SourceError as exc:
+        typer.secho(str(exc), fg=typer.colors.RED, err=True)
+        raise typer.Exit(1)
+
+    typer.echo("\nInstalled packs:")
+    pack_rows: list[tuple[str, list[str]]] = []
+    for i, pack in enumerate(packs, start=1):
+        try:
+            plugins = list_pack_plugins(
+                source["url"],
+                source["ref"],
+                source.get("path_prefix", "plugins"),
+                pack,
+            )
+        except FetchError as exc:
+            typer.secho(f"  {i}. {pack} (failed: {exc})", fg=typer.colors.YELLOW)
+            plugins = []
+        pack_rows.append((pack, plugins))
+        typer.echo(f"  {i}. {pack} ({len(plugins)} plugins)")
+
+    pack_idx = _pick_index(f"Select pack [1-{len(packs)}]: ", len(packs))
+    pack, plugins = pack_rows[pack_idx]
+
+    if not plugins:
+        typer.secho(f"No plugins in pack {pack}", fg=typer.colors.RED, err=True)
+        raise typer.Exit(1)
+
+    typer.echo(f"\nPlugins in {pack}:")
+    tmp_root = None
+    try:
+        tmp_root, pack_dir = fetch_pack_dir(
+            source["url"],
+            source["ref"],
+            source.get("path_prefix", "plugins"),
+            pack,
+        )
+
+        # plugins list order from git; enrich with local workflow.yaml names
+        plugin_labels: dict[str, str] = {}
+        for child in pack_dir.iterdir():
+            if not child.is_dir() or child.name == "pack.yaml":
+                continue
+            yaml_path = child / "workflow.yaml"
+            if yaml_path.is_file():
+                wf = yaml.safe_load(yaml_path.read_text()) or {}
+                plugin_labels[child.name] = wf.get("name", child.name)
+            else:
+                plugin_labels[child.name] = child.name
+
+        for i, plugin in enumerate(plugins, start=1):
+            label = plugin_labels.get(plugin, plugin)
+            typer.echo(f"  {i}. {plugin} — {label}")
+
+    finally:
+        if tmp_root is not None:
+            shutil.rmtree(tmp_root, ignore_errors=True)
+
+    plugin_idx = _pick_index(f"Select plugin [1-{len(plugins)}]: ", len(plugins))
+    plugin = plugins[plugin_idx]
+
+    confirm = typer.confirm(f"Run {pack}/{plugin}?")
+    if not confirm:
+        typer.echo("Cancelled.")
+        raise typer.Exit(0)
+
+    return pack, plugin
+
+def register(app: typer.Typer):
+
+    @app.command("run", help="Run a workflow: lazyops run <pack>/<plugin> [args...]")
+    def run_workflow(
+        target: str | None = typer.Argument(default=None, help="pack/plugin, e.g. aws/addpatchclasstag"),
+        extra_args: list[str] | None = typer.Argument(None),
+    ):
+        if target is None:
+            pack, plugin = _interactive_run()
+        else:
+            pack, plugin = _parse_target(target)
+        _run_target(pack, plugin, list(extra_args or []))

commands/search.py

@@ -0,0 +1,57 @@
+import typer
+
+from registry.catalog import CatalogError, iter_installed_workflows
+
+
+def _matches(query: str, pack: str, plugin: str, workflow_data: dict) -> bool:
+    q = query.lower()
+    haystack = " ".join(
+        [
+            pack,
+            plugin,
+            f"{pack}/{plugin}",
+            str(workflow_data.get("id", "")),
+            str(workflow_data.get("name", "")),
+            str(workflow_data.get("description", "")),
+        ]
+    ).lower()
+    return q in haystack
+
+
+
+def register(app: typer.Typer):
+
+    @app.command("search", help="Search details about any command")
+    def search_workflows(query: str):
+        try:
+            items = iter_installed_workflows()
+        except CatalogError as exc:
+            typer.secho(str(exc), fg=typer.colors.RED, err=True)
+            raise typer.Exit(1)
+        matches = 0
+        for item in items:
+            pack = item["pack"]
+            plugin = item["plugin"]
+            workflow_data = item["workflow"]
+            if not _matches(query, pack, plugin, workflow_data):
+                continue
+            matches += 1
+            wf_id = workflow_data.get("id", plugin)
+            inputs = workflow_data.get("inputs") or []
+            print(f"\033[1mId\033[0m: {pack}/{wf_id}")
+            print(f"\033[1mName\033[0m: {workflow_data.get('name', wf_id)}")
+            print(f"\033[1mWhat i do?\033[0m: {workflow_data.get('description', '')}")
+            if inputs:
+                print("\033[1mInputs\033[0m:")
+                for inp in inputs:
+                    label = "required" if inp.get("required") else "optional"
+                    print(f"  - {inp['name']} ({label})")
+            else:
+                print("\033[1mInputs\033[0m: none")
+            arg_names = [inp["name"] for inp in inputs if inp.get("required")]
+            args = " ".join(f"<{name}>" for name in arg_names)
+            target = f"{pack}/{plugin}"
+            print(f"\n\033[1msyntax\033[0m: lazyops run {target}{(' ' + args) if args else ''}")
+            print()
+        if matches == 0:
+            typer.echo(f"No workflows matched '{query}'.")

commands/source.py

@@ -0,0 +1,52 @@
+import typer
+
+from registry import source as source_registry
+from registry.config import CONFIG_PATH
+
+source_app = typer.Typer(help="Manage workflow sources (git branches, tags, local paths)")
+
+
+def register(app: typer.Typer):
+    app.add_typer(source_app, name="source")
+
+
+@source_app.command("show")
+def source_show():
+    try:
+        src = source_registry.get_source()
+    except source_registry.SourceError as exc:
+        typer.secho(str(exc), fg=typer.colors.RED, err=True)
+        raise typer.Exit(1)
+    typer.echo(f"url:          {src['url']}")
+    typer.echo(f"ref:          {src['ref']}")
+    typer.echo(f"path_prefix:  {src.get('path_prefix', 'plugins')}")
+
+
+@source_app.command("update")
+def source_update(
+    ref: str = typer.Option(..., "--ref", "-r", help="New branch or tag"),
+):
+    try:
+        entry = source_registry.update_source_ref(ref)
+    except source_registry.SourceError as exc:
+        typer.secho(str(exc), fg=typer.colors.RED, err=True)
+        raise typer.Exit(1)
+    typer.secho(f"Source updated to ref: {entry['ref']}", fg=typer.colors.GREEN)
+
+
+@source_app.command("init")
+def source_init(
+    url: str = typer.Argument(..., help="Git URL of lazyops-plugins repo"),
+    ref: str = typer.Option("v1.0.0", "--ref", "-r", help="Branch or tag (version)"),
+    path_prefix: str = typer.Option("plugins", "--path-prefix", help="Root dir in repo"),
+):
+    try:
+        entry = source_registry.init_source(url, ref, path_prefix)
+    except source_registry.SourceError as exc:
+        typer.secho(str(exc), fg=typer.colors.RED, err=True)
+        raise typer.Exit(1)
+    typer.secho("Source configured", fg=typer.colors.GREEN)
+    typer.echo(f"  url:          {entry['url']}")
+    typer.echo(f"  ref:          {entry['ref']}")
+    typer.echo(f"  path_prefix:  {entry['path_prefix']}")
+    typer.echo(f"  config:       {CONFIG_PATH}")

lazyops_cli/cli.py

@@ -0,0 +1,31 @@
+import typer
+from pathlib import Path
+import importlib
+
+
+app = typer.Typer()
+
+COMMANDS_DIR = Path(__file__).parent.parent / "commands"
+
+
+def discover_commands():
+    commands = []
+    for path in COMMANDS_DIR.iterdir():
+        if path.is_file() and path.suffix == ".py" and path.name != "__init__.py":
+            module=importlib.import_module(f"commands.{path.stem}")
+            if hasattr(module,"register"):
+                module.register(app)
+
+
+@app.command()
+def intro(name: str = "World"):
+    print(f"Hello {name}")
+
+# This function will be targeted by your custom CLI name
+discover_commands()
+
+def run():
+    app()
+
+if __name__ == "__main__":
+    run()

lazyops_cli-1.0.0.dist-info/METADATA

@@ -0,0 +1,247 @@
+Metadata-Version: 2.4
+Name: lazyops-cli
+Version: 1.0.0
+Summary: CLI to discover, fetch, and run reusable automation workflows from remote plugin packs.
+Author: Mridul Tiwari
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/MridulTi/LazyOps
+Project-URL: Repository, https://github.com/MridulTi/LazyOps
+Project-URL: Issues, https://github.com/MridulTi/LazyOps/issues
+Project-URL: Documentation, https://github.com/MridulTi/LazyOps#readme
+Keywords: cli,automation,workflows,devops,ops
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: System Administrators
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
+Classifier: Topic :: System :: Systems Administration
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.12.0
+Requires-Dist: PyYAML>=6.0
+Dynamic: license-file
+
+# LazyOps
+
+> Turn your scattered scripts into reusable, searchable, and shareable workflows.
+
+## Why LazyOps?
+
+Every engineer has a folder full of scripts:
+
+```text
+cleanup.sh
+restart-pods.py
+rotate_logs.sh
+debug-nginx.sh
+fix-permissions.sh
+```
+
+After a few months:
+
+* You forget they exist.
+* You can't remember their arguments.
+* They're undocumented.
+* They only work on your machine.
+* Your teammates rewrite the same automation.
+
+LazyOps solves this by adding a lightweight workflow layer on top of existing scripts.
+
+No rewrites. No proprietary language. Just structure.
+
+## Features
+
+* 🚀 Run scripts as named workflows (`lazyops run pack/plugin`)
+* 📦 Install workflow **packs** (aws, kubernetes, security, …) from a remote catalog
+* 🔍 Search and list workflows across installed packs
+* 🐍 Support multiple runtimes (Bash, Python, Node.js, executables)
+* 📝 Interactive picker when you run `lazyops run` with no arguments
+* ✅ Manifest validation before execution
+* 🔖 Pin catalog version by git branch or tag (`source.ref`)
+* 🤝 Workflows live in a separate repo — share and version them independently
+
+## Architecture
+
+LazyOps is a **CLI-only installer**. Workflows are fetched at runtime from a separate plugins repo:
+
+| Repo | Role |
+|------|------|
+| [LazyOps](https://github.com/MridulTi/LazyOps) | CLI, config, fetch & run |
+| [lazyops-plugins](https://github.com/MridulTi/lazyops-plugins) | Workflow catalog (packs + plugins) |
+
+Each **pack** is a bundle (e.g. `aws`, `kubernetes`). Each **plugin** is one workflow folder under that pack. The git **branch or tag** on the plugins repo is the catalog **version**.
+
+```text
+lazyops-plugins/
+└── plugins/
+    └── aws/
+        ├── pack.yaml
+        └── addpatchclasstag/
+            ├── workflow.yaml
+            ├── script.sh
+            └── README.md
+```
+
+Run a workflow:
+
+```bash
+lazyops run aws/addpatchclasstag
+```
+
+LazyOps fetches the plugin at your configured `source.ref`, validates the manifest, and executes the script.
+
+## Installation
+
+### From PyPI (recommended)
+
+The PyPI package is **`lazyops-cli`** (the name `lazyops` is taken by another project). The command is still `lazyops`:
+
+```bash
+pipx install lazyops-cli
+lazyops --help
+```
+
+Requires Python 3.10+ and `git` (used to fetch workflows at runtime).
+
+### From source (development)
+
+LazyOps runs from a project-local virtual environment (`.venv`). Do not install with system `pip`.
+
+```bash
+git clone https://github.com/MridulTi/LazyOps.git
+cd LazyOps
+bash setup.sh
+source ~/.zshrc   # or ~/.bashrc — loads the lazyops alias
+lazyops --help    # works from any directory
+```
+
+`setup.sh` adds a global shell alias pointing at the repo wrapper (which always uses `.venv`):
+
+```bash
+alias lazyops='/path/to/LazyOps/lazyops'
+export LAZYOPS_ROOT='/path/to/LazyOps'
+```
+
+You can also run from the repo without the alias:
+
+```bash
+./lazyops --help
+source .venv/bin/activate
+```
+
+## Quick start
+
+Point LazyOps at the plugins catalog, enable packs, and run workflows:
+
+```bash
+# 1. Configure the plugins source (branch = version)
+lazyops source init https://github.com/MridulTi/lazyops-plugins.git --ref v1.0.0
+
+# 2. Enable packs you need
+lazyops pack add aws
+lazyops pack add kubernetes
+
+# 3. Discover and run
+lazyops list
+lazyops search patch
+lazyops run aws/addpatchclasstag
+lazyops run                    # interactive: pick pack → pick plugin → confirm
+
+# 4. Upgrade catalog version
+lazyops source update --ref v1.2.0
+```
+
+For local development against a checkout of lazyops-plugins:
+
+```bash
+lazyops source init file:///path/to/lazyops-plugins --ref main
+```
+
+Config is stored at `~/.lazyops/config.yaml`:
+
+```yaml
+source:
+  url: https://github.com/MridulTi/lazyops-plugins.git
+  ref: v1.0.0
+  path_prefix: plugins
+packs:
+  - aws
+  - kubernetes
+```
+
+## Commands
+
+| Command | Purpose |
+|---------|---------|
+| `lazyops source init <url> [--ref]` | Set plugins repo URL and version |
+| `lazyops source show` | Show current source config |
+| `lazyops source update --ref <ref>` | Bump catalog version |
+| `lazyops pack add <pack>` | Enable a pack |
+| `lazyops pack list` | List installed packs |
+| `lazyops pack list <pack>` | List plugins in a pack |
+| `lazyops pack remove <pack>` | Disable a pack |
+| `lazyops run <pack>/<plugin> [args...]` | Fetch and run a workflow |
+| `lazyops run` | Interactive workflow picker |
+| `lazyops list` | List workflows in installed packs |
+| `lazyops search <query>` | Search by name, id, or description |
+
+## Example manifest
+
+```yaml
+id: addpatchclasstag
+
+name: "Add Patch Class Tag"
+
+description: "Add patch class tags to instances. Required env: AWS_REGION or REGION."
+
+runtime: bash
+
+entrypoint: script.sh
+
+pack: aws
+
+version: 1.0.0
+
+inputs:
+  - name: instance_id
+    required: true
+```
+
+## Philosophy
+
+Scripts should remain scripts.
+
+LazyOps does not replace your automation. It makes it easier to organize, discover, document, and reuse — with a shared catalog your whole team can install and pin to a version.
+
+## Roadmap
+
+* [x] Workflow specification
+* [x] Remote plugin catalog (source + packs)
+* [x] Fetch and run workflows from git
+* [x] Interactive CLI
+* [x] Search and list
+* [ ] Input validation
+* [ ] Plugin runtimes
+* [ ] Optional web dashboard
+
+## Contributing
+
+Contributions are welcome.
+
+You can help by:
+
+* Adding workflows to [lazyops-plugins](https://github.com/MridulTi/lazyops-plugins)
+* Improving CLI documentation
+* Supporting additional runtimes
+* Reporting bugs
+* Suggesting new features
+
+## License
+
+MIT License

lazyops_cli-1.0.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+commands/list.py,sha256=FntpRYPa5lOfRN1S1hY3uhSWjuxTLS-qEpRjzxy76yw,746
+commands/pack.py,sha256=YmkS5kjsCw6Mhyk88fcSTNBLni5S1sPc3duc0UO7jSo,2705
+commands/run.py,sha256=_Yjn5WWDDPyYLB7HgYLFU8Mp6sbZdE8ViI9P6eq4a68,6448
+commands/search.py,sha256=gjuxp1eTxQRImO6OK2yI1zCho7kCaICxYZk_XokT4iM,2117
+commands/source.py,sha256=fU_19SR0j8XB8Ot9WKKPs9IDturRS2whaPOGExsPMz0,1861
+lazyops_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lazyops_cli/cli.py,sha256=D83WJsI9ypGTxa3-DUC3O_l21Uq0qp-NNsuTN708sOM,664
+lazyops_cli-1.0.0.dist-info/licenses/LICENSE,sha256=Qt8MKT0gY0r-pDAO1zEWfB7YHPycn9Bsy7YUDwF8daQ,1070
+registry/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+registry/catalog.py,sha256=R09XEhval3a2CakDbFJrAPN7cw3HuR5b-ex1xOtzsSE,1567
+registry/config.py,sha256=fjSycupyO-GrrgggjBsjHit2jkdUCq_tjwCAzHcWK-Q,1848
+registry/discover.py,sha256=an7R9XmOGHVcTfB97FvUGaxHYtu5F_pImatoy0bu7z0,858
+registry/fetch.py,sha256=ak9u-lephFVtlgxzcb69SWhdIbA5dxvoUoWve-V1O4A,5180
+registry/packs.py,sha256=1UyOe_K2rT7q-EkG4IhLefVJ8_ds4ytp315yAclz9CU,831
+registry/paths.py,sha256=6vxsHPTAgdAUH4cbFHz9Mda0DBfP3SH2ti0MHBU5XIw,261
+registry/source.py,sha256=L71aPgTyHjzzEjawKdEAZu1gNrnGAJstNe8YQLEu33o,1158
+lazyops_cli-1.0.0.dist-info/METADATA,sha256=g-vAFZMTDVjgiS9NkPR1UhPILeqgzKmzcnTcqB3JJPE,6797
+lazyops_cli-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+lazyops_cli-1.0.0.dist-info/entry_points.txt,sha256=qlVXtgEEZ2FAyGIkzwsb0AigUm5To2vah8yX6C0K238,48
+lazyops_cli-1.0.0.dist-info/top_level.txt,sha256=pTKCX7t0APvoQBsimdqrLxWeI-eX3X1FlWD1NRZNpRY,30
+lazyops_cli-1.0.0.dist-info/RECORD,,

lazyops_cli-1.0.0.dist-info/WHEEL

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

lazyops_cli-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+lazyops = lazyops_cli.cli:run

lazyops_cli-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mridul Tiwari
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lazyops_cli-1.0.0.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+commands
+lazyops_cli
+registry

registry/catalog.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import shutil
+
+import yaml
+
+from registry.fetch import FetchError, fetch_pack_dir
+from registry.packs import list_packs
+from registry.source import SourceError, get_source
+
+
+class CatalogError(Exception):
+    pass
+
+
+def iter_installed_workflows() -> list[dict]:
+    """
+    Return metadata for every plugin under installed packs.
+    Each item: {pack, plugin, workflow}
+    """
+    try:
+        source = get_source()
+    except SourceError as exc:
+        raise CatalogError(str(exc)) from exc
+    url = source["url"]
+    ref = source["ref"]
+    path_prefix = source.get("path_prefix", "plugins")
+    results: list[dict] = []
+    for pack in list_packs():
+        tmp_root = None
+        try:
+            tmp_root, pack_dir = fetch_pack_dir(url, ref, path_prefix, pack)
+            for child in sorted(pack_dir.iterdir()):
+                if not child.is_dir() or child.name == "pack.yaml":
+                    continue
+                yaml_path = child / "workflow.yaml"
+                if not yaml_path.is_file():
+                    continue
+                workflow = yaml.safe_load(yaml_path.read_text()) or {}
+                results.append({
+                    "pack": pack,
+                    "plugin": child.name,
+                    "workflow": workflow,
+                })
+        except FetchError as exc:
+            raise CatalogError(f"Failed to load pack {pack}: {exc}") from exc
+        finally:
+            if tmp_root is not None:
+                shutil.rmtree(tmp_root, ignore_errors=True)
+    return results

registry/config.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+from pathlib import Path
+import yaml,os
+
+DEFAULT_CONFIG_DIR = Path(os.environ.get("LAZYOPS_CONFIG_DIR", str(Path.home() / ".lazyops")))
+CONFIG_PATH = DEFAULT_CONFIG_DIR / "config.yaml"
+
+DEFAULT_CONFIG = {"source": None, "packs": []}
+
+
+def ensure_config_dir() -> None:
+    DEFAULT_CONFIG_DIR.mkdir(parents=True,exist_ok=True)
+
+def _migrate_config(data: dict) -> dict:
+    """Normalize config to source + packs; migrate legacy sources[]."""
+    if not isinstance(data, dict):
+        data = {}
+    # Legacy: sources[] → single source (first entry only)
+    if "source" not in data and isinstance(data.get("sources"), list):
+        legacy = data["sources"]
+        if legacy:
+            first = legacy[0]
+            data["source"] = {
+                "url": first.get("url", ""),
+                "ref": first.get("ref", "v1.0.0"),
+                "path_prefix": first.get("path_prefix", "plugins"),
+            }
+        del data["sources"]
+    if data.get("source") is None:
+        data["source"] = None
+    elif isinstance(data["source"], dict):
+        src = data["source"]
+        data["source"] = {
+            "url": src.get("url", ""),
+            "ref": src.get("ref", "v1.0.0"),
+            "path_prefix": src.get("path_prefix", "plugins"),
+        }
+    if "packs" not in data or not isinstance(data["packs"], list):
+        data["packs"] = []
+    return data
+
+def load_config() -> dict:
+    ensure_config_dir()
+    if not CONFIG_PATH.is_file():
+        return dict(DEFAULT_CONFIG)
+    with CONFIG_PATH.open("r",encoding="utf-8") as f:
+        data = yaml.safe_load(f) or {}
+    return _migrate_config(data)
+
+def save_config(data: dict) -> None:
+    ensure_config_dir()
+    with CONFIG_PATH.open("w", encoding="utf-8") as f:
+        yaml.safe_dump(data, f, sort_keys=False, default_flow_style=False)

registry/discover.py

@@ -0,0 +1,28 @@
+from pathlib import Path
+import yaml
+
+def discover_workflows():
+    workflow_root= Path(__file__).parent.parent / "workflows"
+    workflows=[]
+    for workflows_dir in workflow_root.iterdir():
+        if workflows_dir.is_dir():
+            yaml_file=workflows_dir/ "workflow.yaml"
+            if yaml_file.is_file():
+                workflows.append(workflows_dir.name)
+    return workflows
+
+
+def discover_workflow_path():
+    workflow_root= Path(__file__).parent.parent / "workflows"
+    workflows=[]
+    for workflows_dir in workflow_root.iterdir():
+        if workflows_dir.is_dir():
+            yaml_file=workflows_dir/ "workflow.yaml"
+            if yaml_file.is_file():
+                workflows.append(yaml_file)
+    return workflows
+    
+
+def read_workflow(workflow_path: Path):
+    with open(workflow_path,"r") as f:
+        return yaml.safe_load(f)

registry/fetch.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import shutil,yaml
+import subprocess
+import tempfile
+from pathlib import Path
+
+
+class FetchError(Exception):
+    pass
+
+
+def _run_git(args: list[str], cwd: Path | None = None) -> None:
+    result = subprocess.run(
+        ["git",*args],
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+    )
+    if result.returncode !=0:
+        msg=(result.stderr or result.stdout or "").strip()
+        raise FetchError(msg or f"git {''.join(args)} failed")
+
+
+def plugin_relpath(path_prefix: str, pack: str, plugin: str) -> str:
+    prefix = path_prefix.strip('/')
+    return f"{prefix}/{pack}/{plugin}"
+
+
+def fetch_plugin_dir(
+    url: str,
+    ref: str,
+    path_prefix: str,
+    pack: str,
+    plugin: str
+) -> Path:
+    """
+    Sparse-clone one workflow dir at ref.
+    Returns path to the plugin dir (contains workflow.yaml).
+    Caller deletes parent temp dir when done.
+    """
+    rel = plugin_relpath(path_prefix, pack, plugin)
+    tmp_root = Path(tempfile.mkdtemp(prefix="lazyops-"))
+    repo_dir = tmp_root / "repo"
+    try:
+        _run_git(
+            [
+                "clone",
+                "--depth", "1",
+                "--filter=blob:none",
+                "--sparse",
+                "--branch", ref,
+                url,
+                str(repo_dir),
+            ]
+        )
+        _run_git(["sparse-checkout", "set", rel], cwd=repo_dir)
+        workflow_dir = repo_dir / rel
+        if not (workflow_dir / "workflow.yaml").is_file():
+            raise FetchError(
+                f"Workflow not found: {pack}/{plugin} at ref={ref} ({rel})"
+            )
+        dest = tmp_root / pack / plugin
+        dest.parent.mkdir(parents=True, exist_ok=True)
+        shutil.move(str(workflow_dir), str(dest))
+        shutil.rmtree(repo_dir, ignore_errors=True)
+        return dest
+    except Exception:
+        shutil.rmtree(tmp_root, ignore_errors=True)
+        raise
+
+def fetch_pack_dir(
+    url: str,
+    ref: str,
+    path_prefix: str,
+    pack: str,
+) -> tuple[Path, Path]:
+    """
+    Sparse-clone plugins/<pack>/ once.
+    Returns (tmp_root, pack_dir). Caller must rm tmp_root when done.
+    """
+    rel = f"{path_prefix.strip('/')}/{pack}"
+    tmp_root = Path(tempfile.mkdtemp(prefix="lazyops-pack-"))
+    repo_dir = tmp_root / "repo"
+
+    try:
+        _run_git(
+            [
+                "clone",
+                "--depth", "1",
+                "--filter=blob:none",
+                "--sparse",
+                "--branch", ref,
+                url,
+                str(repo_dir),
+            ]
+        )
+        _run_git(["sparse-checkout", "set", rel], cwd=repo_dir)
+
+        pack_dir = repo_dir / rel
+        if not pack_dir.is_dir():
+            raise FetchError(f"Pack not found: {pack}")
+
+        dest = tmp_root / pack
+        shutil.move(str(pack_dir), str(dest))
+        shutil.rmtree(repo_dir, ignore_errors=True)
+        return tmp_root, dest
+
+    except Exception:
+        shutil.rmtree(tmp_root, ignore_errors=True)
+        raise
+
+def list_pack_plugins(
+    url: str,
+    ref: str,
+    path_prefix: str,
+    pack: str,
+) -> list[str]:
+    """List plugin folder names under a pack (for pack list / interactive run)."""
+    prefix = path_prefix.strip("/")
+    pack_path = f"{prefix}/{pack}"
+    tmp_root = Path(tempfile.mkdtemp(prefix="lazyops-ls-"))
+    repo_dir = tmp_root / "repo"
+    repo_dir.mkdir(parents=True, exist_ok=True)
+    try:
+        _run_git(["init"], cwd=repo_dir)
+        _run_git(["remote", "add", "origin", url], cwd=repo_dir)
+        _run_git(["fetch", "--depth", "1", "origin", ref], cwd=repo_dir)
+        result = subprocess.run(
+            ["git", "ls-tree", "-d", "--name-only", f"FETCH_HEAD:{pack_path}"],
+            cwd=repo_dir,
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            raise FetchError(result.stderr.strip() or f"Pack not found: {pack}")
+        names = []
+        for line in result.stdout.splitlines():
+            name = line.strip()
+            if name and name != "pack.yaml":
+                names.append(name)
+        return sorted(names)
+    finally:
+        shutil.rmtree(tmp_root, ignore_errors=True)
+
+def read_plugin_workflow(
+    url: str,
+    ref: str,
+    path_prefix: str,
+    pack: str,
+    plugin: str
+) -> dict:
+    """Read workflow.yaml for one plugin at ref (no full clone)"""
+    rel = plugin_relpath(path_prefix, pack , plugin) + "/workflow.yaml"
+    tmp_root = Path(tempfile.mkdtemp(prefix="lazyops-yaml-"))
+    repo_dir = tmp_root / "repo"
+    repo_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        _run_git(["init"], cwd=repo_dir)
+        _run_git(["remote", "add", "origin", url], cwd=repo_dir)
+        _run_git(["fetch", "--depth", "1", "origin", ref], cwd=repo_dir)
+
+        result = subprocess.run(
+            ["git","show",f"FETCH_HEAD:{rel}"],
+            cwd=repo_dir,
+            capture_output=True,
+            text=True
+        )
+        if result.returncode != 0:
+            raise FetchError(f"Missing workflow.yaml for {pack}/{plugin}")
+
+        return yaml.safe_load(result.stdout) or {}
+    finally:
+        shutil.rmtree(tmp_root, ignore_errors=True)

registry/packs.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+from registry.config import load_config,save_config
+
+class PackError(Exception):
+    pass
+
+def list_packs() -> list[str]:
+    return load_config().get("packs") or []
+
+def pack_installed(name:str) -> bool:
+    return name in list_packs()
+
+def add_pack(name:str) -> None:
+    if not name:
+        raise PackError("pack name is required")
+
+    config = load_config()
+    packs = config.setdefault("packs",[])
+
+    if name in packs:
+        raise PackError(f"Pack already installed: {name}")
+
+    packs.append(name)
+    save_config(config)
+
+def remove_pack(name:str) -> None:
+    config = load_config()
+    packs = config.get("packs") or []
+
+    if name not in packs:
+        raise PackError(f"Pack not installed: {name}")
+
+    config["packs"] = [p for p in packs if p !=name]
+    save_config(config)

registry/paths.py

@@ -0,0 +1,11 @@
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+
+
+def venv_python() -> str:
+    candidate = PROJECT_ROOT / ".venv" / "bin" / "python"
+    if candidate.is_file():
+        return str(candidate)
+    return sys.executable

registry/source.py

@@ -0,0 +1,42 @@
+from __future__ import annotations
+
+from registry.config import load_config, save_config
+
+
+class SourceError(Exception):
+    pass
+
+
+def init_source(url: str, ref: str = "v1.0.0", path_prefix: str = "plugins") -> dict:
+    if not url:
+        raise SourceError("url is required")
+    config = load_config()
+    config["source"] = {
+        "url": url,
+        "ref": ref,
+        "path_prefix": path_prefix,
+    }
+    save_config(config)
+    return config["source"]
+
+
+def get_source() -> dict:
+    config = load_config()
+    source = config.get("source")
+    if not source or not isinstance(source, dict) or not source.get("url"):
+        raise SourceError(
+            "No source configured. Run: lazyops source init <git-url> --ref v1.0.0"
+        )
+    return source
+
+
+def update_source_ref(ref: str) -> dict:
+    if not ref:
+        raise SourceError("ref is required")
+    config = load_config()
+    source = config.get("source")
+    if not source or not isinstance(source, dict) or not source.get("url"):
+        raise SourceError("No source configured. Run: lazyops source init first")
+    source["ref"] = ref
+    save_config(config)
+    return source