agentic-dev 0.1.0 → 0.2.1

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

@@ -0,0 +1,84 @@
+#!/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

@@ -0,0 +1,303 @@
+#!/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

@@ -0,0 +1,68 @@
+#!/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

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