dev-setup 1.0.0__py3-none-any.whl

dev_setup/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.0.0"

dev_setup/__main__.py

@@ -0,0 +1,9 @@
+from dev_setup.cli import cli
+
+
+def main() -> None:
+    cli()
+
+
+if __name__ == "__main__":
+    main()

dev_setup/base.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import subprocess
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Optional
+
+
+class Tool(ABC):
+    key: str = ""
+    name: str = ""
+    description: str = ""
+    category: str = "custom"
+    install_type: str = "unknown"
+    builtin: bool = True
+    help_cmd: str = ""
+
+    @abstractmethod
+    def is_installed(self) -> bool: ...
+
+    @abstractmethod
+    def install(self) -> Optional[str]:
+        """Install the tool. Return version string if available. Raise on failure."""
+        ...
+
+    @abstractmethod
+    def remove(self) -> None:
+        """Uninstall the tool. Raise on failure."""
+        ...
+
+    def get_version(self) -> str:
+        return ""
+
+
+def run_bash(cmd: str, **kwargs) -> subprocess.CompletedProcess:
+    return subprocess.run(["bash", "-c", cmd], **kwargs)
+
+
+def patch_bashrc(block_name: str, content: str) -> bool:
+    """Idempotently append a named block to ~/.bashrc. Returns True if added."""
+    bashrc = Path.home() / ".bashrc"
+    marker = f"# {block_name}"
+
+    if bashrc.exists() and marker in bashrc.read_text():
+        return False
+
+    with bashrc.open("a") as f:
+        f.write(f"\n{marker}\n{content}\n")
+    return True
+
+
+def remove_bashrc_block(block_name: str) -> bool:
+    """Remove a named block (and the line after the marker) from ~/.bashrc."""
+    bashrc = Path.home() / ".bashrc"
+    if not bashrc.exists():
+        return False
+
+    lines = bashrc.read_text().splitlines(keepends=True)
+    marker = f"# {block_name}"
+    out = []
+    i = 0
+    removed = False
+    while i < len(lines):
+        stripped = lines[i].rstrip()
+        if stripped == marker:
+            i += 1
+            while i < len(lines) and lines[i].strip():
+                i += 1
+            if i < len(lines) and not lines[i].strip():
+                i += 1
+            removed = True
+        else:
+            out.append(lines[i])
+            i += 1
+
+    if removed:
+        bashrc.write_text("".join(out))
+    return removed

dev_setup/cli.py

@@ -0,0 +1,38 @@
+import click
+from dev_setup import __version__
+
+
+@click.group(
+    invoke_without_command=True,
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+@click.pass_context
+def cli(ctx: click.Context) -> None:
+    if ctx.invoked_subcommand is None:
+        from dev_setup.commands.help_cmd import print_help
+        print_help()
+
+
+@cli.command("version")
+def version_cmd() -> None:
+    """Print version and exit."""
+    click.echo(f"dev-setup {__version__}")
+
+
+def _register_commands() -> None:
+    from dev_setup.commands.list_cmd import list_cmd
+    from dev_setup.commands.install_cmd import install_cmd
+    from dev_setup.commands.remove_cmd import remove_cmd
+    from dev_setup.commands.add_cmd import add_cmd
+    from dev_setup.commands.delete_cmd import delete_cmd
+
+    cli.add_command(list_cmd, "list")
+    cli.add_command(install_cmd, "install")
+    cli.add_command(remove_cmd, "remove")
+    cli.add_command(remove_cmd, "uninstall")
+    cli.add_command(add_cmd, "add")
+    cli.add_command(delete_cmd, "delete")
+    cli.add_command(delete_cmd, "rm")
+
+
+_register_commands()

dev_setup/commands/add_cmd.py

@@ -0,0 +1,185 @@
+from __future__ import annotations
+
+import re
+import sys
+from typing import Optional
+
+import click
+
+from dev_setup import registry, ui
+from dev_setup.generic import GenericTool
+
+_VALID_KEY = re.compile(r"^[a-z0-9][a-z0-9_-]*$")
+
+_INSTALL_TEMPLATE = """\
+#!/usr/bin/env bash
+# Install script for {name}
+# Save and close to continue. Delete all content (except this line) to abort.
+set -euo pipefail
+
+"""
+
+_REMOVE_TEMPLATE = """\
+#!/usr/bin/env bash
+# Remove script for {name}
+# Save and close to continue. Leave only comments/blank lines to skip removal.
+set -euo pipefail
+
+"""
+
+
+@click.command("add")
+def add_cmd() -> None:
+    """Add a custom package via guided wizard."""
+    ui.section("Add Custom Package")
+
+    install_type = ui.select(
+        "Package type:",
+        ["npm", "pip", "apt", "git", "script", "bash"],
+    )
+    if not install_type:
+        ui.warn("Aborted.")
+        return
+
+    key = _prompt_key()
+    if not key:
+        return
+
+    name = ui.text_input("Display name:", default=key, required=True)
+    description = ui.text_input("Short description:", required=False)
+
+    kwargs: dict = dict(
+        key=key,
+        name=name,
+        description=description,
+        category="custom",
+        install_type=install_type,
+    )
+
+    if install_type == "npm":
+        kwargs["npm_name"] = ui.text_input("npm package name:", default=key, required=True)
+        kwargs["check_cmd"] = ui.text_input("Command to check if installed:", default=key)
+
+    elif install_type == "pip":
+        kwargs["pip_name"] = ui.text_input("PyPI package name:", default=key, required=True)
+        kwargs["check_cmd"] = ui.text_input("Command to check if installed:", default=key)
+
+    elif install_type == "apt":
+        kwargs["apt_packages"] = ui.text_input(
+            "apt package(s) (space-separated):", default=key, required=True
+        )
+        kwargs["check_cmd"] = ui.text_input("Command to check if installed:", default=key)
+
+    elif install_type == "git":
+        kwargs["git_url"] = ui.text_input("Git repository URL:", required=True)
+        kwargs["git_install_cmd"] = ui.text_input(
+            "Post-clone install command (optional, run inside repo):", required=False
+        )
+        kwargs["git_remove_cmd"] = ui.text_input(
+            "Pre-delete remove command (optional):", required=False
+        )
+        kwargs["check_cmd"] = ui.text_input("Command to check if installed:", required=False)
+
+    elif install_type == "script":
+        kwargs["script_url"] = ui.text_input("Install script URL (curl | sh):", required=True)
+        kwargs["check_cmd"] = ui.text_input("Command to check if installed:", required=False)
+
+    elif install_type == "bash":
+        kwargs["check_cmd"] = ui.text_input(
+            "Command to verify installation (e.g. bat, aws):", required=False
+        )
+        install_script = _edit_script("install", name, required=True)
+        if install_script is None:
+            ui.warn("No install script provided — aborted.")
+            return
+        kwargs["install_script"] = install_script
+
+        remove_script = _edit_script("remove", name, required=False)
+        if remove_script:
+            kwargs["remove_script"] = remove_script
+
+    kwargs["help_cmd"] = ui.text_input(
+        "Help command (optional, e.g. tool --help):", required=False
+    )
+
+    ui.console.print()
+    ui.console.print("[bold]Summary[/]")
+    for k, v in kwargs.items():
+        if v:
+            display = _truncate_script(v) if k.endswith("_script") else v
+            ui.console.print(f"  [dim]{k:<18}[/] {display}")
+    ui.console.print()
+
+    if not ui.confirm("Save this package?"):
+        ui.warn("Aborted — package not saved.")
+        return
+
+    tool = GenericTool(**kwargs)
+    tool.save()
+
+    from dev_setup import registry as _reg
+    _reg._registry[key] = tool
+    if key not in _reg._order:
+        _reg._order.append(key)
+
+    ui.success(f"Package '{key}' added. Install with: dev-setup install {key}")
+
+
+def _prompt_key() -> str:
+    while True:
+        key = ui.text_input("Package key (lowercase, hyphens ok):", required=True)
+        if not _VALID_KEY.match(key):
+            ui.error("Key must be lowercase letters, digits, hyphens, or underscores.")
+            continue
+        if registry.exists(key):
+            ui.error(f"A package with key '{key}' already exists.")
+            if not ui.confirm("Use a different key?"):
+                return ""
+            continue
+        return key
+
+
+def _edit_script(action: str, package_name: str, required: bool = True) -> Optional[str]:
+    """Open $EDITOR with a bash template. Returns stripped script or None if aborted."""
+    template = (_INSTALL_TEMPLATE if action == "install" else _REMOVE_TEMPLATE).format(
+        name=package_name
+    )
+    label = "install" if action == "install" else "remove (optional)"
+    ui.console.print()
+    ui.info(f"Opening $EDITOR for the [bold]{label}[/] script...")
+    ui.dim("Write your bash commands, save, and close the editor to continue.")
+    ui.console.print()
+
+    try:
+        content = click.edit(text=template, extension=".sh", require_save=False)
+    except Exception as exc:
+        ui.error(f"Could not open editor: {exc}")
+        ui.dim("Set the EDITOR environment variable (e.g. export EDITOR=nano) and try again.")
+        return None
+
+    if content is None:
+        return None
+
+    script = _strip_template_comments(content)
+    if not script and required:
+        ui.error("Install script cannot be empty.")
+        return None
+    return script or ""
+
+
+def _strip_template_comments(content: str) -> str:
+    """Remove comment-only lines and leading/trailing blank lines."""
+    lines = [
+        line for line in content.splitlines()
+        if line.strip() and not line.strip().startswith("#")
+    ]
+    return "\n".join(lines).strip()
+
+
+def _truncate_script(script: str) -> str:
+    lines = [l for l in script.splitlines() if l.strip()]
+    if not lines:
+        return "[dim](empty)[/]"
+    first = lines[0][:60]
+    suffix = f"  [dim]+{len(lines) - 1} more lines[/]" if len(lines) > 1 else ""
+    return f"{first}{suffix}"

dev_setup/commands/delete_cmd.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+import sys
+
+import click
+
+from dev_setup import registry, ui
+from dev_setup.generic import CUSTOM_DIR
+
+
+@click.command("delete")
+@click.argument("key")
+def delete_cmd(key: str) -> None:
+    """Remove a custom package from the registry."""
+    if not registry.exists(key):
+        ui.error(f"No package with key '{key}' found.")
+        sys.exit(1)
+
+    tool = registry.get(key)
+    assert tool is not None
+
+    if tool.builtin:
+        ui.error(f"'{key}' is a built-in package and cannot be deleted.")
+        sys.exit(1)
+
+    pkg_file = CUSTOM_DIR / f"{key}.json"
+    if not pkg_file.exists():
+        ui.error(f"Package file not found: {pkg_file}")
+        sys.exit(1)
+
+    ui.console.print(f"\n  [bold]{tool.name}[/] — {tool.description}\n")
+
+    if not ui.confirm(f"Delete '{key}' from the registry?", default=False):
+        ui.dim("Aborted.")
+        return
+
+    pkg_file.unlink()
+
+    if key in registry._registry:
+        del registry._registry[key]
+    if key in registry._order:
+        registry._order.remove(key)
+
+    ui.success(f"Package '{key}' deleted from registry.")

dev_setup/commands/help_cmd.py

@@ -0,0 +1,46 @@
+from dev_setup import ui
+from dev_setup.generic import CUSTOM_DIR
+
+
+def print_help() -> None:
+    ui.print_banner()
+    ui.console.print("[bold]USAGE[/]")
+    ui.console.print("  dev-setup [bold cyan]<command>[/] [OPTIONS] [ARGS]\n")
+
+    ui.console.print("[bold]COMMANDS[/]")
+    rows = [
+        ("list",    "[--installed] [--available] [category]", "List packages"),
+        ("install", "[package ...]",                          "Install packages (interactive if no args)"),
+        ("remove",  "<package ...>",                          "Uninstall installed packages"),
+        ("add",     "",                                        "Add a custom package (guided wizard)"),
+        ("delete",  "<key>",                                  "Remove a custom package from the registry"),
+        ("version", "",                                        "Show version"),
+    ]
+    for cmd, args, desc in rows:
+        ui.console.print(
+            f"  [bold cyan]{cmd:<10}[/] [dim]{args:<40}[/]  {desc}"
+        )
+
+    ui.console.print()
+    ui.console.print("[bold]EXAMPLES[/]")
+    examples = [
+        "dev-setup list",
+        "dev-setup list core",
+        "dev-setup list --installed",
+        "dev-setup install docker nvm",
+        "dev-setup install",
+        "dev-setup remove htop",
+        "dev-setup add",
+        "dev-setup delete my-tool",
+    ]
+    for ex in examples:
+        ui.console.print(f"  [dim]$[/] [green]{ex}[/]")
+
+    ui.console.print()
+    ui.console.print("[bold]CATEGORIES[/]")
+    ui.console.print("  [cyan]core[/]    Always-installed tools (Docker, NVM, uv)")
+    ui.console.print("  [cyan]tools[/]   Optional utilities (PHP, Starship, htop)")
+    ui.console.print("  [cyan]custom[/]  User-added packages\n")
+
+    ui.console.print("[bold]CONFIG[/]")
+    ui.console.print(f"  Custom packages: [dim]{CUSTOM_DIR}[/]\n")

dev_setup/commands/install_cmd.py

@@ -0,0 +1,96 @@
+from __future__ import annotations
+
+import sys
+from typing import Tuple
+
+import click
+import questionary
+
+from dev_setup import registry, ui
+from dev_setup.base import Tool
+
+
+@click.command("install")
+@click.argument("packages", nargs=-1)
+def install_cmd(packages: Tuple[str, ...]) -> None:
+    """Install packages. Interactive picker when called with no arguments."""
+    if not packages:
+        _install_interactive()
+    else:
+        failed = False
+        for key in packages:
+            if not registry.exists(key):
+                ui.error(f"Unknown package: '{key}'")
+                failed = True
+                continue
+            if not _install_one(registry.get(key)):  # type: ignore[arg-type]
+                failed = True
+        if failed:
+            sys.exit(1)
+
+
+def _install_one(tool: Tool) -> bool:
+    ui.section(tool.name)
+    if tool.is_installed():
+        ui.success(f"{tool.name} is already installed: {tool.get_version()}")
+        return True
+    try:
+        version = tool.install()
+        msg = f"{tool.name} installed"
+        if version:
+            msg += f": {version}"
+        ui.success(msg)
+        return True
+    except Exception as exc:
+        ui.error(f"Failed to install {tool.name}: {exc}")
+        return False
+
+
+def _install_interactive() -> None:
+    ui.print_banner()
+    tools = registry.all_tools()
+
+    choices = [
+        questionary.Choice(
+            title=(
+                f"{'[installed] ' if t.is_installed() else ''}"
+                f"{t.key:<14} {t.description}"
+            ),
+            value=t.key,
+            checked=False,
+        )
+        for t in tools
+    ]
+
+    selected = questionary.checkbox(
+        "Select packages to install  (Space to toggle, Enter to confirm):",
+        choices=choices,
+        style=ui._STYLE,
+    ).ask()
+
+    if not selected:
+        ui.info("No packages selected.")
+        return
+
+    already = [k for k in selected if registry.get(k) and registry.get(k).is_installed()]  # type: ignore[union-attr]
+    to_install = [k for k in selected if k not in already]
+
+    if already:
+        ui.dim(f"Already installed: {', '.join(already)}")
+
+    if not to_install:
+        ui.info("Nothing new to install.")
+        return
+
+    if not ui.confirm(f"Install {len(to_install)} package(s)?"):
+        ui.warn("Aborted.")
+        return
+
+    failed = False
+    for key in to_install:
+        tool = registry.get(key)
+        if tool and not _install_one(tool):
+            failed = True
+
+    if failed:
+        sys.exit(1)

dev_setup/commands/list_cmd.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import click
+from rich.table import Table
+
+from dev_setup import registry, ui
+
+
+@click.command("list")
+@click.option("--installed", "show_filter", flag_value="installed", help="Show only installed packages")
+@click.option("--available", "show_filter", flag_value="available", help="Show only uninstalled packages")
+@click.argument("category", required=False)
+def list_cmd(show_filter: str, category: str) -> None:
+    """List available packages."""
+    ui.print_banner()
+
+    tools = registry.all_tools()
+    by_cat: dict = {}
+
+    for tool in tools:
+        if category and tool.category != category:
+            continue
+        is_inst = tool.is_installed()
+        if show_filter == "installed" and not is_inst:
+            continue
+        if show_filter == "available" and is_inst:
+            continue
+        by_cat.setdefault(tool.category, []).append((tool, is_inst))
+
+    if not by_cat:
+        ui.warn("No packages match the given filters.")
+        return
+
+    for cat in ("core", "tools", "custom"):
+        entries = by_cat.get(cat, [])
+        if not entries:
+            continue
+
+        ui.console.print(f"  [bold magenta]{cat.upper()}[/]")
+        ui.divider()
+
+        tbl = Table(box=None, padding=(0, 1), show_header=True, header_style="dim")
+        tbl.add_column("", width=2)
+        tbl.add_column("Package", style="bold", min_width=12)
+        tbl.add_column("Description", min_width=36)
+        tbl.add_column("Type", style="dim", min_width=8)
+        tbl.add_column("Version", style="dim")
+
+        for tool, is_inst in entries:
+            icon = "[green bold]✔[/]" if is_inst else "[red bold]✘[/]"
+            version = tool.get_version() if is_inst else ""
+            tbl.add_row(icon, tool.key, tool.description, tool.install_type, version)
+            if tool.help_cmd:
+                tbl.add_row("", "", f"[dim cyan]  ? {tool.help_cmd}[/]", "", "")
+
+        ui.console.print(tbl)
+        ui.console.print()

dev_setup/commands/remove_cmd.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import sys
+from typing import Tuple
+
+import click
+
+from dev_setup import registry, ui
+from dev_setup.base import Tool
+
+
+@click.command("remove")
+@click.argument("packages", nargs=-1)
+def remove_cmd(packages: Tuple[str, ...]) -> None:
+    """Uninstall installed packages."""
+    if not packages:
+        ui.error("Specify at least one package key. See: dev-setup list --installed")
+        sys.exit(1)
+
+    failed = False
+    for key in packages:
+        if not registry.exists(key):
+            ui.error(f"Unknown package: '{key}'")
+            failed = True
+            continue
+        if not _remove_one(registry.get(key)):  # type: ignore[arg-type]
+            failed = True
+
+    if failed:
+        sys.exit(1)
+
+
+def _remove_one(tool: Tool) -> bool:
+    ui.section(f"Remove {tool.name}")
+
+    if not tool.is_installed():
+        ui.warn(f"{tool.name} is not installed — nothing to remove.")
+        return True
+
+    if not ui.confirm(f"Remove {tool.name}?", default=False):
+        ui.dim("Skipped.")
+        return True
+
+    try:
+        tool.remove()
+        ui.success(f"{tool.name} removed")
+        return True
+    except Exception as exc:
+        ui.error(f"Failed to remove {tool.name}: {exc}")
+        return False