agentic-dev 0.2.2 → 0.2.4

package/.codex/skills/otro/scripts/check_validation_header.py

@@ -1,84 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import os
-import re
-import sys
-from typing import List
-
-DEFAULT_PATH = ".codex/skills/otro/validation/validation.md"
-EXPECTED_KEYS: List[str] = ["Status", "Last updated"]
-TOP_LINES_DEFAULT = int(os.environ.get("CHECK_HEADER_TOP_LINES", "30"))
-
-LINE_PATTERNS = {
-    # Accept forms like:
-    #   Status: value
-    #   | Status | value |
-    #   - Status: value
-    #   * Status: value
-    #   > Status: value
-    #   Status | value
-    key: re.compile(rf"^\s*(?:[|>*-]\s*)?{re.escape(key)}\s*(?::|\|)", re.UNICODE)
-    for key in EXPECTED_KEYS
-}
-
-
-def load_lines(path: str, top_n: int) -> List[str]:
-    with open(path, "r", encoding="utf-8") as f:
-        return [next(f) for _ in range(top_n)]
-
-
-def find_keys(lines: List[str]):
-    found = {}
-    for key, pat in LINE_PATTERNS.items():
-        hit = None
-        for idx, line in enumerate(lines, start=1):
-            if pat.search(line):
-                hit = (idx, line.rstrip("\n"))
-                break
-        found[key] = hit
-    return found
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Guard validation.md header keys against drift")
-    parser.add_argument("--file", default=DEFAULT_PATH, help="Path to validation.md (default: %(default)s)")
-    parser.add_argument("--top", type=int, default=TOP_LINES_DEFAULT, help="Number of top lines to scan (default: %(default)s)")
-    args = parser.parse_args()
-
-    path = args.file
-    top_n = args.top
-
-    if not os.path.isfile(path):
-        print(f"::error file={path},title=validation.md missing::File not found", file=sys.stderr)
-        return 2
-
-    try:
-        lines = load_lines(path, top_n)
-    except StopIteration:
-        # File shorter than requested; still use what we have
-        with open(path, "r", encoding="utf-8") as f:
-            lines = f.readlines()
-
-    found = find_keys(lines)
-
-    missing = [k for k, v in found.items() if v is None]
-    if missing:
-        for key in missing:
-            print(
-                f"::error file={path},title=Header key missing::Expected '{key}' in first {len(lines)} lines",
-                file=sys.stderr,
-            )
-        print(
-            f"Header guard failed: missing keys: {', '.join(missing)} (scanned top {len(lines)} lines)",
-            file=sys.stderr,
-        )
-        return 1
-
-    # Success summary
-    for key, (ln, text) in found.items():
-        print(f"::notice file={path},title=Header key OK::{key} at line {ln}: {text}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/.codex/skills/otro/scripts/common.py

@@ -1,303 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import json
-import re
-import subprocess
-from pathlib import Path
-from typing import Any
-
-
-def skill_dir_from_file(path: str) -> Path:
-    return Path(path).resolve().parent.parent
-
-
-def repo_root_from_skill_dir(skill_dir: Path) -> Path:
-    return skill_dir.parent.parent.parent
-
-
-def repo_root_from_run_dir(
-    run_dir: Path,
-    config: dict[str, Any] | None = None,
-    *,
-    skill_dir: Path | None = None,
-) -> Path:
-    resolved_config = config
-    if resolved_config is None:
-        config_path = run_dir / "config.json"
-        if config_path.exists():
-            try:
-                resolved_config = load_json(config_path)
-            except json.JSONDecodeError:
-                resolved_config = {}
-        else:
-            resolved_config = {}
-    raw = resolved_config.get("repo_root")
-    if isinstance(raw, str) and raw.strip():
-        return Path(raw).expanduser().resolve()
-
-    for candidate in [run_dir, *run_dir.parents]:
-        if (candidate / ".git").exists():
-            return candidate.resolve()
-    if skill_dir is not None:
-        return repo_root_from_skill_dir(skill_dir).resolve()
-    return run_dir.resolve()
-
-
-def run_root_from_skill_dir(skill_dir: Path) -> Path:
-    return skill_dir / "runs"
-
-
-def anchor_plan_path(run_dir: Path) -> Path:
-    return run_dir / "plans" / "anchor-plan.json"
-
-
-def load_json(path: Path) -> Any:
-    with path.open("r", encoding="utf-8") as handle:
-        return json.load(handle)
-
-
-def write_json(path: Path, payload: Any) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    with path.open("w", encoding="utf-8") as handle:
-        json.dump(payload, handle, indent=2, ensure_ascii=False)
-        handle.write("\n")
-
-
-def load_text(path: Path) -> str:
-    return path.read_text(encoding="utf-8")
-
-
-def write_text(path: Path, content: str) -> None:
-    path.parent.mkdir(parents=True, exist_ok=True)
-    path.write_text(content, encoding="utf-8")
-
-
-def loop_results_path(run_dir: Path, loop_number: int) -> Path:
-    return run_dir / "results" / f"loop-{loop_number}.json"
-
-
-def legacy_wave_results_path(run_dir: Path, loop_number: int) -> Path:
-    return run_dir / "results" / f"wave-{loop_number}.json"
-
-
-def load_loop_results(run_dir: Path, loop_number: int) -> Any:
-    canonical = loop_results_path(run_dir, loop_number)
-    legacy = legacy_wave_results_path(run_dir, loop_number)
-    if canonical.exists():
-        return load_json(canonical)
-    if legacy.exists():
-        return load_json(legacy)
-    raise FileNotFoundError(f"missing loop results: {canonical} (legacy fallback: {legacy})")
-
-
-def write_loop_results(run_dir: Path, loop_number: int, payload: Any) -> None:
-    write_json(loop_results_path(run_dir, loop_number), payload)
-    write_json(legacy_wave_results_path(run_dir, loop_number), payload)
-
-
-def loop_task_dir(run_dir: Path, loop_number: int, task_id: str) -> Path:
-    return run_dir / "loops" / f"loop-{loop_number}" / task_id
-
-
-def legacy_wave_task_dir(run_dir: Path, loop_number: int, task_id: str) -> Path:
-    return run_dir / "waves" / f"wave-{loop_number}" / task_id
-
-
-def task_step(task: dict[str, Any]) -> int:
-    raw = task.get("step", task.get("wave"))
-    if raw is None:
-        raise KeyError("task is missing step/wave")
-    return int(raw)
-
-
-def set_task_step(task: dict[str, Any], step_number: int) -> None:
-    task["step"] = int(step_number)
-    task.pop("wave", None)
-
-
-def plan_steps(plan: dict[str, Any]) -> list[dict[str, Any]]:
-    steps = plan.get("steps")
-    if isinstance(steps, list):
-        return steps
-    waves = plan.get("waves")
-    if isinstance(waves, list):
-        return waves
-    return []
-
-
-def set_plan_steps(plan: dict[str, Any], steps: list[dict[str, Any]]) -> None:
-    normalized: list[dict[str, Any]] = []
-    for entry in steps:
-        item = dict(entry)
-        if "step" not in item and "wave" in item:
-            item["step"] = item.pop("wave")
-        else:
-            item.pop("wave", None)
-        normalized.append(item)
-    plan["steps"] = normalized
-    plan.pop("waves", None)
-
-
-def normalize_completion_policy(plan: dict[str, Any]) -> None:
-    policy = plan.get("completion_policy")
-    if not isinstance(policy, dict):
-        return
-    if "repository_done" not in policy and "scope_done" in policy:
-        policy["repository_done"] = policy["scope_done"]
-    policy.pop("scope_done", None)
-
-
-def canonicalize_plan(plan: dict[str, Any]) -> dict[str, Any]:
-    normalized = dict(plan)
-    normalize_completion_policy(normalized)
-
-    tasks = []
-    for task in normalized.get("tasks", []):
-        item = dict(task)
-        if "step" not in item and "wave" in item:
-            item["step"] = item["wave"]
-        item.pop("wave", None)
-        tasks.append(item)
-    normalized["tasks"] = tasks
-
-    steps = []
-    for entry in plan_steps(normalized):
-        item = dict(entry)
-        if "step" not in item and "wave" in item:
-            item["step"] = item["wave"]
-        item.pop("wave", None)
-        steps.append(item)
-    set_plan_steps(normalized, steps)
-    return normalized
-
-
-def ensure_anchor_plan(run_dir: Path, source_plan_path: Path) -> Path:
-    anchor_path = anchor_plan_path(run_dir)
-    if not anchor_path.exists() and source_plan_path.exists():
-        write_text(anchor_path, load_text(source_plan_path))
-    return anchor_path
-
-
-def model_timeout_profile(model: str) -> dict[str, Any]:
-    normalized = model.strip().lower()
-    if re.search(r"gpt-5(\.1)?|codex", normalized):
-        return {
-            "planner_timeout_seconds": 300,
-            "worker_timeout_seconds": 300,
-            "worker_timeout_seconds_by_kind": {
-                "analysis": 300,
-                "planning": 300,
-                "edit": 300,
-                "verify": 300,
-                "integration": 300,
-                "cleanup": 300,
-            },
-        }
-    return {
-        "planner_timeout_seconds": 300,
-        "worker_timeout_seconds": 300,
-        "worker_timeout_seconds_by_kind": {
-            "analysis": 300,
-            "planning": 300,
-            "edit": 300,
-            "verify": 300,
-            "integration": 300,
-            "cleanup": 300,
-        },
-    }
-
-
-def planner_timeout_seconds(config: dict[str, Any]) -> int:
-    raw = config.get("planner_timeout_seconds")
-    if raw is not None:
-        return int(raw)
-    profile = model_timeout_profile(str(config.get("model", "")))
-    return int(profile["planner_timeout_seconds"])
-
-
-def worker_timeout_seconds(config: dict[str, Any], task_kind: str) -> int:
-    by_kind = config.get("worker_timeout_seconds_by_kind")
-    if isinstance(by_kind, dict):
-        kind_value = by_kind.get(task_kind)
-        if kind_value is not None:
-            return int(kind_value)
-    raw = config.get("worker_timeout_seconds")
-    if raw is not None:
-        return int(raw)
-    profile = model_timeout_profile(str(config.get("model", "")))
-    kind_map = profile.get("worker_timeout_seconds_by_kind", {})
-    if task_kind in kind_map:
-        return int(kind_map[task_kind])
-    return int(profile["worker_timeout_seconds"])
-
-
-def salvage_json_output(log_path: Path, output_path: Path) -> bool:
-    if not log_path.exists():
-        return False
-    lines = log_path.read_text(encoding="utf-8", errors="replace").splitlines()
-    for line in reversed(lines):
-        candidate = line.strip()
-        if not candidate.startswith("{") or not candidate.endswith("}"):
-            continue
-        try:
-            payload = json.loads(candidate)
-        except json.JSONDecodeError:
-            continue
-        write_json(output_path, payload)
-        return True
-    return False
-
-
-def run_codex_exec(
-    *,
-    repo_root: Path,
-    prompt: str,
-    model: str,
-    schema_path: Path,
-    output_path: Path,
-    log_path: Path,
-    timeout_seconds: int = 180,
-    extra_args: list[str] | None = None,
-) -> subprocess.CompletedProcess[str]:
-    output_path.parent.mkdir(parents=True, exist_ok=True)
-    log_path.parent.mkdir(parents=True, exist_ok=True)
-    cmd = [
-        "codex",
-        "exec",
-        "--dangerously-bypass-approvals-and-sandbox",
-        "-c",
-        "model_reasoning_effort=high",
-        "--cd",
-        str(repo_root),
-        "--model",
-        model,
-        "--output-schema",
-        str(schema_path),
-        "--output-last-message",
-        str(output_path),
-        "-",
-    ]
-    if extra_args:
-        cmd[2:2] = extra_args
-    with log_path.open("w", encoding="utf-8") as log_handle:
-        try:
-            return subprocess.run(
-                cmd,
-                input=prompt,
-                text=True,
-                stdout=log_handle,
-                stderr=subprocess.STDOUT,
-                check=False,
-                timeout=timeout_seconds,
-            )
-        except subprocess.TimeoutExpired:
-            log_handle.write(f"\n[TIMEOUT after {timeout_seconds}s]\n")
-            log_handle.flush()
-            return subprocess.CompletedProcess(cmd, 124)
-
-
-def summarize_completed_process(result: subprocess.CompletedProcess[str]) -> dict[str, Any]:
-    return {
-        "returncode": result.returncode,
-    }

package/.codex/skills/otro/scripts/init_run.sh

@@ -1,68 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-
-if [[ $# -lt 1 ]]; then
-  echo "usage: $0 <run-name>" >&2
-  exit 1
-fi
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-SKILL_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
-RUN_NAME="$1"
-RUN_DIR="$SKILL_DIR/runs/$RUN_NAME"
-
-REPO_ROOT="$(pwd -P)"
-
-mkdir -p "$RUN_DIR"/{plans,results,steps,waves,logs}
-
-cat > "$RUN_DIR/goal.md" <<'EOF'
-# Goal
-
-Replace this text with the repository-wide objective.
-
-# Constraints
-
-- Keep tasks disjoint by owned file paths inside the same loop.
-- Reconcile integration after every loop before dispatching the next loop.
-
-# Done When
-
-- Define these three levels explicitly:
-- loop_done: current plan backlog is exhausted.
-- run_done: a fresh repository-wide rescan after loop_done finds no materially new tasks.
-- repository_done: run_done plus repository-level deployment and verification gates pass.
-EOF
-
-cat > "$RUN_DIR/config.json" <<EOF
-{
-  "run_name": "$RUN_NAME",
-  "repo_root": "$REPO_ROOT",
-  "model": "gpt-5",
-  "max_parallel": "all",
-  "max_tasks_per_step": 10000,
-  "max_tasks_per_wave": 10000,
-  "max_tasks_total": 50000,
-  "planner_timeout_seconds": 300,
-  "worker_timeout_seconds": 300,
-  "worker_timeout_seconds_by_kind": {
-    "analysis": 300,
-    "planning": 300,
-    "edit": 300,
-    "verify": 300,
-    "integration": 300,
-    "cleanup": 300
-  }
-}
-EOF
-
-cat > "$RUN_DIR/state.json" <<EOF
-{
-  "run_name": "$RUN_NAME",
-  "plan_version": 0,
-  "current_loop": 0,
-  "current_step": 0,
-  "current_wave": 0
-}
-EOF
-
-echo "initialized $RUN_DIR"

package/.codex/skills/otro/scripts/plan_loop.py

@@ -1,8 +0,0 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-from plan_step import main
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())