mystack-rig 1.0.0__py3-none-any.whl

cli/git.py

@@ -0,0 +1,317 @@
+"""
+Git module for workspace project management
+
+This module provides functionality for:
+- Cloning git repositories on remote development environments
+- Managing git configurations
+- Handling authentication with PAT and SSH keys
+"""
+
+import os
+import subprocess
+from typing import Dict, List, Optional, TYPE_CHECKING
+import yaml
+
+if TYPE_CHECKING:
+    from cli.remote_dev import ProjectConfig
+
+
+class GitManager:
+    """Manages git operations for workspace projects"""
+
+    def __init__(self, project_config: Optional["ProjectConfig"] = None):
+        self.project_config = project_config
+        self.repos_to_clone: List[Dict] = []
+        self.ssh_repos: List[Dict] = []
+        self.git_config: Dict = {}
+
+    def load_git_config(self, config_path: Optional[str] = None) -> bool:
+        """Load git configuration from vars.yml"""
+        try:
+            if self.project_config is None:
+                return False
+            
+            self.project_config.load()
+            git_config = self.project_config.get_vars('git')
+            
+            if git_config:
+                self.git_config = git_config
+                self.repos_to_clone = git_config.get('clone_repos', [])
+                self.ssh_repos = git_config.get('ssh_repos', [])
+                return True
+            
+            return False
+        except Exception as e:
+            print(f"Warning: Could not load git config: {e}")
+            return False
+
+    def get_repos_to_clone(self) -> List[Dict]:
+        """Get list of repositories to clone"""
+        return self.repos_to_clone + self.ssh_repos
+
+    def generate_clone_tasks(self) -> List[Dict]:
+        """Generate Ansible tasks for cloning repositories"""
+        tasks = []
+        
+        # Add SSH known hosts setup for public repos
+        for repo in self.repos_to_clone:
+            repo_url = repo.get('repo', '')
+            if repo_url.startswith('https://') or repo_url.startswith('http://'):
+                tasks.append({
+                    'name': f'Add {self._get_hostname(repo_url)} SSH known hosts',
+                    'shell': f'ssh-keyscan {self._get_hostname(repo_url)} >> ~/.ssh/known_hosts 2>/dev/null || true',
+                    'changed_when': False,
+                    'ignore_errors': True
+                })
+                break  # Only add once
+        
+        # Add clone tasks for public repos
+        for repo in self.repos_to_clone:
+            tasks.append({
+                'name': f'Clone {self._get_repo_name(repo.get("repo", ""))}',
+                'git': {
+                    'repo': repo.get('repo'),
+                    'dest': repo.get('dest'),
+                    'accept_hostkey': repo.get('accept_hostkey', True),
+                    'force': repo.get('force', False),
+                    'version': repo.get('version', 'main')
+                }
+            })
+        
+        # Add clone tasks for SSH repos
+        for repo in self.ssh_repos:
+            tasks.append({
+                'name': f'Clone {self._get_repo_name(repo.get("repo", ""))} (SSH)',
+                'git': {
+                    'repo': repo.get('repo'),
+                    'dest': repo.get('dest'),
+                    'accept_hostkey': repo.get('accept_hostkey', True),
+                    'force': repo.get('force', False),
+                    'version': repo.get('version', 'main'),
+                    'ssh_key': repo.get('ssh_key', '/root/.ssh/id_rsa')
+                }
+            })
+        
+        return tasks
+
+    def _get_hostname(self, repo_url: str) -> str:
+        """Extract hostname from repository URL"""
+        if repo_url.startswith('https://') or repo_url.startswith('http://'):
+            return repo_url.split('/')[2]
+        if repo_url.startswith('git@'):
+            # git@host:owner/repo.git → host
+            return repo_url[len('git@'):].split(':', 1)[0] or 'github.com'
+        return 'github.com'
+
+    def _get_repo_name(self, repo_url: str) -> str:
+        """Extract repository name from URL"""
+        # Remove .git suffix
+        name = repo_url.rstrip('/')
+        if name.endswith('.git'):
+            name = name[:-4]
+        
+        # Get last part of URL
+        if '/' in name:
+            return name.split('/')[-1]
+        return name
+
+    def setup_git_environment(self, project_dir: str) -> bool:
+        """Set up git environment for a project"""
+        try:
+            # Ensure .rig directory exists
+            rig_dir = os.path.join(project_dir, '.rig')
+            if not os.path.exists(rig_dir):
+                os.makedirs(rig_dir)
+            
+            # Load existing config if available
+            if self.project_config is None:
+                from cli.remote_dev import ProjectConfig
+                self.project_config = ProjectConfig(project_dir)
+            
+            self.project_config.load()
+            
+            # Set default git configuration if not present
+            if not self.project_config.get_vars('git'):
+                self.project_config.set_vars('git.clone_repos', [])
+                self.project_config.set_vars('git.ssh_repos', [])
+            
+            return True
+        except Exception as e:
+            print(f"Error setting up git environment: {e}")
+            return False
+
+    def add_repo(
+        self,
+        repo_url: str,
+        dest: str,
+        is_ssh: bool = False,
+        password_var: Optional[str] = None,
+    ) -> bool:
+        """Add a repository to the clone list"""
+        try:
+            if self.project_config is None:
+                from cli.remote_dev import ProjectConfig
+                self.project_config = ProjectConfig()
+            
+            self.project_config.load()
+            
+            git_config = self.project_config.get_vars('git') or {}
+            clone_repos = git_config.get('clone_repos', [])
+            ssh_repos = git_config.get('ssh_repos', [])
+            
+            repo_config = {
+                'repo': repo_url,
+                'dest': dest,
+                'accept_hostkey': True
+            }
+            if password_var:
+                repo_config['password_var'] = password_var
+            
+            if is_ssh:
+                repo_config['ssh_key'] = '/root/.ssh/id_rsa'
+                ssh_repos.append(repo_config)
+            else:
+                clone_repos.append(repo_config)
+            
+            git_config['clone_repos'] = clone_repos
+            git_config['ssh_repos'] = ssh_repos
+            
+            self.project_config.set_vars('git', git_config)
+            self.project_config.save(write_vars=False)
+            
+            # Update internal state
+            self.repos_to_clone = clone_repos
+            self.ssh_repos = ssh_repos
+            
+            return True
+        except Exception as e:
+            print(f"Error adding repository: {e}")
+            return False
+
+    def set_repo_password_var(self, repo_url: str, password_var: str) -> bool:
+        """Attach or update password_var on an existing clone_repos entry."""
+        try:
+            if self.project_config is None:
+                from cli.remote_dev import ProjectConfig
+                self.project_config = ProjectConfig()
+
+            self.project_config.load()
+            git_config = self.project_config.get_vars('git') or {}
+            clone_repos = git_config.get('clone_repos', [])
+            updated = False
+            for item in clone_repos:
+                if isinstance(item, dict) and item.get('repo') == repo_url:
+                    item['password_var'] = password_var
+                    updated = True
+            if not updated:
+                return False
+            git_config['clone_repos'] = clone_repos
+            self.project_config.set_vars('git', git_config)
+            self.project_config.save(write_vars=False)
+            self.repos_to_clone = clone_repos
+            return True
+        except Exception as e:
+            print(f"Error setting password_var: {e}")
+            return False
+
+    def set_repo_dest(self, repo_url: str, dest: str) -> bool:
+        """Update dest on an existing clone_repos / ssh_repos entry."""
+        try:
+            if self.project_config is None:
+                from cli.remote_dev import ProjectConfig
+                self.project_config = ProjectConfig()
+
+            self.project_config.load()
+            git_config = self.project_config.get_vars('git') or {}
+            updated = False
+            for key in ('clone_repos', 'ssh_repos'):
+                entries = git_config.get(key, []) or []
+                for item in entries:
+                    if isinstance(item, dict) and item.get('repo') == repo_url:
+                        if item.get('dest') != dest:
+                            item['dest'] = dest
+                            updated = True
+                git_config[key] = entries
+            if not updated:
+                return False
+            self.project_config.set_vars('git', git_config)
+            self.project_config.save(write_vars=False)
+            self.repos_to_clone = git_config.get('clone_repos', [])
+            self.ssh_repos = git_config.get('ssh_repos', [])
+            return True
+        except Exception as e:
+            print(f"Error setting repo dest: {e}")
+            return False
+
+    def normalize_workspace_dests(self) -> int:
+        """
+        Rewrite legacy ``/root/<name>`` clone destinations under ``/workspace``.
+
+        Returns the number of entries updated.
+        """
+        from cli.remote_dev import REMOTE_WORKSPACE_ROOT, remote_workspace_path
+
+        try:
+            if self.project_config is None:
+                return 0
+            self.project_config.load()
+            git_config = self.project_config.get_vars('git') or {}
+            changed = 0
+            for key in ('clone_repos', 'ssh_repos'):
+                entries = git_config.get(key, []) or []
+                for item in entries:
+                    if not isinstance(item, dict):
+                        continue
+                    dest = str(item.get('dest') or '')
+                    if not dest:
+                        continue
+                    # Legacy home clones → workspace; leave /root/.ssh alone.
+                    if dest.startswith('/root/') and not dest.startswith('/root/.'):
+                        name = dest.rstrip('/').split('/')[-1]
+                        item['dest'] = remote_workspace_path(name)
+                        changed += 1
+                    elif not dest.startswith(REMOTE_WORKSPACE_ROOT + '/') and dest != REMOTE_WORKSPACE_ROOT:
+                        # Keep absolute paths outside /root as-is (custom mounts).
+                        pass
+                git_config[key] = entries
+            if changed:
+                self.project_config.set_vars('git', git_config)
+                self.project_config.save(write_vars=False)
+                self.repos_to_clone = git_config.get('clone_repos', [])
+                self.ssh_repos = git_config.get('ssh_repos', [])
+            return changed
+        except Exception as e:
+            print(f"Error normalizing workspace dests: {e}")
+            return 0
+
+    def remove_repo(self, repo_url: str) -> bool:
+        """Remove a repository from the clone list"""
+        try:
+            if self.project_config is None:
+                from cli.remote_dev import ProjectConfig
+                self.project_config = ProjectConfig()
+            
+            self.project_config.load()
+            
+            git_config = self.project_config.get_vars('git') or {}
+            clone_repos = git_config.get('clone_repos', [])
+            ssh_repos = git_config.get('ssh_repos', [])
+            
+            # Remove matching repos
+            clone_repos = [r for r in clone_repos if r.get('repo') != repo_url]
+            ssh_repos = [r for r in ssh_repos if r.get('repo') != repo_url]
+            
+            git_config['clone_repos'] = clone_repos
+            git_config['ssh_repos'] = ssh_repos
+            
+            self.project_config.set_vars('git', git_config)
+            self.project_config.save()
+            
+            # Update internal state
+            self.repos_to_clone = clone_repos
+            self.ssh_repos = ssh_repos
+            
+            return True
+        except Exception as e:
+            print(f"Error removing repository: {e}")
+            return False

cli/last_env.py

@@ -0,0 +1,64 @@
+"""Remember the last handled remote env name under /tmp (cleared on reboot)."""
+
+from __future__ import annotations
+
+import os
+from typing import Optional
+
+DEFAULT_LAST_ENV_PATH = "/tmp/.rig/last-env"
+
+
+def remember_last_env(name: str, path: str = DEFAULT_LAST_ENV_PATH) -> None:
+    """Persist *name* so later commands can omit it."""
+    if not name:
+        return
+    directory = os.path.dirname(path)
+    if directory:
+        os.makedirs(directory, mode=0o700, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as handle:
+        handle.write(f"{name.strip()}\n")
+    try:
+        os.chmod(path, 0o600)
+    except OSError:
+        pass
+
+
+def read_last_env(path: str = DEFAULT_LAST_ENV_PATH) -> Optional[str]:
+    """Return the last remembered environment name, or None."""
+    try:
+        with open(path, encoding="utf-8") as handle:
+            name = handle.read().strip()
+    except OSError:
+        return None
+    return name or None
+
+
+def clear_last_env(
+    name: Optional[str] = None,
+    path: str = DEFAULT_LAST_ENV_PATH,
+) -> None:
+    """
+    Remove the remembered name.
+
+    If *name* is given, only clear when it matches the stored value
+    (so destroying another env does not forget the current one).
+    """
+    if name is not None:
+        current = read_last_env(path=path)
+        if current is None or current != name:
+            return
+    try:
+        os.remove(path)
+    except OSError:
+        pass
+
+
+def resolve_env_name(
+    *candidates: Optional[str],
+    path: str = DEFAULT_LAST_ENV_PATH,
+) -> Optional[str]:
+    """First non-empty candidate, else the remembered last env."""
+    for value in candidates:
+        if value and str(value).strip():
+            return str(value).strip()
+    return read_last_env(path=path)

cli/last_session.py

@@ -0,0 +1,171 @@
+"""Remember the last coding-agent session id under /tmp (cleared on reboot)."""
+
+from __future__ import annotations
+
+import os
+import re
+from typing import List, Optional, Tuple
+
+DEFAULT_SESSION_DIR = "/tmp/.rig/sessions"
+
+# Strip common VT sequences / CR so script(1) logs parse cleanly.
+_ANSI_RE = re.compile(r"\x1b\[[0-9;?]*[a-zA-Z]|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)|\r")
+
+# Prefer explicit resume/session flags from exit banners, then bare ids.
+_SESSION_PATTERNS = (
+    re.compile(
+        r"--resume(?:=|\s+)([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})",
+        re.IGNORECASE,
+    ),
+    re.compile(r"--resume(?:=|\s+)([A-Za-z0-9][A-Za-z0-9_-]{5,})"),
+    re.compile(r"(?:--session|-s)(?:=|\s+)(ses_[A-Za-z0-9_-]+)"),
+    re.compile(r"\bses_[A-Za-z0-9_-]+\b"),
+    re.compile(
+        r"\b([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\b",
+        re.IGNORECASE,
+    ),
+)
+
+
+def _safe_env_name(name: str) -> str:
+    cleaned = re.sub(r"[^A-Za-z0-9._-]+", "-", (name or "").strip())
+    return cleaned.strip("-._") or "env"
+
+
+def session_path(env_name: str, directory: str = DEFAULT_SESSION_DIR) -> str:
+    return os.path.join(directory, _safe_env_name(env_name))
+
+
+def remember_last_session(
+    env_name: str,
+    session_id: str,
+    agent_type: Optional[str] = None,
+    directory: str = DEFAULT_SESSION_DIR,
+) -> None:
+    """Persist the last session id for *env_name*."""
+    if not env_name or not session_id:
+        return
+    os.makedirs(directory, mode=0o700, exist_ok=True)
+    path = session_path(env_name, directory=directory)
+    lines = [f"session={session_id.strip()}\n"]
+    if agent_type:
+        lines.insert(0, f"agent={agent_type.strip()}\n")
+    with open(path, "w", encoding="utf-8") as handle:
+        handle.writelines(lines)
+    try:
+        os.chmod(path, 0o600)
+        os.chmod(directory, 0o700)
+    except OSError:
+        pass
+
+
+def read_last_session(
+    env_name: str,
+    directory: str = DEFAULT_SESSION_DIR,
+) -> Optional[Tuple[str, Optional[str]]]:
+    """
+    Return ``(session_id, agent_type_or_None)`` for *env_name*, if known.
+    """
+    path = session_path(env_name, directory=directory)
+    try:
+        with open(path, encoding="utf-8") as handle:
+            text = handle.read()
+    except OSError:
+        return None
+
+    session_id: Optional[str] = None
+    agent_type: Optional[str] = None
+    for raw in text.splitlines():
+        line = raw.strip()
+        if not line or line.startswith("#"):
+            continue
+        if "=" in line:
+            key, value = line.split("=", 1)
+            key = key.strip().lower()
+            value = value.strip()
+            if key in {"session", "id", "session_id"} and value:
+                session_id = value
+            elif key == "agent" and value:
+                agent_type = value
+        elif session_id is None:
+            session_id = line
+    if not session_id:
+        return None
+    return session_id, agent_type
+
+
+def clear_last_session(
+    env_name: Optional[str] = None,
+    directory: str = DEFAULT_SESSION_DIR,
+) -> None:
+    """Remove stored session for one env, or all sessions when *env_name* is None."""
+    if env_name is None:
+        try:
+            for name in os.listdir(directory):
+                try:
+                    os.remove(os.path.join(directory, name))
+                except OSError:
+                    pass
+        except OSError:
+            pass
+        return
+    try:
+        os.remove(session_path(env_name, directory=directory))
+    except OSError:
+        pass
+
+
+def strip_ansi(text: str) -> str:
+    return _ANSI_RE.sub("", text or "")
+
+
+def parse_session_id(text: str) -> Optional[str]:
+    """Extract the most likely session / thread id from agent exit output."""
+    cleaned = strip_ansi(text)
+    if not cleaned.strip():
+        return None
+    last: Optional[str] = None
+    for pattern in _SESSION_PATTERNS:
+        for match in pattern.finditer(cleaned):
+            value = match.group(1) if match.lastindex else match.group(0)
+            if value:
+                last = value
+    return last
+
+
+def extract_session_from_agent_args(agent_args: Optional[List[str]]) -> Optional[str]:
+    """Return a session id explicitly present in forwarded agent argv."""
+    args = list(agent_args or [])
+    for index, token in enumerate(args):
+        if token in {"--session", "-s", "--resume"} and index + 1 < len(args):
+            value = args[index + 1]
+            if value and not str(value).startswith("-"):
+                return str(value)
+        for prefix in ("--session=", "--resume=", "-s="):
+            if token.startswith(prefix) and len(token) > len(prefix):
+                return token[len(prefix):]
+    return None
+
+
+def agent_args_request_session(agent_args: Optional[List[str]]) -> bool:
+    """True when argv already asks to continue/resume/select a session."""
+    args = list(agent_args or [])
+    for index, token in enumerate(args):
+        if token in {"--continue", "-c", "--resume", "--session", "-s"}:
+            return True
+        if token.startswith("--resume=") or token.startswith("--session=") or token.startswith("-s="):
+            return True
+        # bare ``--resume`` with optional id already covered above
+        if token == "--" and index + 1 < len(args):
+            # remainder after -- still scanned in loop
+            continue
+    return False
+
+
+def resume_args_for_agent(agent_type: Optional[str], session_id: str) -> List[str]:
+    """Build CLI flags to reopen *session_id* for the given agent."""
+    agent = (agent_type or "opencode").strip().lower()
+    if agent in {"opencode", "open-code"}:
+        return ["--session", session_id]
+    # Claude Code and Cursor CLI both use --resume <id>
+    return ["--resume", session_id]

cli/log.py

@@ -0,0 +1,105 @@
+"""Shared CLI logging for rig.
+
+Default level is INFO: lifecycle lines only. Playbook task output is shown
+when a task fails, or when verbosity is raised.
+
+``rig -v`` streams each playbook task and turns on DEBUG. ``-vv``, ``-vvv``,
+and ``-vvvv`` pass that same verbosity through to ansible-playbook.
+``rig -q`` / ``--quiet`` shows warnings and errors only.
+
+Format (stderr): INFO is message-only; DEBUG/WARNING/ERROR keep a level prefix.
+Stdout stays free for command output (encrypt ciphertext, decrypt plaintext, etc.).
+"""
+
+from __future__ import annotations
+
+import logging
+import sys
+from typing import Optional
+
+LOGGER_NAME = "rig"
+_CONFIGURED = False
+_VERBOSITY = 0
+
+
+class _LevelFormatter(logging.Formatter):
+    """INFO: bare message. Other levels: ``LEVEL  message``."""
+
+    def format(self, record: logging.LogRecord) -> str:
+        message = record.getMessage()
+        if record.levelno == logging.INFO:
+            return message
+        return f"{record.levelname.upper():<5} {message}"
+
+
+def get_logger(name: Optional[str] = None) -> logging.Logger:
+    """Return the rig logger (or a child under ``rig.``)."""
+    if name and name != LOGGER_NAME:
+        if not name.startswith(f"{LOGGER_NAME}."):
+            name = f"{LOGGER_NAME}.{name}"
+        return logging.getLogger(name)
+    return logging.getLogger(LOGGER_NAME)
+
+
+def verbosity() -> int:
+    """How much detail the current command asked for. ``0`` is the default."""
+    return _VERBOSITY
+
+
+def configure_logging(
+    *,
+    verbose: bool = False,
+    quiet: bool = False,
+    level: Optional[int] = None,
+    verbosity: Optional[int] = None,
+) -> logging.Logger:
+    """
+    Configure the root ``rig`` logger once (or reconfigure on subsequent calls).
+
+    ``verbosity`` counts ``-v`` flags. Precedence for the level: explicit
+    ``level`` > any verbosity or ``verbose`` > ``quiet`` > INFO.
+    """
+    global _CONFIGURED, _VERBOSITY
+    if verbosity is None:
+        verbosity = 1 if verbose else 0
+    _VERBOSITY = max(0, int(verbosity))
+    if level is None:
+        if _VERBOSITY > 0 or verbose:
+            level = logging.DEBUG
+        elif quiet:
+            level = logging.WARNING
+        else:
+            level = logging.INFO
+
+    logger = get_logger()
+    logger.handlers.clear()
+    handler = logging.StreamHandler(sys.stderr)
+    handler.setFormatter(_LevelFormatter())
+    logger.addHandler(handler)
+    logger.setLevel(level)
+    logger.propagate = False
+    _CONFIGURED = True
+    return logger
+
+
+def ensure_logging() -> logging.Logger:
+    """Configure with defaults if nothing has set logging up yet."""
+    if not _CONFIGURED:
+        return configure_logging()
+    return get_logger()
+
+
+def debug(msg: str, *args, **kwargs) -> None:
+    ensure_logging().debug(msg, *args, **kwargs)
+
+
+def info(msg: str, *args, **kwargs) -> None:
+    ensure_logging().info(msg, *args, **kwargs)
+
+
+def warning(msg: str, *args, **kwargs) -> None:
+    ensure_logging().warning(msg, *args, **kwargs)
+
+
+def error(msg: str, *args, **kwargs) -> None:
+    ensure_logging().error(msg, *args, **kwargs)