devlaunch 0.0.1__py2.py3-none-any.whl

devlaunch/completion.py

@@ -0,0 +1,100 @@
+"""Utilities for installing shell autocompletion scripts."""
+
+from __future__ import annotations
+
+import logging
+import os
+import pathlib
+from typing import Optional
+
+from .completion_loader import load_completion_script
+
+_RC_BLOCK_START = "# >>> devlaunch completions >>>"
+_RC_BLOCK_END = "# <<< devlaunch completions <<<"
+
+# Legacy blocks to clean up from previous installations
+_LEGACY_BLOCKS = {
+    "# dl completion": "# end dl completion",
+    "# dp completion": "# end dp completion",
+    _RC_BLOCK_START: _RC_BLOCK_END,
+}
+
+_LEGACY_SINGLE_LINES = {
+    "complete -F _dl_completion dl",
+    "complete -F _dp_completion dp",
+}
+
+
+def _completion_file_path() -> pathlib.Path:
+    """Return the path where the completion script should be stored."""
+    override = os.environ.get("DEVLAUNCH_COMPLETION_FILE")
+    if override:
+        return pathlib.Path(override).expanduser()
+    return pathlib.Path.home() / ".config" / "devlaunch" / "completions.sh"
+
+
+def install_completions(rc_path: Optional[pathlib.Path] = None) -> int:
+    """Install or refresh completion scripts for dl."""
+    completion_path = _completion_file_path().expanduser()
+    rc_target = (rc_path if rc_path is not None else pathlib.Path.home() / ".bashrc").expanduser()
+
+    try:
+        completion_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Write the dl completion script
+        completion_script = load_completion_script("dl").rstrip() + "\n"
+        completion_path.write_text(completion_script, encoding="utf-8")
+        logging.info("Wrote completion script to %s", completion_path)
+
+        rc_target.parent.mkdir(parents=True, exist_ok=True)
+        existing_content = ""
+        if rc_target.exists():
+            existing_content = rc_target.read_text(encoding="utf-8")
+
+        # Remove any existing completion block and legacy blocks before appending
+        def remove_block(text: str, start: str, end: str) -> str:
+            lines = text.splitlines()
+            out = []
+            skip = False
+            for line in lines:
+                if line.strip() == start:
+                    skip = True
+                    continue
+                if skip and line.strip() == end:
+                    skip = False
+                    continue
+                if not skip:
+                    out.append(line)
+            return "\n".join(out)
+
+        # Remove main block
+        cleaned_content = remove_block(existing_content, _RC_BLOCK_START, _RC_BLOCK_END)
+        # Remove legacy blocks
+        for block_start, block_end in _LEGACY_BLOCKS.items():
+            cleaned_content = remove_block(cleaned_content, block_start, block_end)
+        # Remove legacy single lines
+        cleaned_lines = []
+        for line in cleaned_content.splitlines():
+            if not any(line.strip().startswith(single) for single in _LEGACY_SINGLE_LINES):
+                cleaned_lines.append(line)
+        cleaned_content = "\n".join(cleaned_lines).strip()
+        escaped_path = str(completion_path).replace('"', r"\"")
+        source_line = f'source "{escaped_path}"'
+        block = "\n".join([_RC_BLOCK_START, source_line, _RC_BLOCK_END])
+
+        if cleaned_content:
+            new_content = f"{cleaned_content}\n\n{block}\n"
+        else:
+            new_content = f"{block}\n"
+
+        rc_target.write_text(new_content, encoding="utf-8")
+        logging.info("Added completion source block to %s", rc_target)
+        logging.info("Run 'source %s' or restart your terminal to enable completion", rc_target)
+        print(
+            "[devlaunch] Autocomplete has been updated. Run 'source %s' or restart your terminal to enable completion."
+            % rc_target
+        )
+        return 0
+    except OSError as error:
+        logging.error("Failed to install completions: %s", error)
+        return 1

devlaunch/completion_loader.py

@@ -0,0 +1,12 @@
+"""Helpers for loading embedded completion scripts."""
+
+from __future__ import annotations
+
+from importlib import resources
+
+
+def load_completion_script(name: str) -> str:
+    """Return the text of the embedded completion script."""
+    package = "devlaunch.completions"
+    resource = resources.files(package).joinpath(f"{name}.bash")
+    return resource.read_text(encoding="utf-8")

devlaunch/completions/dl.bash

@@ -0,0 +1,78 @@
+# dl completion
+_dl_completion() {
+    local cur prev opts
+    COMPREPLY=()
+    cur="${COMP_WORDS[COMP_CWORD]}"
+    prev="${COMP_WORDS[COMP_CWORD-1]}"
+
+    # Command options
+    opts="--ls --repos --stop --rm --code --status --recreate --reset --install --help"
+
+    # Flag completion
+    if [[ ${cur} == -* ]]; then
+        COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+        return 0
+    fi
+
+    # Cache file location (honors XDG_CACHE_HOME)
+    local cache_dir="${XDG_CACHE_HOME:-$HOME/.cache}/dl"
+    local cache_file="$cache_dir/completions.bash"
+
+    # Initialize completion variables
+    local DL_WORKSPACES=""
+    local DL_REPOS=""
+    local DL_OWNERS=""
+
+    # Source the bash cache file (fast, no jq needed)
+    if [[ -f "$cache_file" ]]; then
+        source "$cache_file"
+    fi
+
+    # Commands that need workspace completion
+    if [[ "$prev" == "--stop" || "$prev" == "--rm" || "$prev" == "--code" || "$prev" == "--status" || "$prev" == "--recreate" || "$prev" == "--reset" ]]; then
+        if [[ -n "$DL_WORKSPACES" ]]; then
+            COMPREPLY=( $(compgen -W "${DL_WORKSPACES}" -- ${cur}) )
+        fi
+        return 0
+    fi
+
+    # First positional argument: workspace, owner/repo, or path
+    if [[ ${COMP_CWORD} -eq 1 ]]; then
+        # Don't add space after completion to allow @branch suffix
+        compopt -o nospace
+
+        # If typing a path, complete files/directories
+        if [[ "$cur" == ./* || "$cur" == /* || "$cur" == ~/* ]]; then
+            compopt +o nospace
+            COMPREPLY=( $(compgen -d -- ${cur}) )
+            return 0
+        fi
+
+        # Check if completing owner/repo format (contains /)
+        if [[ "$cur" == */* ]]; then
+            # Complete from known repos
+            if [[ -n "$DL_REPOS" ]]; then
+                COMPREPLY=( $(compgen -W "${DL_REPOS}" -- ${cur}) )
+            fi
+            return 0
+        fi
+
+        # Default: complete workspace names and offer owner/ completion
+        local completions="$DL_WORKSPACES"
+
+        # Add owners with trailing slash
+        for owner in $DL_OWNERS; do
+            completions="$completions ${owner}/"
+        done
+
+        if [[ -n "$completions" ]]; then
+            COMPREPLY=( $(compgen -W "${completions}" -- ${cur}) )
+        fi
+        return 0
+    fi
+
+    return 0
+}
+
+complete -F _dl_completion dl
+# end dl completion

devlaunch/dl.py

@@ -0,0 +1,684 @@
+"""
+dl - DevLaunch CLI
+
+A streamlined CLI for devpod with intuitive autocomplete and fzf fuzzy selection.
+Provides an renv-like UX for managing devcontainer workspaces.
+
+Usage:
+    dl                           # fzf selector for existing workspaces
+    dl <workspace>               # open/create workspace, attach shell
+    dl <workspace> <command>     # run command in workspace
+    dl owner/repo                # create from git repo (github.com)
+    dl owner/repo@branch         # specific branch
+    dl ./path                    # create from local path
+    dl --ls                      # list workspaces
+    dl --stop <workspace>        # stop workspace
+    dl --rm <workspace>          # delete workspace
+    dl --code <workspace>        # open in VS Code
+    dl --install                 # install completions
+"""
+
+import sys
+import subprocess
+import json
+import logging
+import os
+import pathlib
+import re
+from typing import List, Optional, Dict, Any
+from dataclasses import dataclass
+
+from .completion import install_completions
+
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+
+
+def _get_cache_dir() -> pathlib.Path:
+    """Get the cache directory, honoring XDG_CACHE_HOME."""
+    xdg_cache = os.environ.get("XDG_CACHE_HOME")
+    if xdg_cache:
+        return pathlib.Path(xdg_cache) / "dl"
+    return pathlib.Path.home() / ".cache" / "dl"
+
+
+# Cache configuration (honors XDG_CACHE_HOME)
+CACHE_DIR = _get_cache_dir()
+CACHE_FILE = CACHE_DIR / "completions.json"
+BASH_CACHE_FILE = CACHE_DIR / "completions.bash"
+
+
+def get_cache_path() -> pathlib.Path:
+    """Get the path to the completion cache file."""
+    return CACHE_FILE
+
+
+def read_completion_cache() -> Optional[Dict[str, Any]]:
+    """Read completion data from cache file."""
+    cache_path = get_cache_path()
+    if not cache_path.exists():
+        return None
+    try:
+        with open(cache_path, encoding="utf-8") as f:
+            return json.load(f)
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
+def write_completion_cache(data: Dict[str, Any]) -> None:
+    """Write completion data to cache file (JSON format)."""
+    cache_path = get_cache_path()
+    try:
+        cache_path.parent.mkdir(parents=True, exist_ok=True)
+        with open(cache_path, "w", encoding="utf-8") as f:
+            json.dump(data, f)
+    except OSError:
+        pass
+
+
+def write_bash_completion_cache(data: Dict[str, Any]) -> None:
+    """Write completion data as a sourceable bash file."""
+    try:
+        BASH_CACHE_FILE.parent.mkdir(parents=True, exist_ok=True)
+        workspaces = " ".join(data.get("workspaces", []))
+        repos = " ".join(data.get("repos", []))
+        owners = " ".join(data.get("owners", []))
+        lines = [
+            "# Auto-generated by dl - do not edit",
+            f'DL_WORKSPACES="{workspaces}"',
+            f'DL_REPOS="{repos}"',
+            f'DL_OWNERS="{owners}"',
+        ]
+        with open(BASH_CACHE_FILE, "w", encoding="utf-8") as f:
+            f.write("\n".join(lines) + "\n")
+    except OSError:
+        pass
+
+
+def update_completion_cache() -> Dict[str, Any]:
+    """Update the completion cache with current data."""
+    workspaces = list_workspaces()
+    workspace_ids = [ws.id for ws in workspaces]
+    repos = discover_repos_from_workspaces(workspaces)
+
+    # Flatten repos to list of owner/repo strings
+    known_repos = []
+    for owner, repo_list in sorted(repos.items()):
+        for repo in sorted(repo_list):
+            known_repos.append(f"{owner}/{repo}")
+
+    # Extract unique owners
+    owners = sorted(repos.keys())
+
+    data = {
+        "workspaces": workspace_ids,
+        "repos": known_repos,
+        "owners": owners,
+    }
+    write_completion_cache(data)
+    write_bash_completion_cache(data)
+    return data
+
+
+def update_cache_background() -> None:
+    """Update completion cache in background."""
+    try:
+        # pylint: disable=consider-using-with
+        subprocess.Popen(
+            [sys.executable, "-m", "devlaunch.dl", "--update-cache"],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            start_new_session=True,
+        )
+    except OSError:
+        pass
+
+
+# Regex to match owner/repo[@branch] format (not a path, not already a URL)
+
+OWNER_REPO_PATTERN = re.compile(r"^[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+(@[a-zA-Z0-9_./%-]+)?$")
+
+
+def is_path_spec(spec: str) -> bool:
+    """Check if spec looks like a filesystem path."""
+    return spec.startswith("./") or spec.startswith("/") or spec.startswith("~")
+
+
+def is_git_spec(spec: str) -> bool:
+    """Check if spec looks like a git repo (owner/repo or URL)."""
+    # Paths are not git specs
+    if is_path_spec(spec):
+        return False
+    if "://" in spec:
+        return True
+    if spec.startswith("github.com/") or spec.startswith("gitlab.com/"):
+        return True
+    return bool(OWNER_REPO_PATTERN.match(spec))
+
+
+def expand_workspace_spec(spec: str) -> str:
+    """Expand owner/repo[@branch] to github.com/owner/repo[@branch] for devpod."""
+    # Don't expand if it's a path
+    if is_path_spec(spec):
+        return spec
+    # Don't expand if it already looks like a URL
+    if "://" in spec or spec.startswith("github.com/") or spec.startswith("gitlab.com/"):
+        return spec
+    # Check if it matches owner/repo[@branch] pattern
+    if OWNER_REPO_PATTERN.match(spec):
+        return f"github.com/{spec}"
+    # Otherwise return as-is (existing workspace name)
+    return spec
+
+
+def spec_to_workspace_id(spec: str) -> str:
+    """Derive the workspace ID that devpod will use for a given spec.
+
+    Devpod uses:
+    - For git repos: the repo name (e.g., owner/repo -> repo)
+    - For paths: the directory name (e.g., ./my-project -> my-project)
+    - For existing IDs: the ID as-is
+    """
+    # Strip @branch suffix if present
+    base_spec = spec.split("@")[0]
+
+    # For paths, use the directory name
+    if is_path_spec(base_spec):
+        return pathlib.Path(base_spec).expanduser().resolve().name
+
+    # For git URLs or owner/repo, extract repo name
+    if is_git_spec(base_spec):
+        # Handle various formats: github.com/owner/repo, owner/repo, https://...
+        parts = base_spec.rstrip("/").split("/")
+        repo_name = parts[-1]
+        # Remove .git suffix if present
+        if repo_name.endswith(".git"):
+            repo_name = repo_name[:-4]
+        return repo_name
+
+    # Otherwise assume it's already a workspace ID
+    return spec
+
+
+def validate_workspace_spec(spec: str, existing_ids: List[str]) -> Optional[str]:
+    """Validate workspace spec and return error message if invalid."""
+    # Valid if it's an existing workspace
+    if spec in existing_ids:
+        return None
+    # Valid if it's a path
+    if is_path_spec(spec):
+        return None
+    # Valid if it's a git spec (owner/repo or URL)
+    if is_git_spec(spec):
+        return None
+    # Invalid - provide helpful error
+    return f"Unknown workspace '{spec}'. Use 'dl --ls' to list workspaces, or specify owner/repo or ./path"
+
+
+@dataclass
+class Workspace:
+    """Represents a devpod workspace."""
+
+    id: str
+    source_type: str  # "local" or "git"
+    source: str
+    last_used: str
+    provider: str
+    ide: str
+
+    @classmethod
+    def from_json(cls, data: Dict[str, Any]) -> "Workspace":
+        """Parse workspace from devpod JSON output."""
+        source = data.get("source", {})
+        if "localFolder" in source:
+            source_type = "local"
+            source_path = source["localFolder"]
+        elif "gitRepository" in source:
+            source_type = "git"
+            source_path = source["gitRepository"]
+        else:
+            source_type = "unknown"
+            source_path = str(source)
+
+        return cls(
+            id=data.get("id", ""),
+            source_type=source_type,
+            source=source_path,
+            last_used=data.get("lastUsed", ""),
+            provider=data.get("provider", {}).get("name", ""),
+            ide=data.get("ide", {}).get("name", ""),
+        )
+
+
+# Regex patterns for parsing git URLs
+GIT_URL_PATTERNS = [
+    # git@github.com:owner/repo.git
+    re.compile(r"git@github\.com:([^/]+)/([^/]+?)(?:\.git)?$"),
+    # https://github.com/owner/repo.git or https://github.com/owner/repo
+    re.compile(r"https?://github\.com/([^/]+)/([^/]+?)(?:\.git)?$"),
+    # github.com/owner/repo
+    re.compile(r"^github\.com/([^/]+)/([^/]+?)(?:\.git)?$"),
+]
+
+
+def parse_owner_repo_from_url(url: str) -> Optional[tuple]:
+    """Extract (owner, repo) from a git URL."""
+    for pattern in GIT_URL_PATTERNS:
+        match = pattern.match(url)
+        if match:
+            return (match.group(1), match.group(2))
+    return None
+
+
+def get_git_remote_url(path: str) -> Optional[str]:
+    """Get the origin remote URL from a git repository."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", path, "remote", "get-url", "origin"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode == 0:
+            return result.stdout.strip()
+    except (OSError, subprocess.SubprocessError):
+        pass
+    return None
+
+
+def get_git_branches(path: str) -> List[str]:
+    """Get list of branches from a git repository."""
+    try:
+        result = subprocess.run(
+            ["git", "-C", path, "branch", "-r"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if result.returncode == 0:
+            branches = []
+            for line in result.stdout.strip().split("\n"):
+                line = line.strip()
+                if line and "origin/" in line and "HEAD" not in line:
+                    branch = line.replace("origin/", "")
+                    branches.append(branch)
+            return branches
+    except (OSError, subprocess.SubprocessError):
+        pass
+    return []
+
+
+def discover_repos_from_workspaces(workspaces: List[Workspace]) -> Dict[str, List[str]]:
+    """Discover owner/repo from workspace git remotes.
+
+    Returns dict mapping owner -> list of repos.
+    """
+    repos: Dict[str, List[str]] = {}
+
+    for ws in workspaces:
+        owner_repo = None
+
+        # For git workspaces, parse the source URL directly
+        if ws.source_type == "git":
+            owner_repo = parse_owner_repo_from_url(ws.source)
+
+        # For local workspaces, try to get git remote
+        elif ws.source_type == "local" and ws.source:
+            remote_url = get_git_remote_url(ws.source)
+            if remote_url:
+                owner_repo = parse_owner_repo_from_url(remote_url)
+
+        if owner_repo:
+            owner, repo = owner_repo
+            if owner not in repos:
+                repos[owner] = []
+            if repo not in repos[owner]:
+                repos[owner].append(repo)
+
+    return repos
+
+
+def get_known_repos() -> List[str]:
+    """Get list of known owner/repo strings from workspaces."""
+    workspaces = list_workspaces()
+    repos = discover_repos_from_workspaces(workspaces)
+    result = []
+    for owner, repo_list in sorted(repos.items()):
+        for repo in sorted(repo_list):
+            result.append(f"{owner}/{repo}")
+    return result
+
+
+def run_devpod(args: List[str], capture: bool = False) -> subprocess.CompletedProcess:
+    """Run a devpod command.
+
+    Security note: Using list form of subprocess.run (not shell=True) prevents
+    command injection. Each list element is passed as a separate argument to
+    the executable, so special characters are not interpreted by a shell.
+    """
+    cmd = ["devpod"] + args
+    logging.debug("Running: %s", " ".join(cmd))
+    if capture:
+        # nosec B603 - using list form, not shell=True; no command injection risk
+        return subprocess.run(cmd, capture_output=True, text=True, check=False)
+    # nosec B603 - using list form, not shell=True; no command injection risk
+    return subprocess.run(cmd, check=False)
+
+
+def list_workspaces() -> List[Workspace]:
+    """List all devpod workspaces."""
+    result = run_devpod(["list", "--output", "json"], capture=True)
+    if result.returncode != 0 or not result.stdout.strip():
+        return []
+    try:
+        data = json.loads(result.stdout)
+        return [Workspace.from_json(ws) for ws in data]
+    except json.JSONDecodeError:
+        logging.error("Failed to parse devpod output")
+        return []
+
+
+def get_workspace_ids() -> List[str]:
+    """Get list of workspace IDs for completion."""
+    return [ws.id for ws in list_workspaces()]
+
+
+def print_workspaces():
+    """Print workspace list in a nice format."""
+    workspaces = list_workspaces()
+    if not workspaces:
+        print("No workspaces found.")
+        return
+
+    # Calculate column widths
+    id_width = max(len(ws.id) for ws in workspaces)
+    type_width = max(len(ws.source_type) for ws in workspaces)
+    source_width = max(len(ws.source) for ws in workspaces)
+
+    # Print header
+    print(
+        f"{'WORKSPACE':<{id_width}}  {'TYPE':<{type_width}}  {'SOURCE':<{source_width}}  LAST USED"
+    )
+    print("-" * (id_width + type_width + source_width + 30))
+
+    # Print rows
+    for ws in workspaces:
+        last_used = ws.last_used[:19].replace("T", " ") if ws.last_used else "never"
+        print(
+            f"{ws.id:<{id_width}}  {ws.source_type:<{type_width}}  {ws.source:<{source_width}}  {last_used}"
+        )
+
+
+def fuzzy_select_workspace() -> Optional[str]:
+    """Interactive fuzzy finder for workspace selection."""
+    try:
+        from iterfzf import iterfzf
+    except ImportError:
+        logging.error("iterfzf not available. Install with: pip install iterfzf")
+        return None
+
+    workspaces = list_workspaces()
+    if not workspaces:
+        logging.info("No workspaces found. Create one with: dl owner/repo or dl ./path")
+        return None
+
+    # Format options for display: "id | type | source"
+    options = []
+    ws_map = {}
+    for ws in workspaces:
+        label = f"{ws.id} | {ws.source_type} | {ws.source}"
+        options.append(label)
+        ws_map[label] = ws.id
+
+    print("Select workspace (type to filter):")
+    try:
+        selected = iterfzf(options, multi=False)
+    except KeyboardInterrupt:
+        return None
+    if selected:
+        return ws_map.get(selected)
+    return None
+
+
+def workspace_up(
+    workspace: str, ide: Optional[str] = None, recreate: bool = False, reset: bool = False
+):
+    """Start or create a workspace."""
+    args = ["up", workspace]
+    if ide:
+        args.extend(["--ide", ide])
+    if recreate:
+        args.append("--recreate")
+    if reset:
+        args.append("--reset")
+    return run_devpod(args)
+
+
+def workspace_ssh(workspace: str, command: Optional[str] = None) -> int:
+    """SSH into a workspace, optionally running a command."""
+    args = ["ssh", workspace]
+    if command:
+        args.extend(["--command", command])
+    result = run_devpod(args)
+    return result.returncode
+
+
+def workspace_stop(workspace: str) -> int:
+    """Stop a workspace."""
+    result = run_devpod(["stop", workspace])
+    return result.returncode
+
+
+def workspace_delete(workspace: str) -> int:
+    """Delete a workspace."""
+    result = run_devpod(["delete", workspace])
+    return result.returncode
+
+
+def workspace_status(workspace: str) -> int:
+    """Get status of a workspace."""
+    result = run_devpod(["status", workspace])
+    return result.returncode
+
+
+def print_help():
+    """Print usage help."""
+    help_text = """dl - DevLaunch CLI
+
+Usage:
+    dl                           Interactive workspace selector (fzf)
+    dl <workspace>               Start workspace and attach shell
+    dl <workspace> <command>     Run command in workspace
+    dl owner/repo                Create workspace from GitHub repo
+    dl owner/repo@branch         Create workspace from specific branch
+    dl ./path                    Create workspace from local path
+
+Commands:
+    --ls                         List all workspaces
+    --stop <workspace>           Stop a workspace
+    --rm <workspace>             Delete a workspace
+    --code <workspace>           Open workspace in VS Code
+    --status <workspace>         Show workspace status
+    --recreate <workspace>       Recreate workspace container
+    --reset <workspace>          Reset workspace (clean slate)
+    --install                    Install shell completions
+    --help, -h                   Show this help
+
+Examples:
+    dl                           # Select workspace with fzf
+    dl myproject                 # Open existing workspace
+    dl loft-sh/devpod            # Create from GitHub
+    dl blooop/devlaunch@main     # Create from specific branch
+    dl ./my-project              # Create from local folder
+    dl --code myproject          # Open in VS Code
+    dl myproject 'make test'     # Run command in workspace
+"""
+    print(help_text)
+
+
+def main() -> int:
+    """Main entry point for dl CLI."""
+    args = sys.argv[1:]
+
+    # Handle help
+    if not args or (len(args) == 1 and args[0] in ("--help", "-h")):
+        if not args:
+            # No args - try fzf selection
+            selected = fuzzy_select_workspace()
+            if not selected:
+                print_help()
+                return 1
+            workspace_up(selected)
+            return workspace_ssh(selected)
+        print_help()
+        return 0
+
+    # Handle flags
+    if args[0] == "--ls":
+        print_workspaces()
+        return 0
+
+    if args[0] == "--repos":
+        # Output known repos for bash completion (uses cache if available)
+        cache = read_completion_cache()
+        if cache and "repos" in cache:
+            for repo in cache["repos"]:
+                print(repo)
+        else:
+            for repo in get_known_repos():
+                print(repo)
+        return 0
+
+    if args[0] == "--update-cache":
+        # Update completion cache (called in background)
+        update_completion_cache()
+        return 0
+
+    if args[0] == "--completion-data":
+        # Output all completion data as JSON (fast, from cache)
+        cache = read_completion_cache()
+        if cache:
+            print(json.dumps(cache))
+        else:
+            # No cache, generate and cache it
+            data = update_completion_cache()
+            print(json.dumps(data))
+        return 0
+
+    if args[0] == "--install":
+        rc_path = None
+        if len(args) > 1:
+            rc_path = pathlib.Path(args[1])
+        # Generate cache so completions work immediately
+        update_completion_cache()
+        return install_completions(rc_path)
+
+    if args[0] == "--stop":
+        if len(args) < 2:
+            workspace = fuzzy_select_workspace()
+            if not workspace:
+                logging.error("Usage: dl --stop <workspace>")
+                return 1
+        else:
+            workspace = args[1]
+        return workspace_stop(workspace)
+
+    if args[0] == "--rm":
+        if len(args) < 2:
+            workspace = fuzzy_select_workspace()
+            if not workspace:
+                logging.error("Usage: dl --rm <workspace>")
+                return 1
+        else:
+            workspace = args[1]
+        return workspace_delete(workspace)
+
+    if args[0] == "--status":
+        if len(args) < 2:
+            workspace = fuzzy_select_workspace()
+            if not workspace:
+                logging.error("Usage: dl --status <workspace>")
+                return 1
+        else:
+            workspace = args[1]
+        return workspace_status(workspace)
+
+    if args[0] == "--code":
+        if len(args) < 2:
+            workspace = fuzzy_select_workspace()
+            if not workspace:
+                logging.error("Usage: dl --code <workspace>")
+                return 1
+        else:
+            workspace = args[1]
+        result = workspace_up(workspace, ide="vscode")
+        return result.returncode
+
+    if args[0] == "--recreate":
+        if len(args) < 2:
+            workspace = fuzzy_select_workspace()
+            if not workspace:
+                logging.error("Usage: dl --recreate <workspace>")
+                return 1
+        else:
+            workspace = args[1]
+        workspace_spec = expand_workspace_spec(workspace)
+        workspace_id = spec_to_workspace_id(workspace)
+        result = workspace_up(workspace_spec, recreate=True)
+        if result.returncode != 0:
+            return result.returncode
+        return workspace_ssh(workspace_id)
+
+    if args[0] == "--reset":
+        if len(args) < 2:
+            workspace = fuzzy_select_workspace()
+            if not workspace:
+                logging.error("Usage: dl --reset <workspace>")
+                return 1
+        else:
+            workspace = args[1]
+        workspace_spec = expand_workspace_spec(workspace)
+        workspace_id = spec_to_workspace_id(workspace)
+        result = workspace_up(workspace_spec, reset=True)
+        if result.returncode != 0:
+            return result.returncode
+        return workspace_ssh(workspace_id)
+
+    # Default: workspace name and optional command
+    raw_spec = args[0]
+    command = " ".join(args[1:]) if len(args) > 1 else None
+
+    # Validate the workspace spec
+    existing_ids = get_workspace_ids()
+    error = validate_workspace_spec(raw_spec, existing_ids)
+    if error:
+        logging.error(error)
+        return 1
+
+    # Use raw spec as-is if it's an existing workspace ID, otherwise expand
+    # This prevents owner/repo-style workspace IDs from being rewritten
+    if raw_spec in existing_ids:
+        workspace_spec = raw_spec
+        workspace_id = raw_spec
+    else:
+        workspace_spec = expand_workspace_spec(raw_spec)
+        workspace_id = spec_to_workspace_id(raw_spec)
+
+    # Start the workspace
+    result = workspace_up(workspace_spec)
+    if result.returncode != 0:
+        return result.returncode
+
+    # Attach to workspace using the ID (not the full spec)
+    ret = workspace_ssh(workspace_id, command)
+
+    # Update cache in background after workspace operations
+    update_cache_background()
+
+    return ret
+
+
+if __name__ == "__main__":
+    try:
+        sys.exit(main())
+    except KeyboardInterrupt:
+        sys.exit(130)

devlaunch-0.0.1.dist-info/METADATA

@@ -0,0 +1,134 @@
+Metadata-Version: 2.4
+Name: devlaunch
+Version: 0.0.1
+Summary: DevLaunch - A streamlined CLI for devpod workspaces
+Project-URL: Source, https://github.com/blooop/devlaunch
+Project-URL: Home, https://github.com/blooop/devlaunch
+Author-email: Austin Gregg-Smith <blooop@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: iterfzf>=1.0.0
+Provides-Extra: test
+Requires-Dist: coverage<=7.13.1,>=7.5.4; extra == 'test'
+Requires-Dist: hypothesis<=6.150.2,>=6.104.2; extra == 'test'
+Requires-Dist: prek<0.3.0,>=0.2.28; extra == 'test'
+Requires-Dist: pylint<=4.0.4,>=3.2.5; extra == 'test'
+Requires-Dist: pytest-cov<=7.0.0,>=4.1; extra == 'test'
+Requires-Dist: pytest<=9.0.2,>=7.4; extra == 'test'
+Requires-Dist: ruff<=0.14.13,>=0.5.0; extra == 'test'
+Requires-Dist: ty<=0.0.12,>=0.0.12; extra == 'test'
+Description-Content-Type: text/markdown
+
+# devlaunch
+
+A streamlined CLI for [devpod](https://devpod.sh) with intuitive autocomplete and fzf fuzzy selection.
+
+## Continuous Integration Status
+
+[![Ci](https://github.com/blooop/devlaunch/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/blooop/devlaunch/actions/workflows/ci.yml?query=branch%3Amain)
+[![Codecov](https://codecov.io/gh/blooop/devlaunch/branch/main/graph/badge.svg?token=Y212GW1PG6)](https://codecov.io/gh/blooop/devlaunch)
+[![GitHub issues](https://img.shields.io/github/issues/blooop/devlaunch.svg)](https://GitHub.com/blooop/devlaunch/issues/)
+[![GitHub pull-requests merged](https://badgen.net/github/merged-prs/blooop/devlaunch)](https://github.com/blooop/devlaunch/pulls?q=is%3Amerged)
+[![GitHub release](https://img.shields.io/github/release/blooop/devlaunch.svg)](https://GitHub.com/blooop/devlaunch/releases/)
+[![License](https://img.shields.io/github/license/blooop/devlaunch)](https://opensource.org/license/mit/)
+[![Python](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-blue)](https://www.python.org/downloads/)
+[![Pixi Badge](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/prefix-dev/pixi/main/assets/badge/v0.json)](https://pixi.sh)
+
+## Installation
+
+```bash
+# Using pixi (recommended)
+pixi global install devlaunch
+
+# Using pip
+pip install devlaunch
+```
+
+After installation, set up shell completions:
+
+```bash
+dl --install
+source ~/.bashrc  # or restart your terminal
+```
+
+## Usage
+
+```bash
+dl                           # Interactive workspace selector (fzf)
+dl <workspace>               # Start workspace and attach shell
+dl <workspace> <command>     # Run command in workspace
+dl owner/repo                # Create workspace from GitHub repo
+dl owner/repo@branch         # Create workspace from specific branch
+dl ./path                    # Create workspace from local path
+```
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `dl --ls` | List all workspaces |
+| `dl --stop <workspace>` | Stop a workspace |
+| `dl --rm <workspace>` | Delete a workspace |
+| `dl --code <workspace>` | Open workspace in VS Code |
+| `dl --status <workspace>` | Show workspace status |
+| `dl --recreate <workspace>` | Recreate workspace container |
+| `dl --reset <workspace>` | Reset workspace (clean slate) |
+| `dl --install` | Install shell completions |
+| `dl --help` | Show help |
+
+## Examples
+
+```bash
+# Select workspace interactively with fzf
+dl
+
+# Open an existing workspace
+dl myproject
+
+# Create workspace from GitHub repository
+dl loft-sh/devpod
+
+# Create workspace from specific branch
+dl blooop/devlaunch@main
+
+# Create workspace from local folder
+dl ./my-project
+
+# Open workspace in VS Code
+dl --code myproject
+
+# Run a command in workspace
+dl myproject 'make test'
+```
+
+## Features
+
+- **Fuzzy Selection**: When called without arguments, uses fzf for interactive workspace selection
+- **Smart Completion**: Tab completion for workspaces, GitHub repos (owner/repo format), and paths
+- **GitHub Shorthand**: Use `owner/repo` instead of full URLs - automatically expands to `github.com/owner/repo`
+- **Branch Support**: Specify branches with `owner/repo@branch` syntax
+- **Fast Autocomplete**: Completion cache for ~3ms response time (vs ~700ms without cache)
+
+## Shell Completion
+
+After running `dl --install`, you get intelligent tab completion:
+
+- Workspace names from your devpod list
+- Known GitHub owners and repositories from your workspaces
+- File/directory paths when starting with `./`, `/`, or `~`
+- All command flags (`--ls`, `--stop`, etc.)
+
+## Development
+
+This project uses [pixi](https://pixi.sh) for environment management.
+
+```bash
+# Run tests
+pixi run test
+
+# Run full CI suite
+pixi run ci
+
+# Format and lint
+pixi run style
+```

devlaunch-0.0.1.dist-info/RECORD

@@ -0,0 +1,11 @@
+devlaunch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devlaunch/completion.py,sha256=qUcniRSrKqYcaRZN2UQghEv0LPEEU5DOTqGj6qPAaRA,3803
+devlaunch/completion_loader.py,sha256=WnRpd54O6xvhNOTbASEcRuBJp0QiatZFXm4wCSZa0Mg,384
+devlaunch/dl.py,sha256=qtS-P0LsYxd6Xn4pXKqwmt-sRqoXjLXbPm-sGtGNBhI,21995
+devlaunch/completions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+devlaunch/completions/dl.bash,sha256=EYRsRDCPbgXadaXMIdMykANhTVMdE1nFstxeNBofEsc,2347
+devlaunch-0.0.1.dist-info/METADATA,sha256=cQg_GsXAPRTP_URzNVLDTh0EWpLPwju3ggbOOuweBE4,4625
+devlaunch-0.0.1.dist-info/WHEEL,sha256=aha0VrrYvgDJ3Xxl3db_g_MDIW-ZexDdrc_m-Hk8YY4,105
+devlaunch-0.0.1.dist-info/entry_points.txt,sha256=w3g7P_f852z_BJGEkOBQzg734meOv1GXWInNpjaTUKY,41
+devlaunch-0.0.1.dist-info/licenses/LICENSE,sha256=BELp7Z_UlGhotfEDzDkWiCw7MtJ12i7B3rhIjebfk0k,1075
+devlaunch-0.0.1.dist-info/RECORD,,

devlaunch-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.28.0
+Root-Is-Purelib: true
+Tag: py2-none-any
+Tag: py3-none-any

devlaunch-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dl = devlaunch.dl:main

devlaunch-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Austin Gregg-Smith
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.