clizard 0.1.0__py3-none-any.whl

clizard/core.py

@@ -0,0 +1,359 @@
+"""Generic Claude-style rich CLI, reusable across projects."""
+import time
+import sys
+from rich import box
+from rich.align import Align
+from rich.console import Console, Group
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.spinner import Spinner
+from rich.table import Table
+from rich.text import Text
+
+from .config import Config
+from .project_info import get_project_info
+
+
+console = Console()
+
+DEFAULT_ASCII = r"""
+  .-.
+ |o o|
+ | = |
+/|___|\
+"""
+
+
+class GenericCLI:
+    """Reusable rich-based chat CLI.
+
+    Pass `handler(prompt, cli) -> str` to process user input, or subclass
+    and override `handle(prompt)`. Register extra slash-commands with
+    `@cli.command("/foo")`.
+    """
+
+    def __init__(
+        self,
+        app_name="Generic CLI",
+        ascii_art=None,
+        accent_color="#d97757",
+        dim_color="#9ca3af",
+        user_color="#3b82f6",
+        settings: dict = None,
+        config_path: str = None,
+        handler=None,
+        tips: list = None,
+        updates: list = None,
+        hidden_settings=None,
+    ):
+        self.app_name = app_name
+        self.ascii_art = ascii_art or DEFAULT_ASCII
+        self.ACCENT = accent_color
+        self.DIM = dim_color
+        self.USER = user_color
+        self.handler = handler
+        self.tips = tips or ["/help", "/settings"]
+        self.updates = updates or ["Initial release"]
+        # Keys that exist in config (e.g. internal/derived values like git
+        # remote info or the model name) but shouldn't clutter /settings or
+        # the /wizard walkthrough. Still readable/writable via
+        # `/settings set <key> <value>` and `self.config.get/set`.
+        self.hidden_settings = set(hidden_settings) if hidden_settings else {
+            "github_user", "github_repo", "remote_url", "default_branch", "model",
+        }
+
+        defaults = {}
+        if settings:
+            defaults.update(settings)
+        self.config = Config(app_name, defaults=defaults, config_path=config_path)
+
+        self._commands = {}
+        self._register_builtins()
+
+    # ---------- command registry ----------
+    def command(self, name, help_text=""):
+        """Decorator: register a slash-command. fn(self, prompt) -> None."""
+        def deco(fn):
+            self._commands[name] = (fn, help_text)
+            return fn
+        return deco
+
+    def register_command(self, name, fn, help_text=""):
+        self._commands[name] = (fn, help_text)
+
+    def _register_builtins(self):
+        self.register_command("/help", self._cmd_help, "Show available commands")
+        self.register_command("/clear", self._cmd_clear, "Clear the terminal")
+        self.register_command("/settings", self._cmd_settings, "View or edit settings")
+        self.register_command("/exit", self._cmd_exit, "Exit the session")
+        self.register_command("/quit", self._cmd_exit, "Exit the session")
+        self.register_command("/install", self._cmd_install, "Install project requirements")
+        self.register_command("/docs", self._cmd_docs, "Open the project documentation")
+        self.register_command("/wizard", self._cmd_wizard, "Step through all settings, then optionally /run")
+
+    def _cmd_help(self, prompt):
+        lines = "\n".join(f"* `{name}` - {desc}" for name, (_, desc) in sorted(self._commands.items()))
+        self.assistant_message(f"### Available Commands\n{lines}")
+
+    def _cmd_clear(self, prompt):
+        console.clear()
+
+    def _cmd_exit(self, prompt):
+        console.print(f"[dim]Goodbye! Thanks for using {self.app_name}.[/dim]")
+        raise SystemExit(0)
+
+    @staticmethod
+    def _cast_value(raw: str, current):
+        """Cast a string CLI value to match the type of the existing setting."""
+        if isinstance(current, bool):
+            return raw.strip().lower() in {"1", "true", "yes", "on"}
+        if isinstance(current, int) and not isinstance(current, bool):
+            try:
+                return int(raw)
+            except ValueError:
+                return raw
+        if isinstance(current, float):
+            try:
+                return float(raw)
+            except ValueError:
+                return raw
+        if raw.lower() == "none":
+            return None
+        return raw
+
+    def _cmd_settings(self, prompt):
+        # /settings              -> interactive view + optional edit
+        # /settings set k v...   -> direct set (v can contain spaces)
+        parts = prompt.split(maxsplit=3)
+        if len(parts) >= 3 and parts[1] == "set":
+            key = parts[2]
+            raw_value = parts[3] if len(parts) > 3 else ""
+            current = self.config.get(key)
+            value = self._cast_value(raw_value, current)
+            self.config.set(key, value)
+            console.print(f"[dim]Set {key} = {value!r}[/dim]")
+            return
+
+        self._show_settings_table()
+        try:
+            answer = Prompt.ask("  ✏️  Edit a setting now?", choices=["y", "n"], default="n")
+        except (KeyboardInterrupt, EOFError):
+            return
+        if answer != "y":
+            return
+
+        keys = [k for k in self.config.settings.keys() if k not in self.hidden_settings]
+        key = Prompt.ask(f"  Which key? [{'/'.join(keys)}]")
+        if key not in self.config.settings:
+            self.error(f"Unknown key: {key}")
+            return
+        current = self.config.get(key)
+        raw_value = Prompt.ask(f"  New value for [bold]{key}[/bold]", default=str(current))
+        value = self._cast_value(raw_value, current)
+        self.config.set(key, value)
+        console.print(f"[dim]Set {key} = {value!r}[/dim]")
+        self._show_settings_table()
+
+    def _cmd_wizard(self, prompt):
+        console.print(f"[bold {self.ACCENT}]Setup Wizard[/bold {self.ACCENT}] — press Enter to keep the current value.\n")
+        meta = getattr(self, "arg_meta", {}) or {}
+
+        for key in list(self.config.settings.keys()):
+            if key in self.hidden_settings:
+                continue
+            current = self.config.get(key)
+            info = meta.get(key, {})
+            help_text = info.get("help")
+            choices = info.get("choices")
+
+            label = f"  [bold]{key}[/bold]"
+            if help_text:
+                label += f" [dim]({help_text})[/dim]"
+            if choices:
+                label += f" [dim]choices: {choices}[/dim]"
+
+            while True:
+                raw_value = Prompt.ask(label, default=str(current))
+                caster = info.get("type")
+                if caster and current is None:
+                    try:
+                        value = caster(raw_value)
+                    except (ValueError, TypeError):
+                        value = self._cast_value(raw_value, current)
+                else:
+                    value = self._cast_value(raw_value, current)
+                if choices and value not in choices:
+                    self.error(f"Invalid value {value!r}. Choose from {choices}.")
+                    continue
+                break
+
+            self.config.set(key, value)
+
+        console.print()
+        self._show_settings_table()
+
+        if "/run" in self._commands:
+            try:
+                answer = Prompt.ask("  ▶️  Start /run now?", choices=["y", "n"], default="y")
+            except (KeyboardInterrupt, EOFError):
+                return
+            if answer == "y":
+                self._commands["/run"][0]("/run")
+        else:
+            console.print("[dim]No /run command registered.[/dim]")
+
+    def _cmd_install(self, prompt):
+        import subprocess
+        from pathlib import Path
+
+        repo_path = Path(self.config.get("path", "."))
+        pyproject = repo_path / "pyproject.toml"
+        requirements = repo_path / "requirements.txt"
+
+        if pyproject.exists():
+            cmd = [sys.executable, "-m", "pip", "install", "-e", str(repo_path)]
+        elif requirements.exists():
+            cmd = [sys.executable, "-m", "pip", "install", "-r", str(requirements)]
+        else:
+            self.error("No pyproject.toml or requirements.txt found.")
+            return
+
+        console.print(f"[dim]$ {' '.join(cmd)}[/dim]")
+        self.status("Installing...")
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True)
+        except Exception as e:
+            self.error(str(e))
+            return
+
+        if result.returncode == 0:
+            self.assistant_message("Install completed successfully.")
+        else:
+            self.error(result.stderr.strip()[-1000:] or "Install failed.")
+
+    def _cmd_docs(self, prompt):
+        import webbrowser
+        from pathlib import Path
+
+        docs_url = self.config.get("docs_url")
+        repo_path = Path(self.config.get("path", "."))
+        local_docs = repo_path / "docs" / "index.html"
+
+        if local_docs.exists():
+            target = local_docs.resolve().as_uri()
+        elif docs_url:
+            target = docs_url
+        else:
+            self.error("No docs/index.html or docs_url configured.")
+            return
+
+        console.print(f"[dim]Opening {target}[/dim]")
+        webbrowser.open(target)
+
+    def _show_settings_table(self):
+        table = Table(
+            title="Current Configuration Settings",
+            box=box.ROUNDED,
+            border_style=self.ACCENT,
+            show_lines=False,
+        )
+        table.add_column("Parameter", style=self.ACCENT)
+        table.add_column("Current Value")
+        for k, v in self.config.settings.items():
+            if k in self.hidden_settings:
+                continue
+            table.add_row(str(k), str(v))
+        console.print(table)
+
+    # ---------- rendering ----------
+    def welcome(self):
+        repo_info = get_project_info()
+
+        console.print()
+        # Build a centered Text block for the header so all fragments are centered.
+        header_text = Text(justify="center")
+        header_text.append(f"{self.app_name}\n", style=f"bold {self.ACCENT} reverse")
+        # Ensure ascii art is on its own centered block
+        header_text.append(f"\n{self.ascii_art}\n", style=self.ACCENT)
+        if repo_info.get('description'):
+            header_text.append(f"\n{repo_info['description']}")
+
+        centered_header = Align.center(header_text, vertical="middle")
+
+        grid = Table.grid(expand=True, padding=(0, 4))
+        grid.add_column(ratio=1)
+        grid.add_column(ratio=1)
+
+        tips_md = "\n".join(f"  • [cyan]{t}[/cyan]" for t in self.tips)
+        updates_md = "\n".join(f"• {u}" for u in self.updates)
+
+        tips_text = Text.from_markup(f"[bold {self.ACCENT}]Getting started[/bold {self.ACCENT}]\n\nType commands like:\n{tips_md}")
+        updates_text = Text.from_markup(f"[bold {self.ACCENT}]What's new[/bold {self.ACCENT}]\n\n{updates_md}")
+
+        grid.add_row(tips_text, updates_text)
+
+        layout_group = Group(centered_header, "─" * 64, "", grid)
+
+        console.print(
+            Align.center(
+                Panel(layout_group, box=box.ROUNDED, border_style=self.ACCENT, padding=(2, 4), width=76)
+            )
+        )
+        console.print()
+
+    def user_message(self, text):
+        console.print(f"\n[bold {self.USER}]👤 You[/bold {self.USER}] › {text}\n")
+
+    def assistant_message(self, text):
+        console.print(f"[bold {self.ACCENT}]🤖 Assistant[/bold {self.ACCENT}]")
+        console.print("═" * 40, style=self.ACCENT)
+        console.print(Markdown(text))
+        console.print("═" * 40, style="dim")
+        console.print()
+
+    def status(self, text, duration=1.2):
+        with Live(Spinner("dots", text=f"[dim]{text}[/dim]", style=self.ACCENT), refresh_per_second=12, transient=True):
+            time.sleep(duration)
+
+    def tool_call(self, tool_name):
+        console.print(f"  [dim]🛠️ Running tool:[/dim] [italic cyan]{tool_name}[/italic cyan]...")
+
+    def error(self, text):
+        console.print(f"[bold red]✕ Error:[/bold red] {text}")
+
+    # ---------- main loop ----------
+    def handle(self, prompt):
+        """Default handler if none supplied; override or pass `handler=`."""
+        if self.handler:
+            return self.handler(prompt, self)
+        return f"Successfully captured your request: **'{prompt}'**."
+
+    def run(self):
+        self.welcome()
+        while True:
+            try:
+                prompt = Prompt.ask(f"[bold {self.ACCENT}]❯[/bold {self.ACCENT}]").strip()
+                if not prompt:
+                    continue
+
+                cmd = prompt.split(maxsplit=1)[0]
+                if cmd in self._commands:
+                    fn, _ = self._commands[cmd]
+                    fn(prompt)
+                    continue
+                if cmd.startswith("/"):
+                    self.error(f"Unknown command: {cmd} (type /help for a list)")
+                    continue
+
+                self.user_message(prompt)
+                self.status("Thinking...")
+                reply = self.handle(prompt)
+                self.assistant_message(reply)
+
+            except SystemExit:
+                break
+            except (KeyboardInterrupt, EOFError):
+                console.print("\n[dim]Session terminated gracefully.[/dim]")
+                break

clizard/discover.py

@@ -0,0 +1,349 @@
+"""Find a repo's entry-point main() function and turn its signature into
+editable CLI settings, without needing argparse to be structured any
+particular way.
+"""
+import importlib.util
+import inspect
+import sys
+import re
+from pathlib import Path
+from .git_info import get_git_info
+
+
+"""Locate the most likely entry-point .py file in a repo."""
+def _find_entry_file(repo_path="."):
+    repo_path = Path(repo_path)
+    repo_name = repo_path.name
+
+    CANDIDATE_FILENAMES = [
+        "__main__.py",
+        "main.py",
+        f"{repo_name}.py",
+    ]
+
+    # Add GitHub repo name if available
+    gitinfo = get_git_info()
+    if gitinfo.get("github_repo"):
+        CANDIDATE_FILENAMES.append(f"{gitinfo['github_repo']}.py")
+
+    CANDIDATE_FILENAMES = list(dict.fromkeys(CANDIDATE_FILENAMES))
+
+    # --- 1. Direct top-level candidates ---
+    for name in CANDIDATE_FILENAMES:
+        # subfolder match
+        for candidate in repo_path.glob(f"*/{name}"):
+            return candidate
+
+        # direct match
+        direct = repo_path / name
+        if direct.exists():
+            return direct
+
+    # --- 2. Find file that actually handles arguments ---
+    ARG_PATTERNS = [
+        r"sys\.argv",
+        r"argparse",
+        r"ArgumentParser",
+        r"click\.command",
+        r"typer\.run",
+    ]
+
+    MAIN_PATTERN = r"def\s+main\s*\("
+
+    for py_file in repo_path.rglob("*.py"):
+        if ".git" in py_file.parts or "site-packages" in py_file.parts:
+            continue
+
+        try:
+            text = py_file.read_text(errors="ignore")
+        except OSError:
+            continue
+
+        # must define main()
+        if not re.search(MAIN_PATTERN, text):
+            continue
+
+        # must reference arguments
+        if any(re.search(p, text) for p in ARG_PATTERNS):
+            return py_file
+
+    # --- 3. Fallback: any file with main() and __name__ check ---
+    for py_file in repo_path.rglob("*.py"):
+        if ".git" in py_file.parts or "site-packages" in py_file.parts:
+            continue
+
+        try:
+            text = py_file.read_text(errors="ignore")
+        except OSError:
+            continue
+
+        if "__name__" in text and "def main(" in text:
+            return py_file
+
+    return None
+
+def _load_module(py_file: Path):
+    """Load py_file as a module, preserving package context so that any
+    relative imports (`from . import foo`, `from .bar import baz`) inside
+    it actually resolve, instead of raising ImportError.
+
+    If py_file lives inside a package (its directory has an __init__.py),
+    we import it as a real submodule of that package via importlib, with
+    the package's *parent* directory on sys.path. Otherwise we fall back
+    to loading it as a standalone module.
+    """
+    parent = py_file.parent
+
+    if (parent / "__init__.py").exists():
+        package_name = parent.name
+        package_parent_dir = str(parent.parent)
+        sys.path.insert(0, package_parent_dir)
+        try:
+            module_name = f"{package_name}.{py_file.stem}"
+            # Drop any stale cached import from a previous discovery run.
+            sys.modules.pop(module_name, None)
+            sys.modules.pop(package_name, None)
+            module = importlib.import_module(module_name)
+        finally:
+            sys.path.remove(package_parent_dir)
+        return module
+
+    module_name = f"_clizard_discovered_{py_file.stem}"
+    spec = importlib.util.spec_from_file_location(module_name, py_file)
+    module = importlib.util.module_from_spec(spec)
+    sys.path.insert(0, str(py_file.parent))
+    try:
+        spec.loader.exec_module(module)
+    finally:
+        sys.path.pop(0)
+    return module
+
+
+def find_main(repo_path="."):
+    """Return (module, main_func, file_path) or (None, None, None)."""
+    py_file = _find_entry_file(repo_path)
+    if py_file is None:
+        return None, None, None
+
+    try:
+        module = _load_module(py_file)
+    except Exception as e:
+        print(f"clizard: failed to import {py_file} to discover main(): {e!r}", file=sys.stderr)
+        return None, None, py_file
+
+    main_func = getattr(module, "main", None)
+    if main_func is None or not callable(main_func):
+        return module, None, py_file
+
+    return module, main_func, py_file
+
+
+def _extract_argparse_settings(main_func):
+    """Many main()s take *no* parameters and instead build their own
+    argparse.ArgumentParser() internally, reading from sys.argv. In that
+    case there's nothing in the signature to inspect, but the settings
+    are sitting right there in the source as `parser.add_argument(...)`
+    calls. Parse the function's source with `ast` and recover them.
+
+    Returns (settings, arg_meta). arg_meta entries carry a "flag" (e.g.
+    "--username") and "is_flag" (True for store_true/store_false), which
+    the generated /run command uses to rebuild sys.argv before calling
+    main() with no arguments, since main() will parse it itself.
+    """
+    import ast
+
+    settings = {}
+    arg_meta = {}
+    try:
+        source = inspect.getsource(main_func)
+    except (OSError, TypeError):
+        return settings, arg_meta
+
+    try:
+        tree = ast.parse(source)
+    except SyntaxError:
+        return settings, arg_meta
+
+    parser_names = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Assign) and isinstance(node.value, ast.Call):
+            func = node.value.func
+            func_name = func.attr if isinstance(func, ast.Attribute) else getattr(func, "id", None)
+            if func_name == "ArgumentParser":
+                for target in node.targets:
+                    if isinstance(target, ast.Name):
+                        parser_names.add(target.id)
+
+    if not parser_names:
+        return settings, arg_meta
+
+    for node in ast.walk(tree):
+        if not (isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute)
+                and node.func.attr == "add_argument"):
+            continue
+        obj = node.func.value
+        if not (isinstance(obj, ast.Name) and obj.id in parser_names):
+            continue
+
+        flags = [a.value for a in node.args if isinstance(a, ast.Constant) and isinstance(a.value, str)]
+        if not flags:
+            continue
+        long_flags = [f for f in flags if f.startswith("--")]
+        flag = long_flags[0] if long_flags else flags[-1]
+        dest_name = flag.lstrip("-").replace("-", "_")
+
+        kw = {}
+        type_name = None
+        for keyword in node.keywords:
+            if keyword.arg is None:
+                continue
+            if keyword.arg == "type" and isinstance(keyword.value, ast.Name):
+                type_name = keyword.value.id  # e.g. "int", "str", "float"
+                continue
+            try:
+                kw[keyword.arg] = ast.literal_eval(keyword.value)
+            except (ValueError, SyntaxError):
+                kw[keyword.arg] = None
+
+        dest_name = kw.get("dest", dest_name)
+        action = kw.get("action")
+        is_flag = action in ("store_true", "store_false")
+        default = kw.get("default")
+        if is_flag and default is None:
+            default = (action == "store_false")
+
+        settings[dest_name] = default
+        arg_meta[dest_name] = {
+            "choices": kw.get("choices"),
+            "type": type_name,
+            "help": kw.get("help"),
+            "flag": flag,
+            "is_flag": is_flag,
+        }
+
+    return settings, arg_meta
+
+
+def settings_from_main(main_func):
+    """Inspect main()'s signature -> (settings dict, arg_meta dict, call_style).
+
+    call_style is "kwargs" when main() takes plain keyword parameters
+    (settings become those params, and /run calls main(**settings)), or
+    "argv" when main() takes no usable parameters but builds its own
+    argparse.ArgumentParser() internally (settings are recovered from its
+    add_argument() calls via AST, and /run rebuilds sys.argv before
+    calling main() with no arguments).
+    """
+    settings = {}
+    arg_meta = {}
+    try:
+        sig = inspect.signature(main_func)
+    except (TypeError, ValueError):
+        sig = None
+
+    if sig is not None:
+        for name, param in sig.parameters.items():
+            if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
+                continue
+            default = None if param.default is inspect.Parameter.empty else param.default
+            annotation = None if param.annotation is inspect.Parameter.empty else param.annotation
+            settings[name] = default
+            arg_meta[name] = {
+                "choices": None,
+                "type": annotation if callable(annotation) else None,
+                "help": None,
+                "flag": None,
+                "is_flag": False,
+            }
+
+    if settings:
+        return settings, arg_meta, "kwargs"
+
+    # main() took no usable params -- see if it builds an argparse parser
+    # internally instead, and recover settings from that.
+    argv_settings, argv_meta = _extract_argparse_settings(main_func)
+    if argv_settings:
+        return argv_settings, argv_meta, "argv"
+
+    return settings, arg_meta, "kwargs"
+
+
+SNAKEMAKE_CONFIG_CANDIDATES = [
+    "config.yaml", "config.yml",
+    "config/config.yaml", "config/config.yml",
+    "workflow/config.yaml", "workflow/config.yml",
+]
+
+
+def find_snakefile(repo_path="."):
+    repo_path = Path(repo_path)
+    for name in ("Snakefile", "workflow/Snakefile"):
+        candidate = repo_path / name
+        if candidate.exists():
+            return candidate
+    matches = list(repo_path.rglob("Snakefile"))
+    return matches[0] if matches else None
+
+
+def find_snakemake_config(repo_path="."):
+    """Locate a Snakemake config YAML: explicit `configfile:` in the
+    Snakefile takes priority, else common default paths are tried.
+    """
+    repo_path = Path(repo_path)
+    snakefile = find_snakefile(repo_path)
+
+    if snakefile and snakefile.exists():
+        try:
+            text = snakefile.read_text(errors="ignore")
+        except OSError:
+            text = ""
+        for line in text.splitlines():
+            line = line.strip()
+            if line.startswith("configfile:"):
+                rel = line.split(":", 1)[1].strip().strip("'\"")
+                candidate = (snakefile.parent / rel).resolve()
+                if candidate.exists():
+                    return candidate
+
+    for rel in SNAKEMAKE_CONFIG_CANDIDATES:
+        candidate = repo_path / rel
+        if candidate.exists():
+            return candidate
+
+    return None
+
+
+def settings_from_snakemake_config(config_path):
+    """Load a Snakemake config YAML -> flat settings dict (keys prefixed
+    'sm_' to avoid clashing with main()'s own argument names).
+    """
+    settings = {}
+    if config_path is None:
+        return settings
+    try:
+        import yaml
+    except ImportError:
+        return settings
+
+    try:
+        with open(config_path, "r") as f:
+            data = yaml.safe_load(f) or {}
+    except (OSError, yaml.YAMLError):
+        return settings
+
+    if not isinstance(data, dict):
+        return settings
+
+    for key, value in data.items():
+        settings[f"sm_{key}"] = value
+
+    return settings
+
+
+def write_snakemake_config(config_path, settings: dict):
+    """Write back sm_-prefixed settings into the Snakemake config YAML."""
+    import yaml
+
+    data = {k[3:]: v for k, v in settings.items() if k.startswith("sm_")}
+    with open(config_path, "w") as f:
+        yaml.safe_dump(data, f, default_flow_style=False)