icdev 1.0.0__py3-none-any.whl

icdev/tools/ci/modules/agent.py

@@ -0,0 +1,271 @@
+# [TEMPLATE: CUI // SP-CTI]
+# ICDEV Agent Executor — Claude Code CLI subprocess invocation
+# Wrapper around tools/agent/agent_executor.py for retry, audit, Bedrock fallback
+
+"""
+Execute Claude Code CLI as a subprocess with slash commands.
+
+Thin wrapper around the robust agent executor (tools/agent/agent_executor.py)
+that provides retry logic (3 attempts), Bedrock fallback, token tracking in
+the agent_executions table, and configurable timeout from cicd_config.yaml.
+
+Preserves backward-compatible APIs used by all CI/CD workflow scripts:
+    - execute_template(request) — slash command execution
+    - prompt_claude_code(request) — direct prompt execution
+    - SLASH_COMMAND_MODEL_MAP — model per command
+    - BOT_IDENTIFIER — bot loop prevention
+
+Usage:
+    from icdev.tools.ci.modules.agent import execute_template
+    request = AgentTemplateRequest(
+        agent_name="planner",
+        slash_command="/icdev-build",
+        args=["user auth with JWT"],
+        run_id="abc12345",
+    )
+    response = execute_template(request)
+"""
+
+import json
+import os
+import sys
+from pathlib import Path
+
+import yaml
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent.parent
+sys.path.insert(0, str(PROJECT_ROOT))
+
+from icdev.tools.testing.data_types import AgentTemplateRequest, AgentPromptRequest, AgentPromptResponse
+
+# Model mapping per slash command (adapted from ADW SLASH_COMMAND_MODEL_MAP)
+SLASH_COMMAND_MODEL_MAP = {
+    # Classification (fast, cheap)
+    "/classify_issue": "haiku",
+    "/classify_workflow": "haiku",
+    "/generate_branch_name": "haiku",
+    # Planning (needs reasoning)
+    "/icdev-init": "sonnet",
+    "/icdev-build": "opus",
+    "/icdev-comply": "sonnet",
+    "/icdev-deploy": "sonnet",
+    "/bug": "opus",
+    "/feature": "opus",
+    "/chore": "sonnet",
+    "/patch": "sonnet",
+    # Testing (fast execution)
+    "/icdev-test": "sonnet",
+    "/test": "sonnet",
+    "/test_e2e": "sonnet",
+    "/resolve_failed_test": "sonnet",
+    "/resolve_failed_e2e_test": "sonnet",
+    # Review/security (needs depth)
+    "/icdev-review": "opus",
+    "/review": "opus",
+    "/icdev-secure": "sonnet",
+    "/icdev-status": "haiku",
+    "/icdev-monitor": "sonnet",
+    "/icdev-knowledge": "sonnet",
+    # Documentation
+    "/document": "sonnet",
+    # Git operations (fast)
+    "/commit": "haiku",
+    "/pull_request": "haiku",
+    "/implement": "opus",
+}
+
+# Bot identifier for preventing infinite loops
+BOT_IDENTIFIER = "[ICDEV-BOT]"
+
+
+def _get_timeout(slash_command: str = "") -> int:
+    """Read configurable timeout from cicd_config.yaml."""
+    config_path = PROJECT_ROOT / "args" / "cicd_config.yaml"
+    default_timeout = 300
+    try:
+        if config_path.exists():
+            with open(config_path) as f:
+                data = yaml.safe_load(f) or {}
+            executor_cfg = data.get("cicd", {}).get("executor", {})
+            overrides = executor_cfg.get("timeout_overrides", {})
+            if slash_command and slash_command in overrides:
+                return overrides[slash_command]
+            return executor_cfg.get("default_timeout_seconds", default_timeout)
+    except Exception:
+        pass
+    return default_timeout
+
+
+def _ensure_agent_dir(run_id: str, agent_name: str) -> Path:
+    """Create and return the agent working directory."""
+    agent_dir = PROJECT_ROOT / "agents" / run_id / agent_name
+    agent_dir.mkdir(parents=True, exist_ok=True)
+    (agent_dir / "prompts").mkdir(exist_ok=True)
+    return agent_dir
+
+
+def prompt_claude_code(request: AgentPromptRequest) -> AgentPromptResponse:
+    """Execute Claude Code CLI with a direct prompt.
+
+    Delegates to the robust executor (tools/agent/agent_executor.py) which
+    provides retry logic, token tracking, and audit trail. Falls back to
+    direct subprocess execution if robust executor is unavailable.
+    """
+    timeout = _get_timeout()
+
+    try:
+        from icdev.tools.agent.agent_executor import execute_agent
+        from icdev.tools.agent.agent_models import (
+            AgentPromptRequest as RobustRequest,
+        )
+
+        # Map CI request -> robust executor request
+        robust_req = RobustRequest(
+            prompt=request.prompt,
+            model=request.model,
+            project_dir=request.project_dir or str(PROJECT_ROOT),
+            timeout_seconds=timeout,
+        )
+
+        robust_resp = execute_agent(robust_req, max_retries=3)
+
+        # Map robust response -> CI response
+        return AgentPromptResponse(
+            output=robust_resp.output_text or "",
+            success=robust_resp.status == "completed",
+            session_id=robust_resp.session_id,
+            duration_ms=robust_resp.duration_ms,
+        )
+
+    except ImportError:
+        # Robust executor not available — direct subprocess fallback
+        pass
+
+    # Fallback: direct Claude Code CLI invocation
+    import subprocess
+    from icdev.tools.testing.utils import get_safe_subprocess_env
+
+    claude_path = os.getenv("CLAUDE_CODE_PATH", "claude")
+    env = get_safe_subprocess_env()
+
+    cmd = [claude_path, "-p", request.prompt]
+    cmd.extend(["--model", request.model])
+    cmd.extend(["--output-format", "stream-json"])
+    cmd.append("--verbose")
+
+    output_file = request.output_file
+    if not output_file:
+        output_file = str(PROJECT_ROOT / ".tmp" / "agent_output.jsonl")
+    Path(output_file).parent.mkdir(parents=True, exist_ok=True)
+
+    try:
+        with open(output_file, "w") as f:
+            result = subprocess.run(
+                cmd, stdout=f, stderr=subprocess.PIPE, text=True,
+                env=env, timeout=timeout,
+                cwd=request.project_dir or str(PROJECT_ROOT),
+                stdin=subprocess.DEVNULL,
+            )
+
+        output_text = ""
+        session_id = None
+        is_error = False
+
+        with open(output_file, "r") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+                try:
+                    msg = json.loads(line)
+                    if msg.get("type") == "result":
+                        output_text = msg.get("result", "")
+                        session_id = msg.get("session_id")
+                        is_error = msg.get("is_error", False)
+                        break
+                except json.JSONDecodeError:
+                    continue
+
+        return AgentPromptResponse(
+            output=output_text,
+            success=not is_error and result.returncode == 0,
+            session_id=session_id,
+            duration_ms=None,
+        )
+
+    except subprocess.TimeoutExpired:
+        return AgentPromptResponse(
+            output=f"Claude Code timed out after {timeout} seconds",
+            success=False,
+        )
+    except FileNotFoundError:
+        return AgentPromptResponse(
+            output=f"Claude Code CLI not found at '{claude_path}'",
+            success=False,
+        )
+    except Exception as e:
+        return AgentPromptResponse(
+            output=f"Agent execution error: {str(e)}",
+            success=False,
+        )
+
+
+def execute_template(request: AgentTemplateRequest) -> AgentPromptResponse:
+    """Execute a Claude Code slash command template.
+
+    1. Look up model from SLASH_COMMAND_MODEL_MAP
+    2. Build prompt: "{slash_command} {args}"
+    3. Save prompt to agents/{run_id}/{agent_name}/prompts/
+    4. Execute via prompt_claude_code() (delegates to robust executor)
+    5. Return structured response
+    """
+    # Determine model
+    model = SLASH_COMMAND_MODEL_MAP.get(request.slash_command, request.model)
+
+    # Build prompt
+    prompt = request.slash_command
+    if request.args:
+        prompt += " " + " ".join(request.args)
+
+    # Set up agent directory
+    agent_dir = _ensure_agent_dir(request.run_id, request.agent_name)
+
+    # Save prompt for debugging
+    cmd_name = request.slash_command.lstrip("/").replace("-", "_")
+    prompt_file = agent_dir / "prompts" / f"{cmd_name}.txt"
+    with open(prompt_file, "w") as f:
+        f.write(prompt)
+
+    # Output file
+    output_file = str(agent_dir / "raw_output.jsonl")
+
+    # Execute
+    prompt_request = AgentPromptRequest(
+        prompt=prompt,
+        agent_name=request.agent_name,
+        model=model,
+        output_file=output_file,
+        project_dir=".",
+    )
+
+    response = prompt_claude_code(prompt_request)
+
+    # Also save as JSON array for easier reading
+    try:
+        jsonl_path = agent_dir / "raw_output.jsonl"
+        json_path = agent_dir / "raw_output.json"
+        if jsonl_path.exists():
+            entries = []
+            with open(jsonl_path) as f:
+                for line in f:
+                    if line.strip():
+                        try:
+                            entries.append(json.loads(line))
+                        except json.JSONDecodeError:
+                            pass
+            with open(json_path, "w") as f:
+                json.dump(entries, f, indent=2)
+    except Exception:
+        pass
+
+    return response

icdev/tools/ci/modules/git_ops.py

@@ -0,0 +1,175 @@
+# [TEMPLATE: CUI // SP-CTI]
+# ICDEV Git Operations — branch, commit, push, PR/MR
+# Adapted from ADW git_ops.py with GitLab MR support
+
+"""
+Git operations for ICDEV CI/CD workflows.
+
+Provides branching, committing, pushing, and PR/MR creation
+using git CLI directly (platform-agnostic for git operations)
+and VCS abstraction for PR/MR creation.
+
+Usage:
+    from icdev.tools.ci.modules.git_ops import create_branch, commit_changes, finalize_git_operations
+    success, error = create_branch("feat-123-auth")
+    success, error = commit_changes("Add authentication module")
+    finalize_git_operations(state, logger)
+"""
+
+import subprocess
+from pathlib import Path
+from typing import Tuple, Optional
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent.parent
+
+
+def _git(args: list, cwd: str = None) -> Tuple[str, str, int]:
+    """Run a git command."""
+    proc = subprocess.run(
+        ["git"] + args,
+        capture_output=True, text=True,
+        cwd=cwd or str(PROJECT_ROOT),
+    )
+    return proc.stdout.strip(), proc.stderr.strip(), proc.returncode
+
+
+def create_branch(branch_name: str) -> Tuple[bool, Optional[str]]:
+    """Create and checkout a new branch (or checkout existing).
+
+    Adapted from ADW create_branch pattern.
+    """
+    # Try creating new branch
+    _, stderr, rc = _git(["checkout", "-b", branch_name])
+    if rc == 0:
+        return True, None
+
+    # Branch might already exist — try checking out
+    _, stderr2, rc2 = _git(["checkout", branch_name])
+    if rc2 == 0:
+        return True, None
+
+    return False, f"Failed to create branch '{branch_name}': {stderr}"
+
+
+def commit_changes(message: str, paths: list = None) -> Tuple[bool, Optional[str]]:
+    """Stage changes and commit.
+
+    Args:
+        message: Commit message.
+        paths: Optional list of specific file paths to stage. If provided,
+               only these paths are staged (targeted add). If None, stages
+               all tracked modified files with ``git add -u`` (safer than
+               ``git add -A`` which also stages untracked files that may
+               include sensitive files like .env or credentials).
+    """
+    if paths:
+        # Targeted staging — only specific files
+        _, stderr, rc = _git(["add", "--"] + paths)
+    else:
+        # Stage tracked modified files only (not untracked)
+        _, stderr, rc = _git(["add", "-u"])
+    if rc != 0:
+        return False, f"git add failed: {stderr}"
+
+    # Check if there's anything to commit
+    stdout, _, _ = _git(["status", "--porcelain"])
+    if not stdout.strip():
+        return True, None  # Nothing to commit, still success
+
+    # Commit
+    _, stderr, rc = _git(["commit", "-m", message])
+    if rc != 0:
+        return False, f"git commit failed: {stderr}"
+
+    return True, None
+
+
+def push_branch(branch_name: str) -> Tuple[bool, Optional[str]]:
+    """Push branch to remote.
+
+    Adapted from ADW push_branch pattern.
+    """
+    _, stderr, rc = _git(["push", "-u", "origin", branch_name])
+    if rc != 0:
+        return False, f"git push failed: {stderr}"
+    return True, None
+
+
+def get_current_branch() -> Optional[str]:
+    """Get the current branch name."""
+    stdout, _, rc = _git(["branch", "--show-current"])
+    return stdout if rc == 0 else None
+
+
+def finalize_git_operations(state, logger, vcs=None):
+    """Push changes and create/update PR or MR.
+
+    Adapted from ADW finalize_git_operations pattern with dual platform support.
+
+    Args:
+        state: ICDevState instance
+        logger: Logger instance
+        vcs: VCS instance (auto-created if None)
+    """
+    branch_name = state.get("branch_name")
+    issue_number = state.get("issue_number")
+
+    if not branch_name:
+        logger.warning("No branch name in state, skipping finalize")
+        return
+
+    # Import VCS if needed
+    if vcs is None:
+        from icdev.tools.ci.modules.vcs import VCS
+        try:
+            vcs = VCS()
+        except Exception as e:
+            logger.error(f"Cannot initialize VCS: {e}")
+            return
+
+    # Push
+    logger.info(f"Pushing branch {branch_name}...")
+    success, error = push_branch(branch_name)
+    if not success:
+        logger.error(f"Push failed: {error}")
+        if issue_number:
+            vcs.comment_on_issue(int(issue_number), f"[ICDEV-BOT] Push failed: {error}")
+        return
+
+    logger.info("Push successful")
+
+    # Check if PR/MR exists
+    pr_url = vcs.check_pr_exists(branch_name)
+    if pr_url:
+        logger.info(f"PR/MR already exists: {pr_url}")
+        if issue_number:
+            platform_name = "MR" if vcs.is_gitlab else "PR"
+            vcs.comment_on_issue(
+                int(issue_number),
+                f"[ICDEV-BOT] Updated existing {platform_name}: {pr_url}"
+            )
+        return
+
+    # Create new PR/MR
+    logger.info("Creating new PR/MR...")
+    run_id = state.get("run_id", "unknown")
+    title = f"ICDEV-{run_id}: Issue #{issue_number}" if issue_number else f"ICDEV-{run_id}"
+    body = (
+        f"## Summary\n"
+        f"Automated by ICDEV workflow run `{run_id}`\n\n"
+        f"Closes #{issue_number}\n\n"
+        f"## CUI // SP-CTI\n"
+        f"Generated by ICDEV CI/CD system.\n"
+    )
+
+    pr_url = vcs.create_pr(title=title, body=body, head=branch_name)
+    if pr_url:
+        platform_name = "Merge Request" if vcs.is_gitlab else "Pull Request"
+        logger.info(f"{platform_name} created: {pr_url}")
+        if issue_number:
+            vcs.comment_on_issue(
+                int(issue_number),
+                f"[ICDEV-BOT] Created {platform_name}: {pr_url}"
+            )
+    else:
+        logger.error("Failed to create PR/MR")

icdev/tools/ci/modules/state.py

@@ -0,0 +1,117 @@
+# [TEMPLATE: CUI // SP-CTI]
+# ICDEV Workflow State Management
+# Adapted from ADW state.py
+
+"""
+Persistent state management for ICDEV CI/CD workflows.
+
+State is stored at agents/{run_id}/icdev_state.json and tracks:
+- run_id, issue_number, branch_name, plan_file, issue_class
+- platform (github/gitlab)
+
+Supports piping between scripts via stdin/stdout (ADW pattern).
+
+Usage:
+    state = ICDevState.load(run_id, logger)
+    state.update(branch_name="feat-123")
+    state.save("icdev_plan")
+    state.to_stdout()  # For piping
+"""
+
+import json
+import sys
+from pathlib import Path
+from typing import Optional, Any
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent.parent
+
+# Core fields persisted to state file
+CORE_FIELDS = {
+    "run_id", "issue_number", "branch_name", "plan_file",
+    "issue_class", "platform", "project_id",
+}
+
+
+class ICDevState:
+    """Persistent workflow state for ICDEV CI/CD pipelines."""
+
+    def __init__(self, run_id: str, logger=None):
+        self.run_id = run_id
+        self._data = {"run_id": run_id}
+        self._logger = logger
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self._data.get(key, default)
+
+    def update(self, **kwargs):
+        """Update state with key-value pairs (only core fields)."""
+        for key, value in kwargs.items():
+            if key in CORE_FIELDS and value is not None:
+                self._data[key] = value
+
+    @property
+    def state_dir(self) -> Path:
+        return PROJECT_ROOT / "agents" / self.run_id
+
+    @property
+    def state_file(self) -> Path:
+        return self.state_dir / "icdev_state.json"
+
+    def save(self, workflow_step: str = ""):
+        """Persist state to file."""
+        self.state_dir.mkdir(parents=True, exist_ok=True)
+        with open(self.state_file, "w") as f:
+            json.dump(self._data, f, indent=2)
+        if self._logger:
+            self._logger.debug(f"State saved to {self.state_file}")
+
+    @classmethod
+    def load(cls, run_id: str, logger=None) -> "ICDevState":
+        """Load state from file, or create new."""
+        state = cls(run_id, logger)
+        state_file = state.state_file
+        if state_file.exists():
+            try:
+                with open(state_file) as f:
+                    data = json.load(f)
+                state._data = data
+                if logger:
+                    logger.debug(f"State loaded from {state_file}")
+            except (json.JSONDecodeError, IOError) as e:
+                if logger:
+                    logger.warning(f"Could not load state: {e}")
+        return state
+
+    @classmethod
+    def from_stdin(cls, logger=None) -> Optional["ICDevState"]:
+        """Read state from stdin if piped (ADW chaining pattern).
+
+        Used for: script1 | script2 (pipe state between workflow steps)
+        """
+        if sys.stdin.isatty():
+            return None
+
+        try:
+            raw = sys.stdin.read().strip()
+            if not raw:
+                return None
+            data = json.loads(raw)
+            run_id = data.get("run_id")
+            if not run_id:
+                return None
+            state = cls(run_id, logger)
+            state._data = data
+            return state
+        except (json.JSONDecodeError, IOError):
+            return None
+
+    def to_stdout(self):
+        """Write core state to stdout for piping to next script."""
+        output = {k: v for k, v in self._data.items() if k in CORE_FIELDS}
+        print(json.dumps(output))
+
+    def to_dict(self) -> dict:
+        return dict(self._data)
+
+    def __repr__(self):
+        return f"ICDevState(run_id={self.run_id}, keys={list(self._data.keys())})"