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

agentic_devtools/orchestration/nodes/completion.py

@@ -0,0 +1,163 @@
+"""Completion node: post summary comment and finalize workflow.
+
+Builds a completion comment with work summary, PR link, completed
+checklist items, and token usage. Posts to the appropriate platform.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from agentic_devtools.cli.github.repo_resolution import resolve_github_repo_safe
+from agentic_devtools.orchestration.nodes._helpers import (
+    _to_nonneg_int,
+    detect_issue_provider,
+    normalize_issue_key,
+    run_command,
+    utc_now,
+)
+from agentic_devtools.orchestration.state_schema import WorkOnIssueState
+
+
+def completion_node(state: WorkOnIssueState) -> dict[str, Any]:
+    """Post completion comment and mark workflow as done.
+
+    Builds a summary with PR link, checklist results, and token usage.
+    Posts to Jira or GitHub depending on the issue provider.
+
+    Fails fast when ``issue_key`` is missing, blank, or not a string so a
+    corrupted/resumed checkpoint cannot raise ``AttributeError`` inside
+    ``detect_issue_provider()`` or ``normalize_issue_key()``.
+    """
+    issue_key = state.get("issue_key", "")
+    if not isinstance(issue_key, str) or not issue_key.strip():
+        return {
+            "step": "completion",
+            "status": "failed",
+            "error": "issue_key is required and must be a non-empty string",
+            "events": [
+                {
+                    "event": "completion_failed",
+                    "timestamp": utc_now(),
+                    "signals": {"error": "missing_issue_key"},
+                }
+            ],
+        }
+    issue_key = issue_key.strip()
+    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)
+    )
+    pr_url = state.get("pr_url", "")
+    checklist_items = state.get("checklist_items", [])
+    token_usage_prompt = state.get("token_usage_prompt", 0)
+    token_usage_completion = state.get("token_usage_completion", 0)
+
+    # Build completion comment
+    comment = _build_completion_comment(
+        issue_key=issue_key,
+        pr_url=pr_url,
+        checklist_items=checklist_items if isinstance(checklist_items, list) else [],
+        token_usage_prompt=_to_nonneg_int(token_usage_prompt),
+        token_usage_completion=_to_nonneg_int(token_usage_completion),
+        issue_provider=issue_provider,
+    )
+
+    # Post comment to appropriate platform
+    if issue_provider == "jira":
+        _post_jira_comment(issue_key, comment)
+    else:
+        _post_github_comment(issue_key, comment)
+
+    return {
+        "step": "completion",
+        "status": "completed",
+        "events": [
+            {
+                "event": "completion_completed",
+                "timestamp": utc_now(),
+                "signals": {"pr_url": pr_url},
+            }
+        ],
+    }
+
+
+def _build_completion_comment(
+    *,
+    issue_key: str,
+    pr_url: str,
+    checklist_items: list[Any],
+    token_usage_prompt: int,
+    token_usage_completion: int,
+    issue_provider: str = "jira",
+) -> str:
+    """Build the completion comment text."""
+    is_github = issue_provider == "github"
+    lines = ["#### Autonomous Implementation Complete" if is_github else "h4. Autonomous Implementation Complete"]
+    lines.append("")
+
+    if pr_url:
+        lines.append(f"**Pull Request**: {pr_url}" if is_github else f"*Pull Request*: {pr_url}")
+    else:
+        lines.append("**Pull Request**: Created (see branch)" if is_github else "*Pull Request*: Created (see branch)")
+
+    lines.append("")
+
+    # Checklist summary
+    completed = sum(1 for item in checklist_items if isinstance(item, dict) and item.get("is_complete"))
+    total = len([item for item in checklist_items if isinstance(item, dict)])
+    lines.append(
+        f"**Checklist**: {completed}/{total} items completed"
+        if is_github
+        else f"*Checklist*: {completed}/{total} items completed"
+    )
+    lines.append("")
+
+    # Token usage
+    total_tokens = token_usage_prompt + token_usage_completion
+    lines.append("**Token Usage**:" if is_github else "*Token Usage*:")
+    lines.append(f"- Prompt tokens: {token_usage_prompt:,}")
+    lines.append(f"- Completion tokens: {token_usage_completion:,}")
+    lines.append(f"- Total tokens: {total_tokens:,}")
+
+    lines.append("")
+    lines.append("_Generated by LangChain work-on-issue workflow_")
+
+    return "\n".join(lines)
+
+
+def _post_jira_comment(issue_key: str, comment: str) -> None:
+    """Post completion comment to Jira."""
+    issue_result = run_command(["agdt-set", "jira.issue_key", issue_key])
+    if issue_result.returncode != 0:
+        return
+
+    comment_result = run_command(["agdt-set", "jira.comment", comment])
+    if comment_result.returncode != 0:
+        return
+
+    add_result = run_command(["agdt-add-jira-comment"])
+    if add_result.returncode == 0:
+        run_command(["agdt-task-wait"], timeout=60)
+
+
+def _post_github_comment(issue_key: str, comment: str) -> None:
+    """Post completion comment to GitHub."""
+    try:
+        from agentic_devtools.adapters.github_adapter import GitHubIssuesAdapter
+
+        repo = resolve_github_repo_safe()
+        if not repo:
+            return
+
+        normalized_issue_key = normalize_issue_key(issue_key)
+        if not normalized_issue_key:
+            return
+
+        adapter = GitHubIssuesAdapter(repo=repo)
+        adapter.add_comment(normalized_issue_key, comment)
+    except Exception:
+        # Best-effort: don't fail the workflow if comment posting fails
+        pass

agentic_devtools/orchestration/nodes/implementation.py

@@ -0,0 +1,395 @@
+"""Implementation node: TDD RED/GREEN cycle for each checklist item.
+
+Iterates over incomplete checklist items, performing for each:
+1. RED: Generate a failing test via LLM
+2. GREEN: Generate implementation code via LLM
+3. VERIFY: Run tests to confirm they pass
+
+Uses repository context discovery to inform LLM prompts.
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+from agentic_devtools.orchestration.execution.context_factory import _run_async
+from agentic_devtools.orchestration.nodes._helpers import (
+    _to_nonneg_int,
+    detect_test_conventions,
+    read_file_content,
+    run_command,
+    scan_directory_structure,
+    utc_now,
+)
+from agentic_devtools.orchestration.state_schema import WorkOnIssueState
+
+
+def implementation_node(state: WorkOnIssueState) -> dict[str, Any]:
+    """Execute TDD cycle for each incomplete checklist item.
+
+    Iterates over checklist items, generating tests (RED) and implementation
+    (GREEN) for each. Verifies with ``agdt-test-pattern``.
+    """
+    checklist_items = state.get("checklist_items", [])
+    if not isinstance(checklist_items, list):
+        checklist_items = []
+
+    raw_log = state.get("implementation_log", [])
+    implementation_log: list[dict[str, Any]] = raw_log if isinstance(raw_log, list) else []
+    raw_paths = state.get("affected_paths", [])
+    affected_paths: list[str] = (
+        [str(p) for p in raw_paths if not isinstance(p, bool)] if isinstance(raw_paths, list) else []
+    )
+    error_message: str | None = None
+    accumulated_prompt = 0
+    accumulated_completion = 0
+
+    # Process each incomplete item
+    for i, item in enumerate(checklist_items):
+        if not isinstance(item, dict):
+            continue
+        if item.get("is_complete"):
+            continue
+
+        try:
+            result = _implement_checklist_item(item, i, state)
+        except Exception as exc:
+            error_message = f"Implementation failed for item {i}: {exc}"
+            implementation_log.append(
+                {
+                    "item_index": i,
+                    "status": "failed",
+                    "error": str(exc),
+                    "timestamp": utc_now(),
+                }
+            )
+            break
+
+        accumulated_prompt += _to_nonneg_int(result.get("token_usage_prompt"))
+        accumulated_completion += _to_nonneg_int(result.get("token_usage_completion"))
+
+        if result.get("error"):
+            error_message = result["error"]
+            implementation_log.append(
+                {
+                    "item_index": i,
+                    "status": "failed",
+                    "error": error_message,
+                    "timestamp": utc_now(),
+                }
+            )
+            break
+
+        # Mark item as complete
+        checklist_items[i] = {**item, "is_complete": True}
+        affected_paths.extend(result.get("affected_paths", []))
+        implementation_log.append(
+            {
+                "item_index": i,
+                "status": "completed",
+                "affected_paths": result.get("affected_paths", []),
+                "timestamp": utc_now(),
+            }
+        )
+
+    # Determine if all items are complete. A checklist with no valid (dict) items —
+    # an empty list, a non-list value coerced to [], or only corrupted non-dict
+    # entries — must NOT be treated as complete: ``all(...)`` over an empty
+    # generator returns True, which would let the workflow skip implementation
+    # entirely and proceed as if the work were done.
+    dict_items = [item for item in checklist_items if isinstance(item, dict)]
+    all_complete = bool(dict_items) and all(item.get("is_complete", False) for item in dict_items)
+    if not dict_items:
+        error_message = "No valid checklist items to implement; cannot mark implementation complete."
+
+    return {
+        "step": "implementation",
+        "error": error_message if not all_complete and error_message else None,
+        "checklist_items": checklist_items,
+        "checklist_complete": all_complete,
+        "implementation_log": implementation_log,
+        "affected_paths": affected_paths,
+        "token_usage_prompt": _to_nonneg_int(state.get("token_usage_prompt")) + accumulated_prompt,
+        "token_usage_completion": _to_nonneg_int(state.get("token_usage_completion")) + accumulated_completion,
+        "events": [
+            {
+                "event": "implementation_completed" if all_complete else "implementation_partial",
+                "timestamp": utc_now(),
+                "signals": {"checklist_complete": all_complete, "error": error_message},
+            }
+        ],
+    }
+
+
+def _implement_checklist_item(
+    item: dict[str, Any],
+    index: int,
+    state: WorkOnIssueState,
+) -> dict[str, Any]:
+    """Implement a single checklist item using TDD cycle.
+
+    Returns dict with affected_paths list, accumulated token usage counts,
+    or an error string.
+    """
+    issue_key = state.get("issue_key", "")
+    plan = state.get("plan", "")
+    description = item.get("description", "")
+
+    # Discover repository context
+    repo_root = _get_repo_root()
+    if repo_root is None:
+        return {"error": "Cannot determine repository root"}
+
+    context = _build_context(repo_root)
+    prompt_tokens = 0
+    completion_tokens = 0
+
+    # RED phase: generate failing test
+    test_result = _generate_test(description, plan, context, issue_key, repo_root)
+    test_usage = test_result.get("token_usage", {})
+    prompt_tokens += _to_nonneg_int(test_usage.get("prompt_tokens"))
+    completion_tokens += _to_nonneg_int(test_usage.get("completion_tokens"))
+    if test_result.get("error"):
+        return {
+            "error": f"RED phase failed: {test_result['error']}",
+            "token_usage_prompt": prompt_tokens,
+            "token_usage_completion": completion_tokens,
+        }
+
+    test_path = test_result.get("path", "")
+    affected = [test_path] if test_path else []
+
+    # RED verification: confirm the generated test actually fails before writing implementation.
+    # A test that immediately passes either has no real assertions or the behavior already exists.
+    # pytest exit code 1 means "tests ran and at least one failed" — the expected outcome for a
+    # properly-written RED-phase test.  Any other non-zero code (2 = usage/syntax error,
+    # 3 = internal error, 4/5 = no tests collected) indicates a broken test file.
+    if test_path:
+        red_verify = run_command(
+            ["agdt-test-pattern", test_path, "-v", "-o", "addopts="],
+            timeout=120,
+        )
+        if red_verify.returncode == 0:
+            return {
+                "error": (
+                    f"RED phase failed: generated test already passes before implementation; "
+                    f"the behavior may already exist or the test has no real assertions ({test_path})"
+                ),
+                "token_usage_prompt": prompt_tokens,
+                "token_usage_completion": completion_tokens,
+            }
+        if red_verify.returncode != 1:
+            # Not a clean test failure — exit codes 2+ indicate broken generated test
+            # (2 = usage/syntax error, 3 = internal error, 4 = pytest usage error, 5 = no tests collected).
+            return {
+                "error": (
+                    f"RED phase failed: generated test is invalid "
+                    f"(pytest exit {red_verify.returncode}); "
+                    f"expected exit code 1 (test failures) but got a collection or syntax error. "
+                    f"Output: {red_verify.stderr[:500]}"
+                ),
+                "token_usage_prompt": prompt_tokens,
+                "token_usage_completion": completion_tokens,
+            }
+
+    # GREEN phase: generate implementation
+    impl_result = _generate_implementation(description, plan, context, test_path, issue_key, repo_root)
+    impl_usage = impl_result.get("token_usage", {})
+    prompt_tokens += _to_nonneg_int(impl_usage.get("prompt_tokens"))
+    completion_tokens += _to_nonneg_int(impl_usage.get("completion_tokens"))
+    if impl_result.get("error"):
+        return {
+            "error": f"GREEN phase failed: {impl_result['error']}",
+            "token_usage_prompt": prompt_tokens,
+            "token_usage_completion": completion_tokens,
+        }
+
+    impl_path = impl_result.get("path", "")
+    if impl_path:
+        affected.append(impl_path)
+
+    # VERIFY: run tests
+    if test_path:
+        verify_result = run_command(
+            ["agdt-test-pattern", test_path, "-v", "-o", "addopts="],
+            timeout=120,
+        )
+        if verify_result.returncode != 0:
+            return {
+                "error": f"VERIFY phase failed: tests did not pass\n{verify_result.stdout}\n{verify_result.stderr}",
+                "token_usage_prompt": prompt_tokens,
+                "token_usage_completion": completion_tokens,
+            }
+
+    return {
+        "affected_paths": affected,
+        "token_usage_prompt": prompt_tokens,
+        "token_usage_completion": completion_tokens,
+    }
+
+
+def _get_repo_root() -> Path | None:
+    """Get the repository root path."""
+    result = run_command(["git", "rev-parse", "--show-toplevel"])
+    if result.returncode != 0:
+        return None
+    return Path(result.stdout.strip())
+
+
+def _build_context(repo_root: Path) -> dict[str, Any]:
+    """Build repository context for LLM prompts."""
+    structure = scan_directory_structure(repo_root, max_depth=2)
+    conventions = detect_test_conventions(repo_root)
+    return {
+        "structure": structure[:100],  # Limit to avoid token overflow
+        "conventions": conventions,
+    }
+
+
+def _resolve_output_path(repo_root: Path, file_path: str) -> Path:
+    """Resolve an LLM-provided output path within repository bounds."""
+    candidate = Path(file_path)
+    if candidate.is_absolute():
+        raise ValueError(f"Absolute paths are not allowed: {file_path}")
+
+    resolved = (repo_root / candidate).resolve()
+    repo_root_resolved = repo_root.resolve()
+
+    try:
+        resolved.relative_to(repo_root_resolved)
+    except ValueError as exc:
+        raise ValueError(f"Path traversal is not allowed: {file_path}") from exc
+
+    return resolved
+
+
+def _generate_test(
+    description: str,
+    plan: str,
+    context: dict[str, Any],
+    issue_key: str,
+    repo_root: Path,
+) -> dict[str, Any]:
+    """Generate a failing test file via LLM (RED phase)."""
+    from agentic_devtools.orchestration.llm.factory import ProviderFactory
+
+    factory = ProviderFactory()
+    provider = factory.get_provider("implementation", "work_on_issue")
+
+    conventions = context.get("conventions", {})
+    test_layout = conventions.get("test_layout", "1:1:1")
+
+    system_prompt = (
+        "You are a test-driven development assistant. Generate a Python test file "
+        "that will initially FAIL (RED phase of TDD). The test should verify the "
+        "expected behavior described in the checklist item.\n\n"
+        f"Test layout convention: {test_layout}\n"
+        "Follow pytest conventions. Include only the test code, no explanations.\n"
+        'Respond with JSON: {"file_path": "relative/path.py", "content": "..."}'
+    )
+
+    user_prompt = f"Issue: {issue_key}\nChecklist item: {description}\nPlan context: {plan[:2000]}"
+
+    async def _call():
+        from agentic_devtools.orchestration.llm.types import LLMMessage
+
+        messages = [
+            LLMMessage(role="system", content=system_prompt),
+            LLMMessage(role="user", content=user_prompt),
+        ]
+        return await provider.complete(messages)
+
+    token_usage: dict[str, int] = {}
+    try:
+        response = _run_async(_call())
+        if response.usage:
+            token_usage = {
+                "prompt_tokens": response.usage.input_tokens,
+                "completion_tokens": response.usage.output_tokens,
+            }
+        parsed = json.loads(response.text)
+        if not isinstance(parsed, dict):
+            return {"error": "LLM did not produce valid test file output", "token_usage": token_usage}
+        file_path = parsed.get("file_path", "")
+        content = parsed.get("content", "")
+
+        if file_path and content:
+            full_path = _resolve_output_path(repo_root, file_path)
+            full_path.parent.mkdir(parents=True, exist_ok=True)
+            full_path.write_text(content, encoding="utf-8")
+            return {"path": file_path, "token_usage": token_usage}
+
+        return {"error": "LLM did not produce valid test file output", "token_usage": token_usage}
+    except Exception as exc:
+        return {"error": str(exc), "token_usage": token_usage}
+
+
+def _generate_implementation(
+    description: str,
+    plan: str,
+    context: dict[str, Any],
+    test_path: str,
+    issue_key: str,
+    repo_root: Path,
+) -> dict[str, Any]:
+    """Generate implementation code via LLM (GREEN phase)."""
+    from agentic_devtools.orchestration.llm.factory import ProviderFactory
+
+    factory = ProviderFactory()
+    provider = factory.get_provider("implementation", "work_on_issue")
+
+    # Read the test file for context
+    test_content = ""
+    if test_path:
+        test_full_path = repo_root / test_path
+        if test_full_path.exists():
+            test_content = read_file_content(test_full_path)
+
+    system_prompt = (
+        "You are an implementation assistant. Generate Python source code that makes "
+        "the provided failing test pass (GREEN phase of TDD). Write minimal code "
+        "to satisfy the test assertions.\n\n"
+        'Respond with JSON: {"file_path": "relative/path.py", "content": "..."}'
+    )
+
+    user_prompt = (
+        f"Issue: {issue_key}\n"
+        f"Checklist item: {description}\n"
+        f"Test file ({test_path}):\n{test_content}\n"
+        f"Plan context: {plan[:1000]}"
+    )
+
+    async def _call():
+        from agentic_devtools.orchestration.llm.types import LLMMessage
+
+        messages = [
+            LLMMessage(role="system", content=system_prompt),
+            LLMMessage(role="user", content=user_prompt),
+        ]
+        return await provider.complete(messages)
+
+    token_usage: dict[str, int] = {}
+    try:
+        response = _run_async(_call())
+        if response.usage:
+            token_usage = {
+                "prompt_tokens": response.usage.input_tokens,
+                "completion_tokens": response.usage.output_tokens,
+            }
+        parsed = json.loads(response.text)
+        if not isinstance(parsed, dict):
+            return {"error": "LLM did not produce valid implementation output", "token_usage": token_usage}
+        file_path = parsed.get("file_path", "")
+        content = parsed.get("content", "")
+
+        if file_path and content:
+            full_path = _resolve_output_path(repo_root, file_path)
+            full_path.parent.mkdir(parents=True, exist_ok=True)
+            full_path.write_text(content, encoding="utf-8")
+            return {"path": file_path, "token_usage": token_usage}
+
+        return {"error": "LLM did not produce valid implementation output", "token_usage": token_usage}
+    except Exception as exc:
+        return {"error": str(exc), "token_usage": token_usage}

agentic_devtools/orchestration/nodes/implementation_review.py

@@ -0,0 +1,126 @@
+"""Implementation review node: self-review generated code for quality.
+
+Scans generated code for debug statements (breakpoint, pdb, debug prints)
+and TODO/FIXME/HACK/XXX markers. Routes back to implementation
+if issues are found.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+from typing import Any
+
+from agentic_devtools.orchestration.nodes._helpers import run_command, utc_now
+from agentic_devtools.orchestration.state_schema import WorkOnIssueState
+
+# Patterns that indicate leftover debug code
+_DEBUG_PATTERNS = [
+    re.compile(r"\bbreakpoint\(\)"),
+    re.compile(r"\bpdb\.set_trace\(\)"),
+    re.compile(r"\bprint\(.*(debug|DEBUG)"),
+    re.compile(r"\bimport pdb\b"),
+    re.compile(r"\bimport ipdb\b"),
+]
+
+_TODO_PATTERN = re.compile(r"\b(TODO|FIXME|HACK|XXX)\b", re.IGNORECASE)
+
+
+def implementation_review_node(state: WorkOnIssueState) -> dict[str, Any]:
+    """Review generated code for quality issues.
+
+    Checks for debug statements, TODO/FIXME markers, and other
+    quality concerns. Sets error to route back to implementation
+    if issues are found.
+    """
+    raw_paths = state.get("affected_paths", [])
+    affected_paths: list[str] = (
+        [str(p) for p in raw_paths if not isinstance(p, bool)] if isinstance(raw_paths, list) else []
+    )
+    issues: list[str] = []
+
+    # Get repo root
+    result = run_command(["git", "rev-parse", "--show-toplevel"])
+    if result.returncode != 0:
+        return {
+            "step": "implementation_review",
+            "error": None,
+            "verification_ready": True,
+            "events": [
+                {
+                    "event": "implementation_review_completed",
+                    "timestamp": utc_now(),
+                    "signals": {"verification_ready": True, "skipped": "no_repo_root"},
+                }
+            ],
+        }
+
+    repo_root = Path(result.stdout.strip()).resolve()
+
+    # Scan each affected file
+    for path_str in affected_paths:
+        # Resolve the joined path and verify it stays inside the repository.
+        # A corrupted path containing ".." segments would otherwise escape
+        # repo_root and could expose arbitrary files outside the repository.
+        # Path.resolve() uses strict=False by default so it never raises OSError;
+        # relative_to() raises ValueError when the path escapes repo_root.
+        try:
+            file_path = (repo_root / path_str).resolve()
+            file_path.relative_to(repo_root)
+        except ValueError:
+            continue
+        if not file_path.exists() or not file_path.is_file():
+            continue
+        if not path_str.endswith(".py"):
+            continue
+
+        try:
+            content = file_path.read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+
+        file_issues = _scan_file(path_str, content)
+        issues.extend(file_issues)
+
+    if issues:
+        error_msg = "Implementation review found issues:\n" + "\n".join(f"- {i}" for i in issues)
+        return {
+            "step": "implementation_review",
+            "error": error_msg,
+            "verification_ready": False,
+            "events": [
+                {
+                    "event": "implementation_review_issues_found",
+                    "timestamp": utc_now(),
+                    "signals": {"issue_count": len(issues)},
+                }
+            ],
+        }
+
+    return {
+        "step": "implementation_review",
+        "error": None,
+        "verification_ready": True,
+        "events": [
+            {
+                "event": "implementation_review_completed",
+                "timestamp": utc_now(),
+                "signals": {"verification_ready": True},
+            }
+        ],
+    }
+
+
+def _scan_file(path: str, content: str) -> list[str]:
+    """Scan a single file for quality issues."""
+    issues: list[str] = []
+
+    for line_num, line in enumerate(content.splitlines(), 1):
+        for pattern in _DEBUG_PATTERNS:
+            if pattern.search(line):
+                issues.append(f"{path}:{line_num}: Debug statement found: {line.strip()}")
+
+        if _TODO_PATTERN.search(line):
+            issues.append(f"{path}:{line_num}: TODO/FIXME marker: {line.strip()}")
+
+    return issues