agentic-devtools 0.2.332__py3-none-any.whl → 0.2.334__py3-none-any.whl

agentic_devtools/orchestration/nodes/retrieve.py

@@ -0,0 +1,198 @@
+"""Retrieve node: fetch issue details from Jira or GitHub.
+
+Handles both Jira (via ``agdt-get-jira-issue``) and GitHub
+(via ``GitHubIssuesAdapter.get_issue()``) issue retrieval paths.
+Normalizes issue data into a common state format.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from agentic_devtools.cli.github.repo_resolution import resolve_github_repo_safe
+from agentic_devtools.cli.jira.adf import _convert_adf_to_text
+from agentic_devtools.orchestration.nodes._helpers import (
+    detect_issue_provider,
+    normalize_issue_key,
+    run_command,
+    utc_now,
+)
+from agentic_devtools.orchestration.state_schema import WorkOnIssueState
+
+
+def retrieve_node(state: WorkOnIssueState) -> dict[str, Any]:
+    """Fetch issue details and store normalized data in state.
+
+    Dispatches to Jira or GitHub retrieval based on ``issue_provider``.
+    """
+    issue_key = state.get("issue_key", "")
+    # Fail fast when issue_key is missing, blank, or not a string — provider
+    # detection and Jira/GitHub retrieval both require a valid key.
+    if not isinstance(issue_key, str):
+        return _error_result("issue_key is required and must be a non-empty string")
+    issue_key = issue_key.strip()
+    if not issue_key:
+        return _error_result("issue_key is required and must be a non-empty string")
+    raw_issue_provider = state.get("issue_provider")
+    issue_provider = (
+        raw_issue_provider
+        if isinstance(raw_issue_provider, str) and raw_issue_provider in {"jira", "github"}
+        else detect_issue_provider(issue_key)
+    )
+
+    if issue_provider == "jira":
+        result = _retrieve_jira(issue_key)
+    else:
+        result = _retrieve_github(issue_key)
+
+    # Propagate the (potentially derived) issue_provider back to state so downstream
+    # nodes (e.g. pull_request_node) don't default to Jira/Azure DevOps when
+    # issue_provider was absent or corrupted in the checkpoint.
+    result["issue_provider"] = issue_provider
+    return result
+
+
+def _retrieve_jira(issue_key: str) -> dict[str, Any]:
+    """Retrieve issue details from Jira via agdt commands."""
+    # Set the issue key in state
+    set_result = run_command(["agdt-set", "jira.issue_key", issue_key])
+    if set_result.returncode != 0:
+        return _error_result(f"Failed to set jira.issue_key: {set_result.stderr.strip()}")
+
+    # Invoke agdt-get-jira-issue (background task)
+    get_result = run_command(["agdt-get-jira-issue"])
+    if get_result.returncode != 0:
+        return _error_result(f"Failed to invoke agdt-get-jira-issue: {get_result.stderr.strip()}")
+
+    # Wait for task completion
+    wait_result = run_command(["agdt-task-wait"], timeout=120)
+    if wait_result.returncode != 0:
+        return _error_result(f"agdt-task-wait failed: {wait_result.stderr.strip()}")
+
+    # Read the output file
+    from agentic_devtools.state import get_state_dir
+
+    state_dir = get_state_dir()
+    output_file = Path(state_dir) / "temp-get-issue-details-response.json"
+
+    if not output_file.exists():
+        return _error_result(f"Issue details output file not found: {output_file}")
+
+    try:
+        issue_data = json.loads(output_file.read_text(encoding="utf-8"))
+    except (json.JSONDecodeError, OSError) as exc:
+        return _error_result(f"Failed to parse issue details: {exc}")
+    if not isinstance(issue_data, dict):
+        return _error_result("Failed to parse issue details: expected a JSON object.")
+
+    # Normalize issue data
+    normalized = _normalize_jira_issue(issue_data, issue_key)
+
+    return {
+        "step": "retrieve",
+        "error": None,
+        "issue_data": normalized,
+        "issue_retrieved": True,
+        "events": [
+            {
+                "event": "retrieve_completed",
+                "timestamp": utc_now(),
+                "signals": {"provider": "jira", "issue_key": issue_key},
+            }
+        ],
+    }
+
+
+def _retrieve_github(issue_key: str) -> dict[str, Any]:
+    """Retrieve issue details from GitHub via adapter."""
+    try:
+        from agentic_devtools.adapters.github_adapter import GitHubIssuesAdapter
+
+        normalized_issue_key = normalize_issue_key(issue_key)
+        if not normalized_issue_key:
+            return _error_result("GitHub issue retrieval failed: issue key is empty after normalization.")
+        repo = resolve_github_repo_safe()
+        if not repo:
+            return {
+                "step": "retrieve",
+                "error": "Cannot resolve GitHub repository from state or git remote.",
+                "issue_data": {},
+                "issue_retrieved": False,
+                "events": [
+                    {
+                        "event": "retrieve_failed",
+                        "timestamp": utc_now(),
+                        "signals": {"provider": "github", "issue_key": issue_key},
+                    }
+                ],
+            }
+
+        adapter = GitHubIssuesAdapter(repo=repo)
+        issue_data = adapter.get_issue(normalized_issue_key)
+
+        normalized: dict[str, Any] = {
+            "key": normalized_issue_key,
+            "provider": "github",
+            "summary": issue_data.get("title", ""),
+            "description": issue_data.get("description", ""),
+            "status": issue_data.get("status", "open"),
+            "labels": issue_data.get("labels", []),
+        }
+
+        return {
+            "step": "retrieve",
+            "error": None,
+            "issue_data": normalized,
+            "issue_retrieved": True,
+            "events": [
+                {
+                    "event": "retrieve_completed",
+                    "timestamp": utc_now(),
+                    "signals": {"provider": "github", "issue_key": issue_key},
+                }
+            ],
+        }
+    except Exception as exc:
+        return _error_result(f"GitHub issue retrieval failed: {exc}")
+
+
+def _normalize_jira_issue(raw: dict[str, Any], issue_key: str) -> dict[str, Any]:
+    """Normalize raw Jira API response to common format."""
+    raw_fields = raw.get("fields")
+    fields: dict[str, Any] = raw_fields if isinstance(raw_fields, dict) else {}
+    status_field = fields.get("status")
+    status_name = status_field.get("name", "") if isinstance(status_field, dict) else ""
+    issuetype_field = fields.get("issuetype")
+    issue_type_name = issuetype_field.get("name", "") if isinstance(issuetype_field, dict) else ""
+    parent_field = fields.get("parent")
+    parent_key = parent_field.get("key") if isinstance(parent_field, dict) else None
+    labels = fields.get("labels", [])
+    return {
+        "key": issue_key,
+        "provider": "jira",
+        "summary": _convert_adf_to_text(fields.get("summary")),
+        "description": _convert_adf_to_text(fields.get("description")),
+        "status": status_name,
+        "issue_type": issue_type_name,
+        "labels": labels if isinstance(labels, list) else [],
+        "parent_key": parent_key,
+    }
+
+
+def _error_result(message: str) -> dict[str, Any]:
+    """Build an error result dict."""
+    return {
+        "step": "retrieve",
+        "error": message,
+        "issue_data": {},
+        "issue_retrieved": False,
+        "events": [
+            {
+                "event": "retrieve_failed",
+                "timestamp": utc_now(),
+                "signals": {"error": message},
+            }
+        ],
+    }

agentic_devtools/orchestration/nodes/setup.py

@@ -0,0 +1,123 @@
+"""Setup node: validate branch context and create branch if needed.
+
+Validates that the current git branch contains the issue key as a
+slash-delimited segment (case-insensitive). If validation fails, creates
+a new branch named ``feature/{issue_key}/implementation`` in the current
+repository.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agentic_devtools.orchestration.nodes._helpers import (
+    normalize_issue_key,
+    run_command,
+    utc_now,
+)
+from agentic_devtools.orchestration.state_schema import WorkOnIssueState
+
+
+def _branch_targets_issue(branch_name: str, normalized_issue_key: str) -> bool:
+    """Return whether a slash-delimited branch name targets the given issue key."""
+    normalized_segments = [segment.strip().lower() for segment in branch_name.split("/") if segment.strip()]
+    return normalized_issue_key.lower() in normalized_segments
+
+
+def setup_node(state: WorkOnIssueState) -> dict[str, Any]:
+    """Validate worktree/branch and create if needed.
+
+    Checks that the current git branch contains the issue key as a
+    slash-delimited branch segment (case-insensitive). If not, attempts
+    to create a new branch.
+    """
+    issue_key = state.get("issue_key", "")
+    if not isinstance(issue_key, str):
+        type_name = type(issue_key).__name__
+        return {
+            "step": "setup",
+            "error": "issue_key must be a string; cannot determine target branch",
+            "events": [
+                {
+                    "event": "setup_failed",
+                    "timestamp": utc_now(),
+                    "signals": {"error": f"issue_key validation failed: expected string, got {type_name}"},
+                }
+            ],
+        }
+
+    normalized_key = normalize_issue_key(issue_key)
+
+    if not normalized_key:
+        return {
+            "step": "setup",
+            "error": "issue_key is missing or empty; cannot determine target branch",
+            "events": [
+                {
+                    "event": "setup_failed",
+                    "timestamp": utc_now(),
+                    "signals": {"error": "issue_key is missing or empty"},
+                }
+            ],
+        }
+
+    # Get current branch name
+    result = run_command(["git", "rev-parse", "--abbrev-ref", "HEAD"])
+    if result.returncode != 0:
+        return {
+            "step": "setup",
+            "error": f"Failed to determine current branch: {result.stderr.strip()}",
+            "events": [
+                {
+                    "event": "setup_failed",
+                    "timestamp": utc_now(),
+                    "signals": {"error": result.stderr.strip()},
+                }
+            ],
+        }
+
+    current_branch = result.stdout.strip()
+
+    # Check if branch contains the issue key as an exact branch segment.
+    if _branch_targets_issue(current_branch, normalized_key):
+        return {
+            "step": "setup",
+            "error": None,
+            "setup_complete": True,
+            "events": [
+                {
+                    "event": "setup_completed",
+                    "timestamp": utc_now(),
+                    "signals": {"branch": current_branch, "action": "validated"},
+                }
+            ],
+        }
+
+    # Branch doesn't contain issue key — create a new branch
+    new_branch = f"feature/{normalized_key}/implementation"
+    create_result = run_command(["git", "checkout", "-b", new_branch])
+    if create_result.returncode != 0:
+        return {
+            "step": "setup",
+            "error": f"Failed to create branch {new_branch}: {create_result.stderr.strip()}",
+            "events": [
+                {
+                    "event": "setup_failed",
+                    "timestamp": utc_now(),
+                    "signals": {"error": create_result.stderr.strip()},
+                }
+            ],
+        }
+
+    return {
+        "step": "setup",
+        "error": None,
+        "setup_complete": True,
+        "events": [
+            {
+                "event": "setup_completed",
+                "timestamp": utc_now(),
+                "signals": {"branch": new_branch, "action": "created"},
+            }
+        ],
+    }

agentic_devtools/orchestration/nodes/verification.py

@@ -0,0 +1,96 @@
+"""Verification node: run quality gates and track retry count.
+
+Executes ``bash scripts/targeted-checks.sh`` and evaluates results.
+On failure, increments retry count and returns an error. Routing back
+to implementation (when retries remain) or to error_handler (when the
+budget is exhausted) is handled by the graph routing functions in
+``pilot_workflow.py``.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agentic_devtools.orchestration.nodes._helpers import run_command, utc_now
+from agentic_devtools.orchestration.state_schema import WorkOnIssueState
+
+# Maximum characters stored in state for verification output.
+# Full output (which may include pytest traces and coverage reports) is
+# truncated before persisting to avoid bloating checkpoints.
+_MAX_STORED_OUTPUT_CHARS = 4000
+# Prefix prepended to the stored tail when output is truncated.
+_TRUNCATION_PREFIX = "[... truncated ...]\n"
+
+
+def verification_node(state: WorkOnIssueState) -> dict[str, Any]:
+    """Execute quality gates and evaluate pass/fail.
+
+    Runs ``bash scripts/targeted-checks.sh`` in default check mode.
+    Exit code 0 means all checks pass; exit 1-9 indicates failed check count.
+    """
+    retry_count = _normalize_retry_count(state.get("retry_count", 0))
+
+    # Execute quality gates
+    result = run_command(
+        ["bash", "scripts/targeted-checks.sh"],
+        timeout=300,
+    )
+
+    full_output = result.stdout + result.stderr
+    # Truncate for state storage; full output may include large pytest/coverage reports.
+    # Prepend a marker so consumers can tell the output was clipped.
+    if len(full_output) > _MAX_STORED_OUTPUT_CHARS:
+        tail_chars = _MAX_STORED_OUTPUT_CHARS - len(_TRUNCATION_PREFIX)
+        stored_output = _TRUNCATION_PREFIX + full_output[-tail_chars:]
+    else:
+        stored_output = full_output
+
+    if result.returncode == 0:
+        # All checks passed
+        return {
+            "step": "verification",
+            "error": None,
+            "retry_count": retry_count,
+            "verification_output": stored_output,
+            "events": [
+                {
+                    "event": "verification_passed",
+                    "timestamp": utc_now(),
+                    "signals": {"exit_code": 0},
+                }
+            ],
+        }
+
+    # Checks failed — increment retry count
+    retry_count += 1
+    error_msg = (
+        f"Quality gate failed (exit code {result.returncode}). Retry {retry_count}.\nOutput:\n{stored_output[:2000]}"
+    )
+
+    return {
+        "step": "verification",
+        "error": error_msg,
+        "retry_count": retry_count,
+        "verification_output": stored_output,
+        "events": [
+            {
+                "event": "verification_failed",
+                "timestamp": utc_now(),
+                "signals": {
+                    "exit_code": result.returncode,
+                    "retry_count": retry_count,
+                },
+            }
+        ],
+    }
+
+
+def _normalize_retry_count(value: object) -> int:
+    """Return retry_count as int, coercing non-int values to 0."""
+    if isinstance(value, bool):
+        return 0
+    if not isinstance(value, int):
+        return 0
+    if value < 0:
+        return 0
+    return value

agentic_devtools/orchestration/pilot_workflow.py

@@ -1,7 +1,9 @@
-"""Stub node functions and conditional edge routing for the pilot work-on-jira-issue workflow.
+"""Routing helpers plus legacy compatibility stubs for the pilot workflow.
 
-All node functions are pure stubs that manipulate ``WorkOnIssueState`` without calling
-real Jira, Git, or Azure DevOps systems. Real tool integration is deferred to Sub-issue 2.
+``build_work_on_issue_graph`` wires real node implementations from
+``agentic_devtools.orchestration.nodes``. The node functions in this module are
+kept only as lightweight compatibility shims for older direct imports and
+legacy unit tests.
 """
 
 from datetime import datetime, timezone
@@ -27,8 +29,19 @@ def _normalize_retry_count(value: object) -> int:
     return value
 
 
+def _normalize_retry_budget(value: object) -> int:
+    """Return retry_budget as int, falling back to :data:`MAX_RETRIES`."""
+    if isinstance(value, bool):
+        return MAX_RETRIES
+    if not isinstance(value, int):
+        return MAX_RETRIES
+    if value < 0:
+        return MAX_RETRIES
+    return value
+
+
 # ---------------------------------------------------------------------------
-# Node functions
+# Legacy compatibility node shims
 # ---------------------------------------------------------------------------
 
 
@@ -199,10 +212,17 @@ def completion_node(state: WorkOnIssueState) -> dict:
 
 
 def error_handler_node(state: WorkOnIssueState) -> dict:
-    """Terminal error handler: log context and mark workflow as failed."""
+    """Terminal error handler: log context and mark workflow as failed or blocked.
+
+    Preserves ``status="blocked"`` when the incoming state already carries that
+    status (e.g., from ``planning_node``), so callers can distinguish a blocked
+    issue from a hard failure.
+    """
+    incoming_status = state.get("status")
+    final_status = "blocked" if incoming_status == "blocked" else "failed"
     return {
         "step": "error_handler",
-        "status": "failed",
+        "status": final_status,
         "error": state.get("error"),
         "events": [
             {
@@ -225,19 +245,15 @@ def error_handler_node(state: WorkOnIssueState) -> dict:
 def route_after_initiate(state: WorkOnIssueState) -> str:
     """Route based on initiate node outcome signals.
 
-    Priority: error → needs_setup → issue_retrieved → legacy fallback.
+    Priority: error → setup. ``initiate_node`` only performs pre-flight
+    validation; it does not fetch the issue. Setup must run before retrieval so
+    branch validation/creation is always applied, and can no-op when the branch
+    already targets the issue. ``issue_retrieved`` is deliberately NOT consulted
+    here — it is owned by ``retrieve_node`` and read by ``route_after_retrieve``.
     """
     if state.get("error"):
         return "error_handler"
-    if state.get("needs_setup"):
-        return "setup"
-    if state.get("issue_retrieved"):
-        return "planning"
-    # Legacy checkpoint fallback: pre-refactor states lack signal fields.
-    # The previous default was "planning" (no error meant success).
-    if "issue_retrieved" not in state and "needs_setup" not in state:
-        return "planning"
-    return "error_handler"
+    return "setup"
 
 
 def route_after_plan(state: WorkOnIssueState) -> str:
@@ -259,12 +275,26 @@ def route_after_plan(state: WorkOnIssueState) -> str:
 
 
 def route_after_setup(state: WorkOnIssueState) -> str:
-    """Route to ``planning`` when setup completes successfully."""
+    """Route to ``retrieve`` when setup completes successfully."""
     if state.get("error"):
         return "error_handler"
     if state.get("setup_complete"):
-        return "planning"
+        return "retrieve"
     if "setup_complete" not in state:
+        return "retrieve"
+    return "error_handler"
+
+
+def route_after_retrieve(state: WorkOnIssueState) -> str:
+    """Route to ``planning`` when issue retrieval succeeds.
+
+    Checks the ``issue_retrieved`` signal set by the retrieve node.
+    """
+    if state.get("error"):
+        return "error_handler"
+    if state.get("issue_retrieved"):
+        return "planning"
+    if "issue_retrieved" not in state:
         return "planning"
     return "error_handler"
 
@@ -315,13 +345,15 @@ def route_after_implementation_review(state: WorkOnIssueState) -> str:
 def route_after_verify(state: WorkOnIssueState) -> str:
     """Route back to ``implementation`` on retryable error, otherwise ``commit``.
 
-    Caps retry loops at :data:`MAX_RETRIES` to prevent infinite loops.
+    Caps retry loops at the policy-provided ``retry_budget`` when present,
+    otherwise falls back to :data:`MAX_RETRIES` for checkpoint compatibility.
     Routes to ``error_handler`` when retries are exhausted.
     """
     retry_count = _normalize_retry_count(state.get("retry_count", 0))
-    if state.get("error") and retry_count < MAX_RETRIES:
+    retry_budget = _normalize_retry_budget(state.get("retry_budget", MAX_RETRIES))
+    if state.get("error") and retry_count < retry_budget:
         return "implementation"
-    if state.get("error") and retry_count >= MAX_RETRIES:
+    if state.get("error") and retry_count >= retry_budget:
         return "error_handler"
     return "commit"
 

agentic_devtools/orchestration/runner.py

@@ -1,11 +1,14 @@
-"""LangGraph workflow runner for the work-on-jira-issue workflow.
+"""LangGraph workflow runner for the work-on-issue workflow.
 
 This module provides the entry point for running the LangGraph-based
-work-on-jira-issue workflow when ``--engine langchain`` is selected.
+work-on-issue workflow when ``--engine langchain`` is selected.
+It supports both Jira issue keys (e.g., PROJECT-1234) and GitHub issue
+numbers (e.g., #42).
 """
 
 import sys
 import uuid
+from pathlib import Path
 from typing import Any
 
 
@@ -17,14 +20,15 @@ def run_langchain_workflow(
     resume: bool = False,
     resume_data: dict | None = None,
 ) -> None:
-    """Run the LangGraph-based work-on-jira-issue workflow.
+    """Run the LangGraph-based work-on-issue workflow.
 
     This is invoked when ``--engine langchain`` (or ``--use-langchain``) is
     provided on the CLI.  It builds and invokes the compiled StateGraph with
-    real tool integrations.
+    real tool integrations.  Supports both Jira issue keys (e.g., PROJECT-1234)
+    and GitHub issue numbers (e.g., #42).
 
     Args:
-        issue_key: Jira issue key (e.g., PROJECT-1234).
+        issue_key: Jira issue key (e.g., PROJECT-1234) or GitHub issue number.
         interactive: Whether to start the Copilot session interactively.
         model: Copilot model to use.
         resume: Whether to resume from an existing checkpoint.
@@ -75,6 +79,9 @@ def run_langchain_workflow(
     # it even when get_checkpointer() raises before assignment.
     checkpointer = None
     try:
+        # Initialize infrastructure components for autonomous execution.
+        policy_state = _initialize_infrastructure(state_dir)
+
         # Initialize checkpointer after lock acquisition so the entire execution
         # (including checkpoint storage) is single-writer per thread scope.
         checkpointer = get_checkpointer()
@@ -154,7 +161,10 @@ def run_langchain_workflow(
                     "model": model,
                 },
                 "affected_paths": [],
+                "token_usage_prompt": 0,
+                "token_usage_completion": 0,
             }
+            initial_state.update(policy_state)
 
             print(f"[langchain] Starting workflow for {issue_key}...")
             try:
@@ -174,6 +184,12 @@ def run_langchain_workflow(
         # True completion.
         final_step = result.get("step", "unknown")
         final_status = result.get("status", "unknown")
+        if final_status in {"failed", "blocked"}:
+            print(
+                f"ERROR: Workflow terminated unsuccessfully: step={final_step}, status={final_status}",
+                file=sys.stderr,
+            )
+            sys.exit(1)
         print(f"[langchain] Workflow completed: step={final_step}, status={final_status}")
     finally:
         lock.release()
@@ -183,17 +199,54 @@ def run_langchain_workflow(
             checkpointer.conn.close()
 
 
+def _initialize_infrastructure(state_dir: Path | str) -> dict[str, int]:
+    """Initialize infrastructure components for autonomous workflow execution.
+
+    Loads policy values used by the workflow (token budget and retry budget)
+    and logs them for observability. Returns state defaults that should be
+    seeded into fresh workflow executions. If policy loading fails, emits a
+    warning and continues with runtime defaults.
+
+    Args:
+        state_dir: Path to the workflow state directory (str or Path).
+
+    Returns:
+        A mapping of policy-backed state defaults for fresh executions.
+    """
+    import sys
+
+    # Initialize PolicyLoader for budget enforcement
+    try:
+        from agentic_devtools.orchestration.policies.loader import PolicyLoader
+
+        loader = PolicyLoader()
+        policy = loader.load()
+        max_tokens = policy.shared.max_tokens
+        retry_budget = policy.work_on_issue.retry_budget
+        print(
+            f"[langchain] Policy loaded: state_dir={state_dir}, max_tokens={max_tokens}, retry_budget={retry_budget}",
+            file=sys.stderr,
+        )
+        return {"retry_budget": retry_budget}
+    except Exception as exc:
+        print(
+            f"[langchain] WARNING: Policy loading failed for state_dir={state_dir}, using defaults: {exc}",
+            file=sys.stderr,
+        )
+        return {}
+
+
 def _is_workflow_paused(result: object) -> bool:
-    """Return True if the workflow is paused (not completed).
+    """Return True if the workflow is paused and awaiting human input.
 
     When a LangGraph workflow with a checkpointer pauses at a human-in-the-loop
     gate node, ``invoke()`` returns the current state dict instead of raising
-    ``GraphInterrupt``.  This helper detects that situation by checking whether
-    the returned status is anything other than ``"completed"``.
+    ``GraphInterrupt``. This helper treats known terminal statuses as
+    non-paused and returns ``True`` only for active/in-progress states.
     """
     if not isinstance(result, dict):
         return True
-    return result.get("status") != "completed"
+    return result.get("status") not in {"completed", "failed", "blocked"}
 
 
 def _print_pause_message(issue_key: str) -> None: