icdev 1.0.0__py3-none-any.whl

icdev/tools/ci/modules/vcs.py

@@ -0,0 +1,303 @@
+# [TEMPLATE: CUI // SP-CTI]
+# ICDEV VCS Abstraction — Unified GitHub + GitLab interface
+# Adapted from ADW github.py with GitLab support added
+
+"""
+Unified Version Control System abstraction for GitHub and GitLab.
+
+Detects which platform is in use from git remote URL, then provides
+a common API for issues, comments, merge/pull requests using the
+appropriate CLI tool (gh for GitHub, glab for GitLab).
+
+Usage:
+    from icdev.tools.ci.modules.vcs import VCS
+    vcs = VCS()  # Auto-detects platform from git remote
+    issue = vcs.fetch_issue(123)
+    vcs.comment_on_issue(123, "Build complete")
+"""
+
+import json
+import os
+import re
+import subprocess
+from pathlib import Path
+from typing import Optional, List, Dict, Any, Tuple
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent.parent
+
+# Safe environment for subprocesses
+def _get_env() -> Dict[str, str]:
+    # Start with full inherited environment so gh/glab can access OS keyring,
+    # APPDATA (Windows credential store), and other platform-specific paths.
+    env = os.environ.copy()
+    # Overlay explicit token overrides if set
+    gh_token = os.getenv("GITHUB_PAT") or os.getenv("GH_TOKEN")
+    if gh_token:
+        env["GH_TOKEN"] = gh_token
+    gl_token = os.getenv("GITLAB_TOKEN") or os.getenv("GLAB_TOKEN")
+    if gl_token:
+        env["GITLAB_TOKEN"] = gl_token
+    gl_url = os.getenv("GITLAB_URL")
+    if gl_url:
+        env["GITLAB_URL"] = gl_url
+    return env
+
+
+def _run(cmd: List[str], cwd: str = None, timeout: int = 30) -> Tuple[str, str, int]:
+    """Run a CLI command and return (stdout, stderr, returncode)."""
+    proc = subprocess.run(
+        cmd, capture_output=True, text=True,
+        cwd=cwd or str(PROJECT_ROOT),
+        env=_get_env(), timeout=timeout,
+    )
+    return proc.stdout.strip(), proc.stderr.strip(), proc.returncode
+
+
+class VCS:
+    """Unified VCS abstraction for GitHub and GitLab.
+
+    Auto-detects platform from git remote URL:
+    - github.com → GitHub (uses `gh` CLI)
+    - gitlab.com or custom GitLab → GitLab (uses `glab` CLI)
+    """
+
+    PLATFORM_GITHUB = "github"
+    PLATFORM_GITLAB = "gitlab"
+
+    def __init__(self, platform: str = None, repo_path: str = None):
+        """Initialize VCS with auto-detection or explicit platform.
+
+        Args:
+            platform: Force "github" or "gitlab" (auto-detect if None)
+            repo_path: Override repo path (e.g., "owner/repo")
+        """
+        self.repo_path = repo_path
+        if platform:
+            self.platform = platform
+        else:
+            self.platform, self.repo_path = self._detect_platform()
+
+    def _detect_platform(self) -> Tuple[str, str]:
+        """Detect GitHub or GitLab from git remote URL."""
+        stdout, stderr, rc = _run(["git", "remote", "get-url", "origin"])
+        if rc != 0:
+            raise ValueError(f"No git remote 'origin': {stderr}")
+
+        url = stdout.strip()
+
+        # Extract repo path from URL
+        # SSH: git@github.com:owner/repo.git
+        # HTTPS: https://github.com/owner/repo.git
+        ssh_match = re.match(r"git@([^:]+):(.+?)(?:\.git)?$", url)
+        https_match = re.match(r"https?://([^/]+)/(.+?)(?:\.git)?$", url)
+
+        if ssh_match:
+            host, path = ssh_match.group(1), ssh_match.group(2)
+        elif https_match:
+            host, path = https_match.group(1), https_match.group(2)
+        else:
+            raise ValueError(f"Cannot parse remote URL: {url}")
+
+        if "github" in host.lower():
+            return self.PLATFORM_GITHUB, path
+        else:
+            # Default to GitLab for non-GitHub hosts
+            return self.PLATFORM_GITLAB, path
+
+    @property
+    def cli(self) -> str:
+        """Return the CLI tool name for this platform."""
+        return "gh" if self.platform == self.PLATFORM_GITHUB else "glab"
+
+    @property
+    def is_github(self) -> bool:
+        return self.platform == self.PLATFORM_GITHUB
+
+    @property
+    def is_gitlab(self) -> bool:
+        return self.platform == self.PLATFORM_GITLAB
+
+    # --- Issues ---
+
+    def fetch_issue(self, issue_number: int) -> Dict[str, Any]:
+        """Fetch issue details from GitHub or GitLab."""
+        if self.is_github:
+            fields = "number,title,body,state,author,labels,comments,createdAt,updatedAt,url"
+            stdout, stderr, rc = _run([
+                "gh", "issue", "view", str(issue_number),
+                "-R", self.repo_path,
+                "--json", fields,
+            ])
+        else:
+            stdout, stderr, rc = _run([
+                "glab", "issue", "view", str(issue_number),
+                "--output", "json",
+            ])
+
+        if rc != 0:
+            raise RuntimeError(f"Failed to fetch issue #{issue_number}: {stderr}")
+
+        return json.loads(stdout)
+
+    def list_open_issues(self, limit: int = 50) -> List[Dict[str, Any]]:
+        """List open issues."""
+        if self.is_github:
+            stdout, stderr, rc = _run([
+                "gh", "issue", "list",
+                "--repo", self.repo_path,
+                "--state", "open",
+                "--json", "number,title,body,labels,createdAt,updatedAt",
+                "--limit", str(limit),
+            ])
+        else:
+            stdout, stderr, rc = _run([
+                "glab", "issue", "list",
+                "--opened",
+                "--output", "json",
+                "--per-page", str(limit),
+            ])
+
+        if rc != 0:
+            return []
+
+        return json.loads(stdout) if stdout else []
+
+    def comment_on_issue(self, issue_number: int, body: str) -> bool:
+        """Post a comment on an issue/MR."""
+        if self.is_github:
+            _, stderr, rc = _run([
+                "gh", "issue", "comment", str(issue_number),
+                "-R", self.repo_path,
+                "--body", body,
+            ])
+        else:
+            _, stderr, rc = _run([
+                "glab", "issue", "note", str(issue_number),
+                "--message", body,
+            ])
+
+        return rc == 0
+
+    def fetch_issue_comments(self, issue_number: int) -> List[Dict[str, Any]]:
+        """Fetch comments on an issue."""
+        if self.is_github:
+            stdout, stderr, rc = _run([
+                "gh", "issue", "view", str(issue_number),
+                "--repo", self.repo_path,
+                "--json", "comments",
+            ])
+            if rc == 0 and stdout:
+                data = json.loads(stdout)
+                return data.get("comments", [])
+        else:
+            stdout, stderr, rc = _run([
+                "glab", "api", f"projects/:id/issues/{issue_number}/notes",
+                "--paginate",
+            ])
+            if rc == 0 and stdout:
+                return json.loads(stdout)
+
+        return []
+
+    # --- Pull Requests / Merge Requests ---
+
+    def create_pr(self, title: str, body: str, base: str = "main",
+                  head: str = None) -> Optional[str]:
+        """Create a pull request (GitHub) or merge request (GitLab).
+
+        Returns the PR/MR URL on success, None on failure.
+        """
+        if self.is_github:
+            cmd = [
+                "gh", "pr", "create",
+                "--repo", self.repo_path,
+                "--title", title,
+                "--body", body,
+                "--base", base,
+            ]
+            if head:
+                cmd.extend(["--head", head])
+            stdout, stderr, rc = _run(cmd, timeout=60)
+        else:
+            cmd = [
+                "glab", "mr", "create",
+                "--title", title,
+                "--description", body,
+                "--target-branch", base,
+                "--remove-source-branch",
+                "--yes",
+            ]
+            if head:
+                cmd.extend(["--source-branch", head])
+            stdout, stderr, rc = _run(cmd, timeout=60)
+
+        if rc == 0:
+            # Extract URL from output
+            for line in (stdout + "\n" + stderr).splitlines():
+                if "http" in line:
+                    url_match = re.search(r'(https?://\S+)', line)
+                    if url_match:
+                        return url_match.group(1)
+            return stdout.strip() or "created"
+
+        return None
+
+    def check_pr_exists(self, branch_name: str) -> Optional[str]:
+        """Check if a PR/MR already exists for a branch. Returns URL or None."""
+        if self.is_github:
+            stdout, stderr, rc = _run([
+                "gh", "pr", "list",
+                "--repo", self.repo_path,
+                "--head", branch_name,
+                "--json", "url",
+            ])
+            if rc == 0 and stdout:
+                prs = json.loads(stdout)
+                if prs:
+                    return prs[0].get("url")
+        else:
+            stdout, stderr, rc = _run([
+                "glab", "mr", "list",
+                "--source-branch", branch_name,
+                "--output", "json",
+            ])
+            if rc == 0 and stdout:
+                mrs = json.loads(stdout)
+                if mrs:
+                    return mrs[0].get("web_url") or mrs[0].get("url")
+
+        return None
+
+    def comment_on_pr(self, pr_number: int, body: str) -> bool:
+        """Post a comment on a PR/MR."""
+        if self.is_github:
+            _, _, rc = _run([
+                "gh", "pr", "comment", str(pr_number),
+                "-R", self.repo_path,
+                "--body", body,
+            ])
+        else:
+            _, _, rc = _run([
+                "glab", "mr", "note", str(pr_number),
+                "--message", body,
+            ])
+        return rc == 0
+
+    # --- Utility ---
+
+    def get_remote_url(self) -> str:
+        """Get the git remote URL."""
+        stdout, _, _ = _run(["git", "remote", "get-url", "origin"])
+        return stdout
+
+    def whoami(self) -> str:
+        """Get the authenticated user."""
+        if self.is_github:
+            stdout, _, rc = _run(["gh", "auth", "status"])
+            return stdout
+        else:
+            stdout, _, rc = _run(["glab", "auth", "status"])
+            return stdout
+
+    def __repr__(self) -> str:
+        return f"VCS(platform={self.platform}, repo={self.repo_path})"

icdev/tools/ci/modules/workflow_ops.py

@@ -0,0 +1,295 @@
+# [TEMPLATE: CUI // SP-CTI]
+# ICDEV Workflow Operations — classify, branch, commit, PR helpers
+# Adapted from ADW workflow_ops.py with dual platform support
+
+"""
+Shared workflow operations for ICDEV CI/CD pipelines.
+
+Provides issue classification, branch name generation, commit message creation,
+PR/MR creation, and workflow extraction using Claude Code slash commands.
+
+Usage:
+    from icdev.tools.ci.modules.workflow_ops import classify_issue, generate_branch_name
+    issue_command, error = classify_issue(issue_json, run_id, logger)
+    branch_name, error = generate_branch_name(issue_json, issue_command, run_id, logger)
+"""
+
+import logging
+import re
+import subprocess
+from pathlib import Path
+from typing import Tuple, Optional
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent.parent
+
+from icdev.tools.ci.modules.agent import execute_template, BOT_IDENTIFIER
+from icdev.tools.ci.modules.state import ICDevState
+from icdev.tools.testing.data_types import AgentTemplateRequest, AgentPromptResponse
+from icdev.tools.testing.utils import parse_json
+
+# Agent name constants (adapted from ADW)
+AGENT_PLANNER = "icdev_planner"
+AGENT_IMPLEMENTOR = "icdev_implementor"
+AGENT_CLASSIFIER = "issue_classifier"
+AGENT_BRANCH_GENERATOR = "branch_generator"
+AGENT_PR_CREATOR = "pr_creator"
+
+# Available ICDEV workflows for runtime validation
+AVAILABLE_ICDEV_WORKFLOWS = [
+    "icdev_plan",
+    "icdev_build",
+    "icdev_test",
+    "icdev_review",
+    "icdev_comply",
+    "icdev_secure",
+    "icdev_deploy",
+    "icdev_document",
+    "icdev_patch",
+    "icdev_plan_build",
+    "icdev_plan_build_test",
+    "icdev_plan_build_test_review",
+    "icdev_sdlc",
+]
+
+
+def format_issue_message(
+    run_id: str, agent_name: str, message: str, session_id: Optional[str] = None
+) -> str:
+    """Format a message for issue comments with ICDEV tracking and bot identifier."""
+    if session_id:
+        return f"{BOT_IDENTIFIER} {run_id}_{agent_name}_{session_id}: {message}"
+    return f"{BOT_IDENTIFIER} {run_id}_{agent_name}: {message}"
+
+
+def extract_icdev_info(
+    text: str, temp_run_id: str
+) -> Tuple[Optional[str], Optional[str]]:
+    """Extract ICDEV workflow and run_id from text using classify_workflow agent.
+    Returns (workflow_command, run_id) tuple."""
+
+    request = AgentTemplateRequest(
+        agent_name="icdev_classifier",
+        slash_command="/classify_workflow",
+        args=[text],
+        run_id=temp_run_id,
+    )
+
+    try:
+        response = execute_template(request)
+
+        if not response.success:
+            print(f"Failed to classify ICDEV workflow: {response.output}")
+            return None, None
+
+        try:
+            data = parse_json(response.output, dict)
+            icdev_command = data.get("icdev_slash_command", "").replace("/", "")
+            run_id = data.get("run_id")
+
+            if icdev_command and icdev_command in AVAILABLE_ICDEV_WORKFLOWS:
+                return icdev_command, run_id
+
+            return None, None
+
+        except (ValueError, TypeError):
+            return None, None
+
+    except Exception as e:
+        print(f"Error calling classify_workflow: {e}")
+        return None, None
+
+
+def classify_issue(
+    issue_json: str, run_id: str, logger: logging.Logger
+) -> Tuple[Optional[str], Optional[str]]:
+    """Classify issue and return appropriate slash command.
+    Returns (command, error_message) tuple."""
+
+    request = AgentTemplateRequest(
+        agent_name=AGENT_CLASSIFIER,
+        slash_command="/classify_issue",
+        args=[issue_json],
+        run_id=run_id,
+    )
+
+    logger.debug("Classifying issue...")
+    response = execute_template(request)
+
+    if not response.success:
+        return None, response.output
+
+    output = response.output.strip()
+    classification_match = re.search(r"(/chore|/bug|/feature|/patch|0)", output)
+
+    if classification_match:
+        issue_command = classification_match.group(1)
+    else:
+        issue_command = output
+
+    if issue_command == "0":
+        return None, f"No command selected: {response.output}"
+
+    if issue_command not in ["/chore", "/bug", "/feature", "/patch"]:
+        return None, f"Invalid command selected: {response.output}"
+
+    return issue_command, None
+
+
+def generate_branch_name(
+    issue_json: str, issue_class: str, run_id: str, logger: logging.Logger
+) -> Tuple[Optional[str], Optional[str]]:
+    """Generate and create a git branch for the issue.
+    Returns (branch_name, error_message) tuple."""
+    issue_type = issue_class.replace("/", "")
+
+    request = AgentTemplateRequest(
+        agent_name=AGENT_BRANCH_GENERATOR,
+        slash_command="/generate_branch_name",
+        args=[issue_type, run_id, issue_json],
+        run_id=run_id,
+    )
+
+    response = execute_template(request)
+
+    if not response.success:
+        return None, response.output
+
+    branch_name = response.output.strip()
+    logger.info(f"Generated branch name: {branch_name}")
+    return branch_name, None
+
+
+def build_plan(
+    issue_json: str, command: str, run_id: str, logger: logging.Logger
+) -> AgentPromptResponse:
+    """Build implementation plan for the issue."""
+    request = AgentTemplateRequest(
+        agent_name=AGENT_PLANNER,
+        slash_command=command,
+        args=[issue_json],
+        run_id=run_id,
+    )
+
+    return execute_template(request)
+
+
+def implement_plan(
+    plan_file: str, run_id: str, logger: logging.Logger,
+    agent_name: Optional[str] = None
+) -> AgentPromptResponse:
+    """Implement the plan using the /implement command."""
+    implementor_name = agent_name or AGENT_IMPLEMENTOR
+
+    request = AgentTemplateRequest(
+        agent_name=implementor_name,
+        slash_command="/implement",
+        args=[plan_file],
+        run_id=run_id,
+    )
+
+    return execute_template(request)
+
+
+def create_commit(
+    agent_name: str, issue_json: str, issue_class: str,
+    run_id: str, logger: logging.Logger
+) -> Tuple[Optional[str], Optional[str]]:
+    """Create a git commit with a properly formatted message.
+    Returns (commit_message, error_message) tuple."""
+    issue_type = issue_class.replace("/", "")
+    unique_agent_name = f"{agent_name}_committer"
+
+    request = AgentTemplateRequest(
+        agent_name=unique_agent_name,
+        slash_command="/commit",
+        args=[agent_name, issue_type, issue_json],
+        run_id=run_id,
+    )
+
+    response = execute_template(request)
+
+    if not response.success:
+        return None, response.output
+
+    commit_message = response.output.strip()
+    logger.info(f"Created commit message: {commit_message}")
+    return commit_message, None
+
+
+def create_pull_request(
+    branch_name: str, issue_json: str, state: ICDevState,
+    logger: logging.Logger
+) -> Tuple[Optional[str], Optional[str]]:
+    """Create a pull request/merge request for the implemented changes.
+    Returns (pr_url, error_message) tuple."""
+    plan_file = state.get("plan_file") or "No plan file"
+    run_id = state.get("run_id")
+
+    request = AgentTemplateRequest(
+        agent_name=AGENT_PR_CREATOR,
+        slash_command="/pull_request",
+        args=[branch_name, issue_json, plan_file, run_id],
+        run_id=run_id,
+    )
+
+    response = execute_template(request)
+
+    if not response.success:
+        return None, response.output
+
+    pr_url = response.output.strip()
+    logger.info(f"Created PR/MR: {pr_url}")
+    return pr_url, None
+
+
+def ensure_run_id(
+    issue_number: str,
+    run_id: Optional[str] = None,
+    logger: Optional[logging.Logger] = None,
+) -> str:
+    """Get run_id or create a new one and initialize state."""
+    from icdev.tools.testing.utils import make_run_id
+
+    if run_id:
+        state = ICDevState.load(run_id, logger)
+        if state.get("run_id") == run_id:
+            if logger:
+                logger.info(f"Found existing state for run_id: {run_id}")
+            return run_id
+        state = ICDevState(run_id, logger)
+        state.update(run_id=run_id, issue_number=issue_number)
+        state.save("ensure_run_id")
+        return run_id
+
+    new_run_id = make_run_id()
+    state = ICDevState(new_run_id, logger)
+    state.update(run_id=new_run_id, issue_number=issue_number)
+    state.save("ensure_run_id")
+    if logger:
+        logger.info(f"Created new run_id and state: {new_run_id}")
+    return new_run_id
+
+
+def find_existing_branch_for_issue(
+    issue_number: str, run_id: Optional[str] = None
+) -> Optional[str]:
+    """Find an existing branch for the given issue number."""
+    result = subprocess.run(
+        ["git", "branch", "-a"], capture_output=True, text=True,
+        cwd=str(PROJECT_ROOT),
+    )
+
+    if result.returncode != 0:
+        return None
+
+    branches = result.stdout.strip().split("\n")
+
+    for branch in branches:
+        branch = branch.strip().replace("* ", "").replace("remotes/origin/", "")
+        if f"-issue-{issue_number}-" in branch:
+            if run_id and f"-icdev-{run_id}-" in branch:
+                return branch
+            elif not run_id:
+                return branch
+
+    return None