clizard 0.1.0__py3-none-any.whl

clizard/__init__.py

@@ -0,0 +1,6 @@
+from .core import GenericCLI
+from .config import Config
+from .cli_args import parse_args, build_parser, auto_cli
+
+__all__ = ["GenericCLI", "Config", "parse_args", "build_parser", "auto_cli"]
+__version__ = "0.1.0"

clizard/__main__.py

@@ -0,0 +1,146 @@
+"""Default console-script entry point: `clizard`.
+
+Run with no args inside a repo to auto-discover everything:
+  - the repo's main() (via __main__.py / main.py signature)
+  - a Snakemake workflow (Snakefile + config.yaml), if present
+  - git remote info (.git/config)
+  - pyproject.toml metadata (name, docs url, requirements)
+  - .clizard overrides (ascii art, accent color, tips, app name, docs url)
+
+Falls back to a bare GenericCLI if nothing is discoverable.
+"""
+import subprocess
+import sys
+from pathlib import Path
+
+from .cli_args import parse_args
+from .core import GenericCLI
+from .git_info import get_git_info
+from .project_info import get_project_info
+from .clizard_file import ensure_clizard_file
+from .discover import (
+    find_main, settings_from_main,
+    find_snakemake_config, settings_from_snakemake_config, write_snakemake_config,
+)
+from .scaffold import generate_clizard_main
+
+
+def build_cli(repo_path="."):
+    repo_path = str(Path(repo_path).resolve())
+
+    git_info = get_git_info(repo_path)
+    proj_info = get_project_info(repo_path)
+    clz = ensure_clizard_file(repo_path)
+
+    app_name = clz.get("app_name") or proj_info.get("name") or git_info.get("github_repo") or "clizard"
+    docs_url = clz.get("docs_url") or proj_info.get("docs_url")
+
+    module, main_func, entry_file = find_main(repo_path)
+    main_settings, arg_meta, call_style = settings_from_main(main_func) if main_func else ({}, {}, "kwargs")
+
+    sm_config_path = find_snakemake_config(repo_path)
+    sm_settings = settings_from_snakemake_config(sm_config_path) if sm_config_path else {}
+
+    settings = {
+        "path": repo_path,
+        "docs_url": docs_url or "",
+        **main_settings,
+        **sm_settings,
+    }
+
+    has_run_target = main_func is not None or sm_config_path is not None
+    default_tips = ["/wizard", "/run", "/settings", "/help"] if has_run_target else ["/settings", "/help"]
+
+    cli = GenericCLI(
+        app_name=app_name,
+        ascii_art=clz.get("ascii_art"),
+        accent_color=clz.get("accent_color", "#d97757"),
+        settings=settings,
+        tips=clz.get("tips") if clz.get("tips") else default_tips,
+        updates=clz.get("updates"),
+    )
+    cli.arg_meta = arg_meta
+
+    # Config persists settings across runs (so a value the user explicitly
+    # set via /settings, e.g. username="test", survives between sessions).
+    # But that means a key first discovered with no default (None) stays
+    # None forever in the persisted store, even after main()'s source gains
+    # an explicit default later (e.g. clean=True, verbosity=3). Backfill: if
+    # the persisted value is still None, adopt the freshly discovered
+    # default instead of leaving it stuck.
+    for key, val in {**main_settings, **sm_settings}.items():
+        if cli.config.get(key) is None and val is not None:
+            cli.config.set(key, val)
+
+    # Only show /run if there's actually something to run.
+    if not has_run_target:
+        cli._commands.pop("/run", None)
+        if "/run" in cli.tips:
+            cli.tips = [t for t in cli.tips if t != "/run"]
+
+    if has_run_target:
+        @cli.command("/run", "Run the project's main()/Snakemake workflow with current settings")
+        def _cmd_run(prompt):
+            if main_func is not None:
+                cli.status("Running main()...")
+                if call_style == "argv":
+                    argv = ["clizard"]
+                    for name, meta in arg_meta.items():
+                        flag = meta.get("flag")
+                        if not flag:
+                            continue
+                        val = cli.config.get(name)
+                        if val is None:
+                            continue
+                        if meta.get("is_flag"):
+                            if val:
+                                argv.append(flag)
+                        else:
+                            argv.extend([flag, str(val)])
+                    old_argv = sys.argv
+                    sys.argv = argv
+                    try:
+                        result = main_func()
+                    finally:
+                        sys.argv = old_argv
+                else:
+                    call_kwargs = {k: cli.config.get(k) for k in main_settings}
+                    result = main_func(**call_kwargs)
+                if result is not None:
+                    cli.assistant_message(str(result))
+
+            if sm_config_path is not None:
+                current_sm = {k: cli.config.get(k) for k in sm_settings}
+                write_snakemake_config(sm_config_path, current_sm)
+                cmd = ["snakemake", "--configfile", str(sm_config_path), "--cores", "all"]
+                console_cmd = " ".join(cmd)
+                cli.status(f"Running: {console_cmd}")
+                try:
+                    result = subprocess.run(cmd, cwd=repo_path, capture_output=True, text=True)
+                    output = (result.stdout + result.stderr).strip()
+                    cli.assistant_message(f"```\n$ {console_cmd}\n{output[-2000:]}\n```")
+                except FileNotFoundError:
+                    cli.error("snakemake is not installed or not on PATH.")
+
+    if main_func is not None:
+        @cli.command("/scaffold", "Generate clizard_main.py wrapping this project's main()")
+        def _cmd_scaffold(prompt):
+            try:
+                out_path = generate_clizard_main(repo_path)
+                cli.assistant_message(f"Wrote `{out_path}`. Run it with:\n\n```\npython {out_path.name}\n```")
+            except RuntimeError as e:
+                cli.error(str(e))
+
+    return cli
+
+
+def main():
+    args = parse_args(app_name="clizard")
+    cli = build_cli(repo_path=args.path or ".")
+    if args.model:
+        cli.config.set("model", args.model)
+    cli.run()
+
+
+if __name__ == "__main__":
+    main()

clizard/cli_args.py

@@ -0,0 +1,95 @@
+"""Argument parsing for GenericCLI-based tools."""
+import argparse
+
+
+def build_parser(app_name="Generic CLI", extra_args=None):
+    """Create an argparse.ArgumentParser with common options.
+
+    extra_args: list of dicts like {"flags": ["--foo"], "kwargs": {...}}
+    to let downstream scripts add their own arguments.
+    """
+    parser = argparse.ArgumentParser(prog=app_name, description=f"{app_name} - interactive CLI")
+    parser.add_argument("--model", default=None, help="Model name/identifier to use")
+    parser.add_argument("--path", default=None, help="Working/project path")
+    parser.add_argument("--config", default=None, help="Path to a JSON config file")
+    parser.add_argument("--name", default=None, help="Override the displayed app name")
+
+    if extra_args:
+        for arg in extra_args:
+            parser.add_argument(*arg["flags"], **arg.get("kwargs", {}))
+
+    return parser
+
+
+def parse_args(app_name="Generic CLI", extra_args=None, argv=None):
+    parser = build_parser(app_name, extra_args)
+    return parser.parse_args(argv)
+
+
+def auto_cli(parser, args=None, app_name=None, handler=None, run_callback=None, config_path=None):
+    """Build a GenericCLI automatically from an existing argparse.ArgumentParser.
+
+    Every `--flag` already defined on `parser` becomes an editable setting:
+    its current value (parsed from argv, or its default) seeds the CLI's
+    `/settings` table, and its `choices`/`type`/`help` are kept so `/settings`
+    can validate and cast edits correctly.
+
+    Parameters
+    ----------
+    parser : argparse.ArgumentParser
+        An already-configured parser (e.g. the one built in your existing
+        `main()`), or just `parser` before calling `parse_args()` on it.
+    args : argparse.Namespace, optional
+        Pre-parsed args. If omitted, `parser.parse_args()` is called.
+    app_name : str, optional
+        Defaults to `parser.prog`.
+    handler : callable(prompt, cli) -> str, optional
+        Called for free-text input. If omitted, free-text input does nothing
+        special; use `run_callback` + a `/run` command instead (see below).
+    run_callback : callable(cli) -> str, optional
+        If given, a `/run` command is registered that calls
+        `run_callback(cli)` using the current settings, mirroring how you'd
+        call your script's `run(...)` function with `args.*`.
+    config_path : str, optional
+        Where to persist settings between sessions.
+
+    Returns
+    -------
+    GenericCLI
+    """
+    from .core import GenericCLI  # local import avoids a circular import
+
+    if args is None:
+        args = parser.parse_args()
+
+    settings = {}
+    arg_meta = {}
+    for action in parser._actions:
+        dest = action.dest
+        if dest in ("help",) or isinstance(action, argparse._HelpAction):
+            continue
+        settings[dest] = getattr(args, dest, action.default)
+        arg_meta[dest] = {
+            "choices": list(action.choices) if action.choices else None,
+            "type": action.type,
+            "help": action.help,
+        }
+
+    cli = GenericCLI(
+        app_name=app_name or parser.prog or "CLI",
+        settings=settings,
+        config_path=config_path,
+        handler=handler,
+        tips=["/run", "/settings", "/docs", "/help"] if run_callback else ["/settings", "/help"],
+    )
+    cli.arg_meta = arg_meta  # exposed for validation / display in /settings
+
+    if run_callback is not None:
+        @cli.command("/run", "Run the script with current settings")
+        def _cmd_run(prompt):
+            cli.status("Running...")
+            result = run_callback(cli)
+            if result is not None:
+                cli.assistant_message(str(result))
+
+    return cli

clizard/clizard_file.py

@@ -0,0 +1,55 @@
+"""Read/write the project-local .clizard metadata file.
+
+This stores anything that can't be auto-discovered from git/pyproject:
+ascii_art, app_name override, docs_url override, accent_color, tips, etc.
+"""
+import json
+from pathlib import Path
+
+DEFAULT_ASCII = r"""
+  .-.
+ |o o|
+ | = |
+/|___|\
+"""
+
+CLIZARD_FILENAME = ".clizard"
+
+
+def load_clizard_file(repo_path="."):
+    """Return the parsed .clizard JSON dict, or {} if absent/invalid."""
+    path = Path(repo_path) / CLIZARD_FILENAME
+    if not path.exists():
+        return {}
+    try:
+        with open(path, "r") as f:
+            return json.load(f)
+    except (json.JSONDecodeError, OSError):
+        return {}
+
+
+def save_clizard_file(data: dict, repo_path="."):
+
+    path = Path(repo_path) / CLIZARD_FILENAME
+    with open(path, "w") as f:
+        json.dump(data, f, indent=2)
+    return path
+
+
+def ensure_clizard_file(repo_path=".", **overrides):
+    """Create a .clizard file with sane defaults if one doesn't exist yet."""
+    path = Path(repo_path) / CLIZARD_FILENAME
+    if path.exists():
+        return load_clizard_file(repo_path)
+
+    data = {
+        "app_name": None,       # None -> auto from pyproject/git
+        "ascii_art": DEFAULT_ASCII,
+        "docs_url": None,       # None -> auto from pyproject, else docs/index.html
+        "accent_color": "#d97757",
+        "tips": ["/wizard", "/run", "/settings", "/docs", "/help"],
+        "updates": [],
+    }
+    data.update(overrides)
+    save_clizard_file(data, repo_path)
+    return data

clizard/config.py

@@ -0,0 +1,50 @@
+"""Settings persistence for GenericCLI."""
+import json
+from pathlib import Path
+
+DEFAULT_CONFIG_DIR = Path.home() / ".config" / "clizard"
+
+
+class Config:
+    """Simple JSON-backed settings store.
+
+    settings dict holds arbitrary key/values (model, path, theme, etc).
+    """
+
+    def __init__(self, app_name: str, defaults: dict = None, config_path: str = None):
+        self.app_name = app_name
+        self.defaults = defaults or {}
+        if config_path:
+            self.path = Path(config_path)
+        else:
+            self.path = DEFAULT_CONFIG_DIR / f"{app_name}.json"
+        self.settings = dict(self.defaults)
+        self.load()
+
+    def load(self):
+        if self.path.exists():
+            try:
+                with open(self.path, "r") as f:
+                    data = json.load(f)
+                self.settings.update(data)
+            except (json.JSONDecodeError, OSError):
+                pass
+        return self.settings
+
+    def save(self):
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        with open(self.path, "w") as f:
+            json.dump(self.settings, f, indent=2)
+
+    def get(self, key, fallback=None):
+        return self.settings.get(key, fallback)
+
+    def set(self, key, value):
+        self.settings[key] = value
+        self.save()
+
+    def update_from_args(self, args_dict: dict):
+        """Override settings with non-None values from parsed CLI args."""
+        for k, v in args_dict.items():
+            if v is not None:
+                self.settings[k] = v