dev-setup 1.0.0__py3-none-any.whl

dev_setup/packages/saml2aws.py

@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+import json
+import platform
+import shutil
+import subprocess
+import tarfile
+import tempfile
+import urllib.request
+from pathlib import Path
+from typing import Optional
+
+from dev_setup.base import Tool
+
+_INSTALL_PATH = Path("/usr/local/bin/saml2aws")
+_RELEASES_API = "https://api.github.com/repos/Versent/saml2aws/releases/latest"
+
+
+class Saml2AwsTool(Tool):
+    key = "saml2aws"
+    name = "saml2aws"
+    description = "SAML → AWS STS credentials CLI (Versent)"
+    category = "tools"
+    install_type = "script"
+    help_cmd = "saml2aws --help"
+
+    def is_installed(self) -> bool:
+        return shutil.which("saml2aws") is not None
+
+    def get_version(self) -> str:
+        r = subprocess.run(["saml2aws", "--version"], capture_output=True, text=True)
+        out = r.stdout.strip() or r.stderr.strip()
+        return out.splitlines()[0] if out else ""
+
+    def install(self) -> Optional[str]:
+        from dev_setup import ui
+
+        version = self._latest_version()
+        arch = "arm64" if platform.machine() == "aarch64" else "amd64"
+        filename = f"saml2aws_{version}_linux_{arch}.tar.gz"
+        url = (
+            f"https://github.com/Versent/saml2aws/releases/download/"
+            f"v{version}/{filename}"
+        )
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            archive = Path(tmpdir) / filename
+
+            with ui.spinner(f"Downloading saml2aws v{version}..."):
+                subprocess.run(
+                    ["curl", "-fsSL", "-o", str(archive), url],
+                    check=True, capture_output=True,
+                )
+
+            with ui.spinner("Extracting saml2aws..."):
+                with tarfile.open(archive) as tf:
+                    tf.extractall(tmpdir)
+
+            binary = Path(tmpdir) / "saml2aws"
+            if not binary.exists():
+                raise RuntimeError(f"saml2aws binary not found in archive")
+
+            with ui.spinner("Installing saml2aws to /usr/local/bin..."):
+                subprocess.run(
+                    ["sudo", "mv", str(binary), str(_INSTALL_PATH)],
+                    check=True, capture_output=True,
+                )
+                subprocess.run(
+                    ["sudo", "chmod", "+x", str(_INSTALL_PATH)],
+                    check=True, capture_output=True,
+                )
+
+        if not self.is_installed():
+            raise RuntimeError("saml2aws installation failed — binary not found")
+        return self.get_version()
+
+    def remove(self) -> None:
+        from dev_setup import ui
+
+        if not _INSTALL_PATH.exists():
+            raise RuntimeError(f"saml2aws not found at {_INSTALL_PATH}")
+
+        with ui.spinner("Removing saml2aws..."):
+            subprocess.run(
+                ["sudo", "rm", "-f", str(_INSTALL_PATH)],
+                check=True, capture_output=True,
+            )
+
+    @staticmethod
+    def _latest_version() -> str:
+        try:
+            req = urllib.request.Request(
+                _RELEASES_API, headers={"User-Agent": "dev-setup"}
+            )
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                data = json.loads(resp.read())
+                tag = data["tag_name"]
+                return tag.lstrip("v")
+        except Exception:
+            return "2.36.6"

dev_setup/packages/starship.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from dev_setup.base import Tool, patch_bashrc, remove_bashrc_block
+
+STARSHIP_BLOCK = "Starship prompt"
+STARSHIP_INIT_LINE = 'eval "$(starship init bash)"'
+
+
+class StarshipTool(Tool):
+    key = "starship"
+    name = "Starship"
+    description = "Fast, cross-shell customizable prompt"
+    category = "tools"
+    install_type = "script"
+    help_cmd = "starship --help"
+
+    def is_installed(self) -> bool:
+        return shutil.which("starship") is not None
+
+    def get_version(self) -> str:
+        r = subprocess.run(["starship", "--version"], capture_output=True, text=True)
+        return r.stdout.strip().splitlines()[0] if r.returncode == 0 else ""
+
+    def install(self) -> Optional[str]:
+        from dev_setup import ui
+
+        with ui.spinner("Installing Starship..."):
+            subprocess.run(
+                ["bash", "-c", "curl -fsSL https://starship.rs/install.sh | sh -s -- --yes"],
+                check=True, capture_output=True,
+            )
+
+        if not self.is_installed():
+            raise RuntimeError("Starship installation failed")
+
+        added = patch_bashrc(STARSHIP_BLOCK, STARSHIP_INIT_LINE)
+        if added:
+            ui.info("Starship init added to ~/.bashrc")
+        else:
+            ui.dim("Starship init already in ~/.bashrc")
+
+        return self.get_version()
+
+    def remove(self) -> None:
+        from dev_setup import ui
+
+        for p in [
+            Path("/usr/local/bin/starship"),
+            Path.home() / ".cargo" / "bin" / "starship",
+            Path.home() / ".local" / "bin" / "starship",
+        ]:
+            if p.exists():
+                if str(p).startswith("/usr"):
+                    subprocess.run(["sudo", "rm", "-f", str(p)], capture_output=True)
+                else:
+                    p.unlink()
+                ui.dim(f"Removed: {p}")
+
+        remove_bashrc_block(STARSHIP_BLOCK)
+        ui.info("Starship init removed from ~/.bashrc")

dev_setup/packages/uv_tool.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from dev_setup.base import Tool, patch_bashrc
+
+UV_PATH_BLOCK = "uv (and other ~/.local/bin tools)"
+UV_PATH_LINE = 'export PATH="$HOME/.local/bin:$PATH"'
+
+
+class UvTool(Tool):
+    key = "uv"
+    name = "uv"
+    description = "Astral Python package and project manager"
+    category = "core"
+    install_type = "script"
+    help_cmd = "uv --help"
+
+    def is_installed(self) -> bool:
+        return shutil.which("uv") is not None
+
+    def get_version(self) -> str:
+        r = subprocess.run(["uv", "--version"], capture_output=True, text=True)
+        return r.stdout.strip() if r.returncode == 0 else ""
+
+    def install(self) -> Optional[str]:
+        from dev_setup import ui
+
+        with ui.spinner("Installing uv..."):
+            subprocess.run(
+                ["bash", "-c", "curl -LsSf https://astral.sh/uv/install.sh | sh"],
+                check=True, capture_output=True,
+            )
+
+        import os
+        path = os.environ.get("PATH", "")
+        local_bin = str(Path.home() / ".local" / "bin")
+        if local_bin not in path:
+            os.environ["PATH"] = f"{local_bin}:{path}"
+
+        if not shutil.which("uv"):
+            raise RuntimeError("uv binary not found after install — add ~/.local/bin to PATH")
+
+        patch_bashrc(UV_PATH_BLOCK, UV_PATH_LINE)
+        ui.info("~/.local/bin added to PATH in ~/.bashrc")
+
+        return self.get_version()
+
+    def remove(self) -> None:
+        from dev_setup import ui
+
+        removed = False
+        for p in [
+            Path.home() / ".local" / "bin" / "uv",
+            Path.home() / ".local" / "bin" / "uvx",
+            Path.home() / ".cargo" / "bin" / "uv",
+            Path.home() / ".cargo" / "bin" / "uvx",
+        ]:
+            if p.exists():
+                p.unlink()
+                ui.dim(f"Removed: {p}")
+                removed = True
+
+        if not removed:
+            raise RuntimeError("uv binary not found in ~/.local/bin or ~/.cargo/bin")

dev_setup/registry.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import importlib
+import json
+import pkgutil
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from dev_setup.base import Tool
+
+_registry: Dict[str, Tool] = {}
+_order: List[str] = []
+_initialized = False
+
+
+def _register(tool: Tool) -> None:
+    if tool.key not in _registry:
+        _registry[tool.key] = tool
+        _order.append(tool.key)
+    else:
+        _registry[tool.key] = tool
+
+
+def _load_builtins() -> None:
+    from dev_setup import packages as pkg_ns
+
+    for finder, name, _ in pkgutil.iter_modules(pkg_ns.__path__):  # type: ignore[attr-defined]
+        module = importlib.import_module(f"dev_setup.packages.{name}")
+        for attr in dir(module):
+            obj = getattr(module, attr)
+            if (
+                isinstance(obj, type)
+                and issubclass(obj, Tool)
+                and obj is not Tool
+                and getattr(obj, "key", "")
+            ):
+                instance = obj()
+                instance.builtin = True
+                _register(instance)
+
+
+def _load_custom(config_dir: Path) -> None:
+    if not config_dir.is_dir():
+        return
+    for f in sorted(config_dir.glob("*.json")):
+        try:
+            data = json.loads(f.read_text())
+            from dev_setup.generic import GenericTool
+            tool = GenericTool.from_dict(data, key=f.stem)
+            tool.builtin = False
+            _register(tool)
+        except Exception:
+            pass
+
+
+def init() -> None:
+    global _initialized
+    if _initialized:
+        return
+    _initialized = True
+    _load_builtins()
+    from dev_setup.generic import _CUSTOM_DIR
+    _load_custom(_CUSTOM_DIR)
+
+
+def get(key: str) -> Optional[Tool]:
+    init()
+    return _registry.get(key)
+
+
+def all_tools() -> List[Tool]:
+    init()
+    return [_registry[k] for k in _order if k in _registry]
+
+
+def exists(key: str) -> bool:
+    init()
+    return key in _registry

dev_setup/ui.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from contextlib import contextmanager
+from typing import Generator, Optional
+
+import questionary
+from questionary import Style as QStyle
+from rich.console import Console
+from rich.panel import Panel
+from rich.rule import Rule
+from rich.text import Text
+
+console = Console(highlight=False)
+
+_STYLE = QStyle([
+    ("qmark",       "fg:#7C3AED bold"),
+    ("question",    "bold"),
+    ("answer",      "fg:#A78BFA bold"),
+    ("pointer",     "fg:#7C3AED bold"),
+    ("highlighted", "fg:#A78BFA bold"),
+    ("selected",    "fg:#A78BFA"),
+    ("separator",   "fg:#6B7280"),
+    ("instruction", "fg:#6B7280 italic"),
+])
+
+
+def info(msg: str) -> None:
+    console.print(f"  [cyan bold]❯[/]  {msg}")
+
+
+def success(msg: str) -> None:
+    console.print(f"  [green bold]✔[/]  {msg}")
+
+
+def warn(msg: str) -> None:
+    console.print(f"  [yellow bold]⚠[/]  {msg}")
+
+
+def error(msg: str) -> None:
+    console.print(f"  [red bold]✖[/]  {msg}")
+
+
+def dim(msg: str) -> None:
+    console.print(f"  [dim]{msg}[/]")
+
+
+def section(title: str) -> None:
+    console.print()
+    console.print(
+        Panel(f"[bold]{title}[/]", border_style="bright_magenta", expand=False, padding=(0, 1))
+    )
+    console.print()
+
+
+def divider() -> None:
+    console.print(Rule(style="dim"))
+
+
+def print_banner() -> None:
+    t = Text()
+    t.append(" dev", style="bold bright_magenta")
+    t.append("-", style="dim")
+    t.append("setup", style="bold white")
+    t.append("  v1.0.0", style="dim")
+    console.print()
+    console.print(Panel(t, border_style="bright_magenta", padding=(0, 2), expand=False))
+    console.print()
+
+
+@contextmanager
+def spinner(label: str) -> Generator[None, None, None]:
+    with console.status(f"  [dim]{label}[/]", spinner="dots"):
+        yield
+
+
+def confirm(prompt: str, default: bool = False) -> bool:
+    result = questionary.confirm(prompt, default=default, style=_STYLE).ask()
+    return bool(result)
+
+
+def text_input(prompt: str, default: str = "", required: bool = False) -> str:
+    while True:
+        result = questionary.text(prompt, default=default, style=_STYLE).ask()
+        val = (result or "").strip()
+        if val or not required:
+            return val
+        error("This field is required.")
+
+
+def select(prompt: str, choices: list[str]) -> str:
+    result = questionary.select(prompt, choices=choices, style=_STYLE).ask()
+    return result or ""
+
+
+def checkbox(prompt: str, choices: list) -> list:
+    result = questionary.checkbox(prompt, choices=choices, style=_STYLE).ask()
+    return result or []