claude-dev-env 4.2.0 → 7.0.0

package/.agents/skills/_shared/pr-loop/scripts/build_converge_task_list.py

@@ -1,310 +0,0 @@
-#!/usr/bin/env python3
-"""``build_converge_task_list.py`` — ordered review tasks for a run.
-
-Step 1 of autoconverge / portable pr-converge: call this script. Do not invent
-tasks in prose. The final task is always all runnable code reviews CLEAN on
-the same HEAD.
-
-::
-
-    python build_converge_task_list.py \\
-        [--bugbot-down 0|1] [--copilot-down 0|1] \\
-        [--codex-down 0|1] [--codex-required 0|1]
-
-Stdout JSON::
-
-    {
-      "tasks": [...],
-      "runnable_review_ids": [...],
-      "skipped_review_ids": [...],
-      "final_task_id": "all_runnable_reviews_clean_same_head",
-      "done_when": "..."
-    }
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from pathlib import Path
-
-_self_dir = Path(__file__).resolve().parent
-if str(_self_dir) not in sys.path:
-    sys.path.insert(0, str(_self_dir))
-
-from select_converge_pacer import parse_bool_flag  # noqa: E402
-from skills_pr_loop_constants.converge_task_list_constants import (  # noqa: E402
-    CLI_BUGBOT_DOWN_FLAG,
-    CLI_CODEX_DOWN_FLAG,
-    CLI_CODEX_REQUIRED_FLAG,
-    CLI_COPILOT_DOWN_FLAG,
-    DONE_WHEN_TEXT,
-    EXIT_SUCCESS,
-    EXIT_USAGE_ERROR,
-    RESULT_KEY_DONE_WHEN,
-    RESULT_KEY_FINAL_TASK_ID,
-    RESULT_KEY_RUNNABLE_REVIEW_IDS,
-    RESULT_KEY_SKIPPED_REVIEW_IDS,
-    RESULT_KEY_TASKS,
-    SKIP_REASON_BUGBOT_DOWN,
-    SKIP_REASON_CODEX_DOWN,
-    SKIP_REASON_CODEX_NOT_REQUIRED,
-    SKIP_REASON_COPILOT_DOWN,
-    TASK_FIELD_ID,
-    TASK_FIELD_IS_RUNNABLE,
-    TASK_FIELD_KIND,
-    TASK_FIELD_SKIP_REASON,
-    TASK_FIELD_TITLE,
-    TASK_ID_ALL_CLEAN_SAME_HEAD,
-    TASK_ID_BUGBOT,
-    TASK_ID_BUGTEAM,
-    TASK_ID_CODE_REVIEW,
-    TASK_ID_CODEX,
-    TASK_ID_COPILOT,
-    TASK_KIND_FINAL,
-    TASK_KIND_REVIEW,
-    TASK_TITLE_ALL_CLEAN_SAME_HEAD,
-    TASK_TITLE_BUGBOT,
-    TASK_TITLE_BUGTEAM,
-    TASK_TITLE_CODE_REVIEW,
-    TASK_TITLE_CODEX,
-    TASK_TITLE_COPILOT,
-)
-
-
-def _review_task(
-    *,
-    task_id: str,
-    title: str,
-    is_runnable: bool,
-    skip_reason: str | None,
-) -> dict[str, object]:
-    task: dict[str, object] = {
-        TASK_FIELD_ID: task_id,
-        TASK_FIELD_TITLE: title,
-        TASK_FIELD_KIND: TASK_KIND_REVIEW,
-        TASK_FIELD_IS_RUNNABLE: is_runnable,
-    }
-    if skip_reason is not None:
-        task[TASK_FIELD_SKIP_REASON] = skip_reason
-    return task
-
-
-def _append_always_runnable_reviews(
-    all_tasks: list[dict[str, object]],
-) -> None:
-    all_tasks.append(
-        _review_task(
-            task_id=TASK_ID_CODE_REVIEW,
-            title=TASK_TITLE_CODE_REVIEW,
-            is_runnable=True,
-            skip_reason=None,
-        )
-    )
-    all_tasks.append(
-        _review_task(
-            task_id=TASK_ID_BUGTEAM,
-            title=TASK_TITLE_BUGTEAM,
-            is_runnable=True,
-            skip_reason=None,
-        )
-    )
-
-
-def _append_bugbot_task(
-    all_tasks: list[dict[str, object]],
-    *,
-    is_bugbot_down: bool,
-) -> None:
-    if is_bugbot_down:
-        all_tasks.append(
-            _review_task(
-                task_id=TASK_ID_BUGBOT,
-                title=TASK_TITLE_BUGBOT,
-                is_runnable=False,
-                skip_reason=SKIP_REASON_BUGBOT_DOWN,
-            )
-        )
-        return
-    all_tasks.append(
-        _review_task(
-            task_id=TASK_ID_BUGBOT,
-            title=TASK_TITLE_BUGBOT,
-            is_runnable=True,
-            skip_reason=None,
-        )
-    )
-
-
-def _append_copilot_task(
-    all_tasks: list[dict[str, object]],
-    *,
-    is_copilot_down: bool,
-) -> None:
-    if is_copilot_down:
-        all_tasks.append(
-            _review_task(
-                task_id=TASK_ID_COPILOT,
-                title=TASK_TITLE_COPILOT,
-                is_runnable=False,
-                skip_reason=SKIP_REASON_COPILOT_DOWN,
-            )
-        )
-        return
-    all_tasks.append(
-        _review_task(
-            task_id=TASK_ID_COPILOT,
-            title=TASK_TITLE_COPILOT,
-            is_runnable=True,
-            skip_reason=None,
-        )
-    )
-
-
-def _append_codex_task(
-    all_tasks: list[dict[str, object]],
-    *,
-    is_codex_down: bool,
-    is_codex_required: bool,
-) -> None:
-    if is_codex_down:
-        all_tasks.append(
-            _review_task(
-                task_id=TASK_ID_CODEX,
-                title=TASK_TITLE_CODEX,
-                is_runnable=False,
-                skip_reason=SKIP_REASON_CODEX_DOWN,
-            )
-        )
-        return
-    if not is_codex_required:
-        all_tasks.append(
-            _review_task(
-                task_id=TASK_ID_CODEX,
-                title=TASK_TITLE_CODEX,
-                is_runnable=False,
-                skip_reason=SKIP_REASON_CODEX_NOT_REQUIRED,
-            )
-        )
-        return
-    all_tasks.append(
-        _review_task(
-            task_id=TASK_ID_CODEX,
-            title=TASK_TITLE_CODEX,
-            is_runnable=True,
-            skip_reason=None,
-        )
-    )
-
-
-def _append_final_task(all_tasks: list[dict[str, object]]) -> None:
-    all_tasks.append(
-        {
-            TASK_FIELD_ID: TASK_ID_ALL_CLEAN_SAME_HEAD,
-            TASK_FIELD_TITLE: TASK_TITLE_ALL_CLEAN_SAME_HEAD,
-            TASK_FIELD_KIND: TASK_KIND_FINAL,
-            TASK_FIELD_IS_RUNNABLE: True,
-        }
-    )
-
-
-def _partition_review_ids(
-    all_tasks: list[dict[str, object]],
-) -> tuple[list[str], list[str]]:
-    all_runnable_review_ids = [
-        str(each_task[TASK_FIELD_ID])
-        for each_task in all_tasks
-        if each_task[TASK_FIELD_KIND] == TASK_KIND_REVIEW
-        and each_task[TASK_FIELD_IS_RUNNABLE] is True
-    ]
-    all_skipped_review_ids = [
-        str(each_task[TASK_FIELD_ID])
-        for each_task in all_tasks
-        if each_task[TASK_FIELD_KIND] == TASK_KIND_REVIEW
-        and each_task[TASK_FIELD_IS_RUNNABLE] is False
-    ]
-    return all_runnable_review_ids, all_skipped_review_ids
-
-
-def build_converge_task_list(
-    *,
-    is_bugbot_down: bool,
-    is_copilot_down: bool,
-    is_codex_down: bool,
-    is_codex_required: bool,
-) -> dict[str, object]:
-    """Return the ordered task list and done criterion for one converge run.
-
-    Args:
-        is_bugbot_down: Skip Bugbot as a runnable review.
-        is_copilot_down: Skip Copilot as a runnable review.
-        is_codex_down: Skip Codex even when usage would require it.
-        is_codex_required: Weekly usage / policy requires a Codex review.
-
-    Returns:
-        JSON-serializable control object with ``tasks`` and ``done_when``.
-    """
-    all_tasks: list[dict[str, object]] = []
-    _append_always_runnable_reviews(all_tasks)
-    _append_bugbot_task(all_tasks, is_bugbot_down=is_bugbot_down)
-    _append_copilot_task(all_tasks, is_copilot_down=is_copilot_down)
-    _append_codex_task(
-        all_tasks,
-        is_codex_down=is_codex_down,
-        is_codex_required=is_codex_required,
-    )
-    _append_final_task(all_tasks)
-    all_runnable_review_ids, all_skipped_review_ids = _partition_review_ids(
-        all_tasks
-    )
-    return {
-        RESULT_KEY_TASKS: all_tasks,
-        RESULT_KEY_RUNNABLE_REVIEW_IDS: all_runnable_review_ids,
-        RESULT_KEY_SKIPPED_REVIEW_IDS: all_skipped_review_ids,
-        RESULT_KEY_FINAL_TASK_ID: TASK_ID_ALL_CLEAN_SAME_HEAD,
-        RESULT_KEY_DONE_WHEN: DONE_WHEN_TEXT,
-    }
-
-
-def build_argument_parser() -> argparse.ArgumentParser:
-    """Build the CLI parser for ``build_converge_task_list``.
-
-    Returns:
-        Configured argument parser.
-    """
-    parser = argparse.ArgumentParser(description="build_converge_task_list")
-    parser.add_argument(CLI_BUGBOT_DOWN_FLAG, default="0")
-    parser.add_argument(CLI_COPILOT_DOWN_FLAG, default="0")
-    parser.add_argument(CLI_CODEX_DOWN_FLAG, default="0")
-    parser.add_argument(CLI_CODEX_REQUIRED_FLAG, default="0")
-    return parser
-
-
-def main(all_argv: list[str]) -> int:
-    """CLI entry: print one task-list JSON object on stdout.
-
-    Args:
-        all_argv: Argument vector without program name.
-
-    Returns:
-        Process exit code.
-    """
-    parser = build_argument_parser()
-    parsed_arguments = parser.parse_args(all_argv)
-    try:
-        task_list_payload = build_converge_task_list(
-            is_bugbot_down=parse_bool_flag(parsed_arguments.bugbot_down),
-            is_copilot_down=parse_bool_flag(parsed_arguments.copilot_down),
-            is_codex_down=parse_bool_flag(parsed_arguments.codex_down),
-            is_codex_required=parse_bool_flag(parsed_arguments.codex_required),
-        )
-    except ValueError as validation_error:
-        print(str(validation_error), file=sys.stderr)
-        return EXIT_USAGE_ERROR
-    print(json.dumps(task_list_payload, sort_keys=True))
-    return EXIT_SUCCESS
-
-
-if __name__ == "__main__":
-    raise SystemExit(main(sys.argv[1:]))

package/.agents/skills/_shared/pr-loop/scripts/build_fix_prompt.py

@@ -1,292 +0,0 @@
-"""Emit the complete FIX spawn prompt XML to stdout.
-
-Populates <bug> entries from findings JSON, plus <execution> checklist
-and <constraints>. <comment_posting> and <output_format> follow
-``--flavor`` (agent or headless).
-
-Usage:
-  python scripts/build_fix_prompt.py --owner jl-cmd --repo claude-dev-env --pr-number 422 --loop 1 --head-ref feat/branch --base-ref main --worktree-path <PATH> --findings-json <PATH> [--flavor agent|headless]
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import sys
-from xml.etree.ElementTree import Element, SubElement
-from pathlib import Path
-
-_self_dir = Path(__file__).resolve().parent
-if str(_self_dir) not in sys.path:
-    sys.path.insert(0, str(_self_dir))
-
-from _cli_utils import require_file
-from _path_resolver import fix_outcome_xml_path
-from _xml_utils import emit_pretty_xml
-from skills_pr_loop_constants.path_resolver_constants import (
-    ALL_FIX_CONSTRAINT_TEXTS,
-    ALL_FIX_CONSTRAINT_TEXTS_HEADLESS,
-    ALL_FIX_EXECUTION_STEPS,
-    ALL_FIX_EXECUTION_STEPS_HEADLESS,
-    ALL_FIX_PROMPT_FLAVORS,
-    FINDINGS_JSON_MUST_BE_LIST_MESSAGE,
-    FIX_COMMENT_POSTING_AGENT_TEXT,
-    FIX_COMMENT_POSTING_HEADLESS_TEXT,
-    FIX_OUTPUT_FORMAT_AGENT_TEXT,
-    FIX_OUTPUT_FORMAT_HEADLESS_TEMPLATE,
-    FIX_PROMPT_FLAVOR_AGENT,
-    FIX_PROMPT_FLAVOR_HEADLESS,
-)
-
-
-def _comment_posting_text(flavor: str) -> str:
-    """Return the <comment_posting> body for the given prompt flavor.
-
-    Args:
-        flavor: ``agent`` or ``headless`` prompt flavor.
-
-    Returns:
-        Comment-posting instruction text for that flavor.
-    """
-    if flavor == FIX_PROMPT_FLAVOR_HEADLESS:
-        return FIX_COMMENT_POSTING_HEADLESS_TEXT
-    return FIX_COMMENT_POSTING_AGENT_TEXT
-
-
-def _format_instruction_text(
-    *,
-    flavor: str,
-    worktree_path: Path,
-    pr_number: int,
-    loop: int,
-) -> str:
-    """Return the <output_format> body for the given prompt flavor.
-
-    Args:
-        flavor: ``agent`` or ``headless`` prompt flavor.
-        worktree_path: Path to the git worktree.
-        pr_number: Pull request number.
-        loop: Loop iteration number.
-
-    Returns:
-        Format-instruction text for that flavor.
-    """
-    if flavor == FIX_PROMPT_FLAVOR_HEADLESS:
-        outcome_path = fix_outcome_xml_path(worktree_path, pr_number, loop)
-        return FIX_OUTPUT_FORMAT_HEADLESS_TEMPLATE.format(
-            outcome_path=outcome_path.as_posix(),
-        )
-    return FIX_OUTPUT_FORMAT_AGENT_TEXT
-
-
-def _all_execution_steps(flavor: str) -> list[str]:
-    """Return the execution checklist for the given prompt flavor.
-
-    Args:
-        flavor: ``agent`` or ``headless`` prompt flavor.
-
-    Returns:
-        Ordered execution step texts for that flavor.
-    """
-    if flavor == FIX_PROMPT_FLAVOR_HEADLESS:
-        return list(ALL_FIX_EXECUTION_STEPS_HEADLESS)
-    return list(ALL_FIX_EXECUTION_STEPS)
-
-
-def _all_constraint_texts(flavor: str) -> list[str]:
-    """Return the constraint texts for the given prompt flavor.
-
-    Args:
-        flavor: ``agent`` or ``headless`` prompt flavor.
-
-    Returns:
-        Ordered constraint texts for that flavor.
-    """
-    if flavor == FIX_PROMPT_FLAVOR_HEADLESS:
-        return list(ALL_FIX_CONSTRAINT_TEXTS_HEADLESS)
-    return list(ALL_FIX_CONSTRAINT_TEXTS)
-
-
-def build_fix_prompt_xml(
-    *,
-    owner: str,
-    repo: str,
-    pr_number: int,
-    loop: int,
-    head_ref: str,
-    base_ref: str,
-    worktree_path: Path,
-    findings_json_path: Path,
-    flavor: str = FIX_PROMPT_FLAVOR_AGENT,
-) -> Element:
-    """Build the complete FIX spawn prompt XML.
-
-    Args:
-        owner: GitHub repository owner.
-        repo: GitHub repository name.
-        pr_number: Pull request number.
-        loop: Loop iteration number.
-        head_ref: Head branch ref.
-        base_ref: Base branch ref.
-        worktree_path: Path to the git worktree.
-        findings_json_path: Path to the findings JSON file.
-        flavor: Prompt flavor — ``agent`` (in-agent commit/post) or
-            ``headless`` (outcome file, lead-owned commit/post).
-
-    Returns:
-        Root <spawn_prompt> element.
-    """
-    findings_data = json.loads(findings_json_path.read_text(encoding="utf-8"))
-    if not isinstance(findings_data, list):
-        findings_type_name = type(findings_data).__name__
-        raise TypeError(
-            FINDINGS_JSON_MUST_BE_LIST_MESSAGE % findings_type_name
-        )
-
-    root = Element("spawn_prompt", {"role": "fix", "loop": str(loop)})
-
-    context = SubElement(root, "context")
-    SubElement(context, "owner").text = owner
-    SubElement(context, "repo").text = repo
-    SubElement(context, "pr_number").text = str(pr_number)
-    SubElement(context, "head_ref").text = head_ref
-    SubElement(context, "base_ref").text = base_ref
-    SubElement(context, "worktree_path").text = worktree_path.as_posix()
-
-    bugs_elem = SubElement(root, "bugs")
-    for each_finding in findings_data:
-        if isinstance(each_finding, dict):
-            bug = SubElement(bugs_elem, "bug")
-            for each_key, each_field_detail in each_finding.items():
-                child = SubElement(bug, each_key)
-                child.text = (
-                    str(each_field_detail) if each_field_detail is not None else ""
-                )
-
-    execution = SubElement(root, "execution")
-    for each_step in _all_execution_steps(flavor):
-        SubElement(execution, "step").text = each_step
-
-    constraints = SubElement(root, "constraints")
-    for each_constraint in _all_constraint_texts(flavor):
-        SubElement(constraints, "constraint").text = each_constraint
-
-    comment_posting = SubElement(root, "comment_posting")
-    comment_posting.text = _comment_posting_text(flavor)
-
-    format_section = SubElement(root, "output_format")
-    format_section.text = _format_instruction_text(
-        flavor=flavor,
-        worktree_path=worktree_path,
-        pr_number=pr_number,
-        loop=loop,
-    )
-
-    return root
-
-
-def emit_fix_prompt(
-    *,
-    owner: str,
-    repo: str,
-    pr_number: int,
-    loop: int,
-    head_ref: str,
-    base_ref: str,
-    worktree_path: Path,
-    findings_json_path: Path,
-    flavor: str = FIX_PROMPT_FLAVOR_AGENT,
-) -> str:
-    """Build and serialize the FIX spawn prompt to a pretty-printed XML string.
-
-    Args:
-        owner: GitHub repository owner.
-        repo: GitHub repository name.
-        pr_number: Pull request number.
-        loop: Loop iteration number.
-        head_ref: Head branch ref.
-        base_ref: Base branch ref.
-        worktree_path: Path to the git worktree.
-        findings_json_path: Path to the findings JSON file.
-        flavor: Prompt flavor — ``agent`` or ``headless``.
-
-    Returns:
-        Pretty-printed XML string.
-    """
-    root = build_fix_prompt_xml(
-        owner=owner,
-        repo=repo,
-        pr_number=pr_number,
-        loop=loop,
-        head_ref=head_ref,
-        base_ref=base_ref,
-        worktree_path=worktree_path,
-        findings_json_path=findings_json_path,
-        flavor=flavor,
-    )
-    return emit_pretty_xml(root)
-
-
-def parse_arguments(all_argv: list[str]) -> argparse.Namespace:
-    """Parse command-line arguments.
-
-    Args:
-        all_argv: Command-line argument list.
-
-    Returns:
-        Parsed namespace with all required fix prompt parameters.
-    """
-    parser = argparse.ArgumentParser(description=__doc__)
-    parser.add_argument("--owner", required=True)
-    parser.add_argument("--repo", required=True)
-    parser.add_argument("--pr-number", type=int, required=True)
-    parser.add_argument("--loop", type=int, required=True)
-    parser.add_argument("--head-ref", required=True)
-    parser.add_argument("--base-ref", required=True)
-    parser.add_argument("--worktree-path", type=Path, required=True)
-    parser.add_argument("--findings-json", type=Path, required=True)
-    parser.add_argument(
-        "--flavor",
-        choices=sorted(ALL_FIX_PROMPT_FLAVORS),
-        default=FIX_PROMPT_FLAVOR_AGENT,
-    )
-    return parser.parse_args(all_argv)
-
-
-def main(all_arguments: list[str]) -> int:
-    """Entry point: emit FIX spawn prompt XML to stdout.
-
-    Args:
-        all_arguments: Command-line arguments.
-
-    Returns:
-        0 on success, 1 on failure.
-    """
-    arguments = parse_arguments(all_arguments)
-    findings_path = getattr(arguments, "findings_json")
-
-    early_exit = require_file(findings_path, "findings-json")
-    if early_exit is not None:
-        return early_exit
-
-    try:
-        xml_output = emit_fix_prompt(
-            owner=arguments.owner,
-            repo=arguments.repo,
-            pr_number=getattr(arguments, "pr_number"),
-            loop=arguments.loop,
-            head_ref=getattr(arguments, "head_ref"),
-            base_ref=getattr(arguments, "base_ref"),
-            worktree_path=getattr(arguments, "worktree_path"),
-            findings_json_path=findings_path,
-            flavor=arguments.flavor,
-        )
-    except (json.JSONDecodeError, OSError, TypeError) as exc:
-        print(f"emit_fix_prompt failed: {exc}", file=sys.stderr)
-        return 1
-    sys.stdout.write(xml_output)
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main(sys.argv[1:]))