qwik 0.1.0__py3-none-any.whl

qwik/__init__.py

@@ -0,0 +1,3 @@
+"""A friendly CLI alias manager."""
+
+__version__ = "0.1.0"

qwik/__main__.py

@@ -0,0 +1,6 @@
+"""Allow running ``python -m qwik``."""
+
+from qwik.cli import app
+
+if __name__ == "__main__":
+    app()

qwik/cli.py

@@ -0,0 +1,142 @@
+"""Main Typer CLI application wiring all subcommands together."""
+
+from __future__ import annotations
+
+import typer
+from rich.console import Console
+
+from qwik import __version__
+from qwik.commands.add import add_command
+from qwik.commands.doctor import doctor_command
+from qwik.commands.edit import edit_command
+from qwik.commands.enable_disable import disable_command, enable_command
+from qwik.commands.exporter import export_command
+from qwik.commands.importer import import_command
+from qwik.commands.init_shell import init_shell_command
+from qwik.commands.list import list_command
+from qwik.commands.pick import pick_command
+from qwik.commands.remove import remove_command
+from qwik.commands.rename import rename_command
+from qwik.commands.run import run_command
+from qwik.commands.search import search_command
+from qwik.commands.show import show_command
+from qwik.commands.tag import tag_command, untag_command
+
+__all__ = ["app"]
+
+
+def _version_callback(value: bool) -> None:
+    """Print version and exit."""
+    if value:
+        Console().print(f"qwik {__version__}")
+        raise typer.Exit()
+
+
+app = typer.Typer(
+    name="qwik",
+    help="A friendly CLI alias manager.",
+    no_args_is_help=False,
+    add_completion=True,
+)
+
+# Register subcommands
+app.command("add")(add_command)
+app.command("list")(list_command)
+app.command("show")(show_command)
+app.command("edit")(edit_command)
+app.command("rename")(rename_command)
+app.command("rm")(remove_command)
+app.command("enable")(enable_command)
+app.command("disable")(disable_command)
+app.command("run")(run_command)
+app.command("search")(search_command)
+app.command("pick")(pick_command)
+app.command("tag")(tag_command)
+app.command("untag")(untag_command)
+app.command("export")(export_command)
+app.command("import")(import_command)
+app.command("init")(init_shell_command)
+app.command("doctor")(doctor_command)
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    run_alias: str | None = typer.Option(
+        None,
+        "--run",
+        "-r",
+        help="Run an alias (qwik -r <name> [args...]).",
+    ),
+    list_flag: bool = typer.Option(False, "--list", "-l", help="Quick list."),
+    search_query: str | None = typer.Option(
+        None,
+        "--search",
+        "-s",
+        help="Quick search.",
+    ),
+    version: bool = typer.Option(
+        False,
+        "--version",
+        "-v",
+        help="Show version and exit.",
+        callback=_version_callback,
+        is_eager=True,
+    ),
+    help_flag: bool = typer.Option(
+        False,
+        "--help",
+        "-h",
+        help="Show this message and exit.",
+        is_eager=True,
+    ),
+) -> None:
+    """Top-level callback implementing shortcut flags and bare invocation.
+
+    When invoked with no subcommand and no flags, the fuzzy picker opens.
+    """
+    # If a subcommand is already being handled, do nothing.
+    if ctx.invoked_subcommand is not None:
+        return
+
+    if help_flag:
+        Console().print(ctx.get_help())
+        raise typer.Exit()
+
+    if list_flag:
+        list_command()
+        raise typer.Exit()
+
+    if search_query is not None:
+        search_command(search_query)
+        raise typer.Exit()
+
+    if run_alias is not None:
+        # Need to capture remaining args after -r ... tricky in Typer callback.
+        # We use sys.argv but only look at the FIRST occurrence (index 0/1 are
+        # the Python/qwik executable), so alias names containing "-r" are safe
+        # unless they appear before the flag.
+        import sys
+
+        # Find first occurrence in argv (after the program name)
+        idx = None
+        for i, arg in enumerate(sys.argv[1:], start=1):
+            if arg == "-r" or arg == "--run":
+                idx = i
+                break
+        if idx is None:
+            Console().print(
+                "[qwik.error]Could not locate -r in arguments.[/qwik.error]"
+            )
+            raise typer.Exit(1)
+        remainder = sys.argv[idx + 1 :]
+        if not remainder:
+            Console().print("[qwik.error]Usage: qwik -r <name> [args...][/qwik.error]")
+            raise typer.Exit(1)
+        name = remainder[0]
+        args = remainder[1:]
+        run_command(name, args)
+        raise typer.Exit()
+
+    # Bare invocation → fuzzy picker
+    pick_command()

qwik/commands/add.py

@@ -0,0 +1,110 @@
+"""``qwik add`` — create a new alias."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from qwik.core.conflicts import ConflictChecker
+from qwik.core.models import Alias
+from qwik.core.store import get_store
+from qwik.ui.prompts import (
+    print_error,
+    print_info,
+    print_success,
+    print_warning,
+    prompt_confirm,
+    prompt_text,
+)
+
+__all__ = ["add_command"]
+
+
+def add_command(
+    name: Optional[str] = typer.Argument(None, help="Alias name."),
+    command: list[str] = typer.Argument(None, help="Command the alias expands to."),
+    tag: Optional[str] = typer.Option(
+        None, "--tag", "-t", help="Comma-separated tags."
+    ),
+    description: Optional[str] = typer.Option(
+        None, "--description", "-d", help="Optional description."
+    ),
+    force: bool = typer.Option(
+        False, "--force", "-f", help="Overwrite if alias already exists."
+    ),
+    global_install: bool = typer.Option(
+        False, "--global", "-g", help="(Reserved) install for all users."
+    ),
+) -> None:
+    """Create a new alias.
+
+    When *name* or *command* are omitted, the command runs interactively.
+    """
+    del global_install  # reserved for future use
+    store = get_store()
+    store_data = store.load()
+    console = Console()
+
+    # Interactive mode if name missing
+    if name is None:
+        name = prompt_text("? Alias name", console=console, allow_empty=False)
+    if not command:
+        cmd_input = prompt_text("? Command", console=console, allow_empty=False)
+        command = [cmd_input]
+
+    full_command = " ".join(command)
+
+    # Conflict checks
+    checker = ConflictChecker(store_data)
+    result = checker.check(name)
+
+    if not result.valid_syntax:
+        print_error(
+            result.name, suggestion="Names must match ^[A-Za-z_][A-Za-z0-9_-]*$"
+        )
+        raise typer.Exit(1)
+
+    if result.existing_alias and not force:
+        print_error(
+            f'Alias "{name}" already exists.',
+            suggestion=f"qwik edit {name}  to change the command\n"
+            f"qwik rm {name}     to remove it\n"
+            f"--force            to overwrite",
+        )
+        raise typer.Exit(1)
+
+    if result.is_builtin and not force:
+        print_error(
+            f'"{name}" is a shell builtin. Shadowing it can break your shell.',
+            suggestion="Use --force only if you know what you're doing.",
+        )
+        raise typer.Exit(1)
+
+    if result.needs_warning:
+        print_warning(
+            f'"{name}" shadows {result.path_location}.',
+            console=console,
+        )
+        if not prompt_confirm("Continue?", default=False, console=console):
+            raise typer.Exit(0)
+
+    alias = Alias(
+        command=full_command,
+        tag=tag or "",
+        description=description or "",
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc),
+    )
+
+    try:
+        store_data.add(name, alias, force=force)
+    except KeyError as exc:
+        print_error(str(exc))
+        raise typer.Exit(1)
+
+    store.save_with_backup(store_data)
+    print_success(f'Added "{name}" → {full_command!r}', console=console)
+    print_info("Run `source <rc>` or open a new terminal to use it.", console=console)

qwik/commands/doctor.py

@@ -0,0 +1,153 @@
+"""``qwik doctor`` — diagnose environment and store health."""
+
+from __future__ import annotations
+
+import os
+import shutil
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from qwik.core.store import get_store
+from qwik.shells.base import SUPPORTED_SHELLS
+from qwik.ui.prompts import print_error, print_success, print_warning
+
+__all__ = ["doctor_command"]
+
+
+def doctor_command() -> None:
+    """Diagnose shell, hook status, store readability, and conflicts."""
+    console = Console()
+    store = get_store()
+
+    checks_ok = 0
+    checks_warn = 0
+    checks_err = 0
+
+    # Detect shell
+    shell = _detect_shell()
+    console.print(f"[bold]Shell detected:[/bold] {shell or 'unknown'}")
+    if shell in SUPPORTED_SHELLS:
+        print_success(f"{shell} is supported.", console=console)
+        checks_ok += 1
+    elif shell:
+        print_warning(f"{shell} support is best-effort.", console=console)
+        checks_warn += 1
+
+    # Hook installed?
+    hook_installed = _hook_installed(shell)
+    if hook_installed:
+        print_success("Shell hook appears installed.", console=console)
+        checks_ok += 1
+    else:
+        print_warning(
+            "Shell hook not detected. Run `qwik init <shell> --install`.",
+            console=console,
+        )
+        checks_warn += 1
+
+    # Store readable?
+    data = None
+    try:
+        data = store.load()
+        print_success(f"Store readable ({len(data.aliases)} aliases).", console=console)
+        checks_ok += 1
+    except Exception as exc:
+        print_error(f"Store unreadable: {exc}", console=console)
+        checks_err += 1
+
+    # Conflicts with system commands
+    if data is not None:
+        if data.aliases:
+            conflicts = [n for n in data.aliases if shutil.which(n)]
+            if conflicts:
+                print_warning(
+                    f"Aliases shadowing PATH binaries: {', '.join(conflicts)}",
+                    console=console,
+                )
+                checks_warn += 1
+            else:
+                print_success("No alias shadows a system binary.", console=console)
+                checks_ok += 1
+        else:
+            print_success("No aliases — nothing to shadow.", console=console)
+            checks_ok += 1
+
+    # Summary
+    console.print()
+    total = checks_ok + checks_warn + checks_err
+    console.print(
+        f"[bold]Summary:[/bold] {checks_ok}/{total} passed, "
+        f"{checks_warn} warning(s), {checks_err} error(s)"
+    )
+    if checks_err:
+        raise typer.Exit(1)
+
+
+def _detect_shell() -> str | None:
+    """Attempt to detect the current user's shell.
+
+    Returns:
+        A lowercase shell name (e.g. ``bash``, ``zsh``), or ``None``.
+    """
+    # Prefer the $SHELL environment variable.
+    shell_env = os.environ.get("SHELL", "").lower()
+    if "bash" in shell_env:
+        return "bash"
+    if "zsh" in shell_env:
+        return "zsh"
+    if "fish" in shell_env:
+        return "fish"
+    if "pwsh" in shell_env or "powershell" in shell_env:
+        return "pwsh"
+
+    # Fallback: inspect parent process via /proc on Linux.
+    try:
+        with Path("/proc/self/status").open(encoding="utf-8") as f:
+            for line in f:
+                if line.startswith("PPid:"):
+                    ppid = line.split()[1]
+                    exe_link = Path(f"/proc/{ppid}/exe")
+                    if exe_link.exists():
+                        name = exe_link.resolve().name.lower()
+                        if "bash" in name:
+                            return "bash"
+                        if "zsh" in name:
+                            return "zsh"
+                        if "fish" in name:
+                            return "fish"
+                        if "pwsh" in name or "powershell" in name:
+                            return "pwsh"
+    except Exception:
+        pass
+    return None
+
+
+def _hook_installed(shell: str | None) -> bool:
+    """Crude heuristic: grep rc file for 'qwik init'.
+
+    Args:
+        shell: Detected shell name.
+
+    Returns:
+        ``True`` if the rc file contains an ``qwik init`` invocation.
+    """
+    if shell is None:
+        return False
+    rc_map = {
+        "bash": Path.home() / ".bashrc",
+        "zsh": Path.home() / ".zshrc",
+        "fish": Path.home() / ".config" / "fish" / "config.fish",
+        "pwsh": Path.home()
+        / ".config"
+        / "powershell"
+        / "Microsoft.PowerShell_profile.ps1",
+    }
+    rc = rc_map.get(shell)
+    if rc is None or not rc.exists():
+        return False
+    try:
+        return "qwik init" in rc.read_text(encoding="utf-8")
+    except Exception:
+        return False

qwik/commands/edit.py

@@ -0,0 +1,110 @@
+"""``qwik edit`` — open alias in ``$EDITOR``."""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import tempfile
+from datetime import datetime, timezone
+from pathlib import Path
+
+import typer
+from rich.console import Console
+
+from qwik.core.models import Alias
+from qwik.core.store import get_store
+from qwik.ui.prompts import print_error, print_success
+
+__all__ = ["edit_command"]
+
+
+def edit_command(
+    name: str = typer.Argument(..., help="Alias name to edit."),
+) -> None:
+    """Open the alias entry in ``$EDITOR`` as an editable TOML snippet."""
+    store = get_store()
+    data = store.load()
+    console = Console()
+
+    alias = data.get(name)
+    if alias is None:
+        print_error(f'Alias "{name}" does not exist.', console=console)
+        raise typer.Exit(1)
+
+    editor = os.environ.get("EDITOR", "vi")
+
+    snippet = (
+        f'# Edit the fields below and save/quit to apply changes to "{name}"\n'
+        f"command = {alias.command!r}\n"
+        f"tag = {alias.tag!r}\n"
+        f"description = {alias.description!r}\n"
+        f"enabled = {alias.enabled!r}\n"
+    )
+
+    with tempfile.NamedTemporaryFile(
+        mode="w+", suffix=".toml", delete=False, encoding="utf-8"
+    ) as tmp:
+        tmp.write(snippet)
+        tmp_path = Path(tmp.name)
+
+    try:
+        subprocess.run([editor, str(tmp_path)], check=True)
+        edited_text = tmp_path.read_text(encoding="utf-8")
+        # Very simple parser: extract key = value lines
+        new_fields: dict[str, object] = {}
+        for line in edited_text.splitlines():
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            # Strip inline comments (first unquoted #)
+            comment_idx = -1
+            in_quote: str | None = None
+            for i, ch in enumerate(line):
+                if ch in ('"', "'") and (i == 0 or line[i - 1] != "\\"):
+                    if in_quote == ch:
+                        in_quote = None
+                    elif in_quote is None:
+                        in_quote = ch
+                elif ch == "#" and in_quote is None:
+                    comment_idx = i
+                    break
+            if comment_idx >= 0:
+                line = line[:comment_idx].rstrip()
+            if " = " not in line:
+                continue
+            key, raw_val = line.split(" = ", 1)
+            key = key.strip()
+            raw_val = raw_val.strip()
+            low = raw_val.lower()
+            if low == "true":
+                new_fields[key] = True
+            elif low == "false":
+                new_fields[key] = False
+            elif raw_val.startswith("[") and raw_val.endswith("]"):
+                # list of strings
+                inner = raw_val[1:-1]
+                new_fields[key] = [
+                    v.strip().strip("'\"").strip()
+                    for v in inner.split(",")
+                    if v.strip()
+                ]
+            else:
+                new_fields[key] = raw_val.strip("'\"").strip()
+
+        data.aliases[name] = Alias(
+            command=str(new_fields.get("command", alias.command)),
+            tag=new_fields.get("tag", alias.tag) or [],
+            description=str(new_fields.get("description", alias.description)),
+            enabled=new_fields.get("enabled", alias.enabled),
+            created_at=alias.created_at,
+            updated_at=datetime.now(timezone.utc),
+            last_used=alias.last_used,
+            run_count=alias.run_count,
+        )
+        store.save_with_backup(data)
+        print_success(f'Updated "{name}".', console=console)
+    except subprocess.CalledProcessError as exc:
+        print_error(f"Editor exited with code {exc.returncode}.", console=console)
+        raise typer.Exit(1)
+    finally:
+        tmp_path.unlink(missing_ok=True)

qwik/commands/enable_disable.py

@@ -0,0 +1,50 @@
+"""``qwik enable`` / ``qwik disable`` — toggle alias state."""
+
+from __future__ import annotations
+
+from datetime import datetime, timezone
+
+import typer
+from rich.console import Console
+
+from qwik.core.store import get_store
+from qwik.ui.prompts import print_error, print_success
+
+__all__ = ["enable_command", "disable_command"]
+
+
+def _toggle(name: str, enabled: bool) -> None:
+    """Set the enabled flag for *name* and persist.
+
+    Args:
+        name: Alias identifier.
+        enabled: Desired state.
+    """
+    store = get_store()
+    data = store.load()
+    console = Console()
+
+    alias = data.get(name)
+    if alias is None:
+        print_error(f'Alias "{name}" does not exist.', console=console)
+        raise typer.Exit(1)
+
+    alias.enabled = enabled
+    alias.updated_at = datetime.now(timezone.utc)
+    store.save_with_backup(data)
+    state = "enabled" if enabled else "disabled"
+    print_success(f'"{name}" is now {state}.', console=console)
+
+
+def enable_command(
+    name: str = typer.Argument(..., help="Alias name to enable."),
+) -> None:
+    """Re-enable a previously disabled alias."""
+    _toggle(name, True)
+
+
+def disable_command(
+    name: str = typer.Argument(..., help="Alias name to disable."),
+) -> None:
+    """Temporarily disable an alias without deleting it."""
+    _toggle(name, False)

qwik/commands/exporter.py

@@ -0,0 +1,53 @@
+"""``qwik export`` — write aliases to TOML/JSON."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+
+from qwik.core.store import get_store
+from qwik.ui.prompts import print_error, print_success
+
+__all__ = ["export_command"]
+
+
+def export_command(
+    path: Path = typer.Argument(..., help="Destination file path."),
+    format: Optional[str] = typer.Option(
+        None,
+        "--format",
+        "-f",
+        help="toml or json (inferred from extension if omitted).",
+    ),
+) -> None:
+    """Export aliases to a file."""
+    store = get_store()
+    data = store.load()
+    console = Console()
+
+    if not data.aliases:
+        print_error("No aliases to export.", console=console)
+        raise typer.Exit(1)
+
+    fmt = (format or path.suffix.lstrip(".")).lower()
+    if fmt not in ("toml", "json"):
+        print_error(f"Unknown format '{fmt}'. Use toml or json.", console=console)
+        raise typer.Exit(1)
+
+    if fmt == "toml":
+        import tomlkit
+
+        doc = store._store_to_document(data)
+        path.write_text(tomlkit.dumps(doc), encoding="utf-8")
+    else:
+        import json
+
+        path.write_text(
+            json.dumps(data.model_dump(mode="json"), indent=2),
+            encoding="utf-8",
+        )
+
+    print_success(f"Exported {len(data.aliases)} aliases to {path}", console=console)