codex-flow 2.1.13__py3-none-any.whl

codex_flow/data/scripts/migrations/0001_update_settings.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python3
+"""Add OTA update preferences without rewriting unrelated policy fields."""
+
+from __future__ import annotations
+
+import argparse
+import os
+import re
+import tempfile
+from pathlib import Path
+
+DEFAULTS = {
+    "channel": '"stable"',
+    "check": "true",
+    "check_interval_hours": "24",
+    "notify_cli": "true",
+    "notify_app": "true",
+    "auto_install": "false",
+}
+
+
+def atomic_write(path: Path, text: str) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    fd, name = tempfile.mkstemp(prefix=f".{path.name}.", dir=str(path.parent))
+    try:
+        with os.fdopen(fd, "w", encoding="utf-8", newline="\n") as handle:
+            handle.write(text)
+            handle.flush()
+            os.fsync(handle.fileno())
+        os.replace(name, path)
+    finally:
+        try:
+            os.unlink(name)
+        except FileNotFoundError:
+            pass
+
+
+def migrate(policy: Path) -> bool:
+    try:
+        text = policy.read_text(encoding="utf-8-sig")
+    except OSError:
+        return False
+
+    section_re = re.compile(r"(?ms)^\[update\]\s*\n(.*?)(?=^\[[^\n]+\]\s*$|\Z)")
+    match = section_re.search(text)
+    changed = False
+    if not match:
+        if text and not text.endswith("\n"):
+            text += "\n"
+        if text and not text.endswith("\n\n"):
+            text += "\n"
+        text += "[update]\n" + "".join(f"{key} = {value}\n" for key, value in DEFAULTS.items())
+        changed = True
+    else:
+        body = match.group(1)
+        for key, value in DEFAULTS.items():
+            if re.search(rf"(?m)^\s*{re.escape(key)}\s*=", body):
+                continue
+            if body and not body.endswith("\n"):
+                body += "\n"
+            body += f"{key} = {value}\n"
+            changed = True
+        if changed:
+            text = text[: match.start(1)] + body + text[match.end(1) :]
+
+    if changed:
+        atomic_write(policy, text)
+    return changed
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--policy", required=True, type=Path)
+    args = parser.parse_args()
+    migrate(args.policy)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

codex_flow/data/scripts/package-release.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+"""Build codex-flow OTA release archives."""
+
+from __future__ import annotations
+
+import argparse
+import gzip
+import hashlib
+import os
+import tarfile
+import zipfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+# Everything required after OTA switches STATE_DIR/source to the version package.
+# Keep this list runtime-focused: CI/tests/.github stay source-only, while
+# benchmark data and ChatGPT MCP must remain available after the original git
+# checkout is no longer involved.
+INCLUDE_ROOTS = (
+    "VERSION",
+    "LICENSE",
+    "README.md",
+    "README.en.md",
+    "install.sh",
+    "install.ps1",
+    "bin",
+    "scripts",
+    "templates",
+    "completions",
+    "policy",
+    "benchmark",
+    "apps/chatgpt-mcp",
+)
+DARWIN_ROOTS = (
+    "apps/macos-overlay",
+)
+
+
+def version() -> str:
+    return (ROOT / "VERSION").read_text(encoding="utf-8-sig").strip().lstrip("v")
+
+
+def _collect(path: Path, seen: set[Path]) -> None:
+    if path.is_file() and not path.is_symlink():
+        seen.add(path)
+        return
+    if not path.is_dir():
+        return
+    for child in path.rglob("*"):
+        if (
+            child.is_file()
+            and not child.is_symlink()
+            and "__pycache__" not in child.parts
+            and child.suffix not in {".pyc", ".pyo"}
+            and child.name != ".DS_Store"
+        ):
+            seen.add(child)
+
+
+def iter_files(platform_name: str) -> list[Path]:
+    seen: set[Path] = set()
+    for item in INCLUDE_ROOTS:
+        _collect(ROOT / item, seen)
+    if platform_name.startswith("darwin-"):
+        for item in DARWIN_ROOTS:
+            _collect(ROOT / item, seen)
+    return sorted(seen, key=lambda p: p.relative_to(ROOT).as_posix())
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _mode(src: Path) -> int:
+    return 0o755 if os.access(src, os.X_OK) or src.suffix in {".sh", ".py"} else 0o644
+
+
+def build(platform_name: str, output_dir: Path) -> Path:
+    output_dir.mkdir(parents=True, exist_ok=True)
+    ver = version()
+    prefix = f"codex-flow-{ver}"
+    files = iter_files(platform_name)
+    if platform_name.startswith("windows-"):
+        archive = output_dir / f"codex-flow-{ver}-{platform_name}.zip"
+        with zipfile.ZipFile(archive, "w", compression=zipfile.ZIP_DEFLATED, compresslevel=9) as zf:
+            for src in files:
+                rel = src.relative_to(ROOT).as_posix()
+                info = zipfile.ZipInfo(f"{prefix}/{rel}")
+                info.date_time = (2020, 1, 1, 0, 0, 0)
+                info.external_attr = (_mode(src) & 0xFFFF) << 16
+                info.compress_type = zipfile.ZIP_DEFLATED
+                zf.writestr(info, src.read_bytes())
+    else:
+        archive = output_dir / f"codex-flow-{ver}-{platform_name}.tar.gz"
+        # Pin the gzip header timestamp as well as tar metadata so rebuilds of
+        # identical inputs produce stable bytes/checksums.
+        with archive.open("wb") as raw, gzip.GzipFile(fileobj=raw, mode="wb", mtime=0) as gz:
+            with tarfile.open(fileobj=gz, mode="w", format=tarfile.PAX_FORMAT) as tf:
+                for src in files:
+                    rel = src.relative_to(ROOT).as_posix()
+                    arcname = f"{prefix}/{rel}"
+                    info = tf.gettarinfo(str(src), arcname=arcname)
+                    info.uid = info.gid = 0
+                    info.uname = info.gname = "root"
+                    info.mtime = 0
+                    info.mode = _mode(src)
+                    with src.open("rb") as handle:
+                        tf.addfile(info, handle)
+    digest = sha256(archive)
+    (archive.with_suffix(archive.suffix + ".sha256")).write_text(
+        f"{digest}  {archive.name}\n", encoding="utf-8"
+    )
+    print(archive)
+    return archive
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--platform", required=True)
+    parser.add_argument("--output-dir", default="dist", type=Path)
+    args = parser.parse_args()
+    build(args.platform, args.output_dir)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

codex_flow/data/scripts/render-benchmark-report.py

@@ -0,0 +1,292 @@
+#!/usr/bin/env python3
+from __future__ import annotations
+
+import argparse
+import json
+from collections import defaultdict
+from pathlib import Path
+from typing import Any
+
+
+def load_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows = [json.loads(line) for line in path.read_text().splitlines() if line.strip()]
+    if not rows:
+        raise ValueError("benchmark results are empty")
+    for row in rows:
+        if row.get("schema_version") == 1:
+            suffix = row["model"].rsplit("-", 1)[-1]
+            if suffix in {"luna", "terra", "sol"}:
+                base = f"{suffix}-direct"
+                row["strategy_id"] = base if row["reasoning_effort"] == "high" else f"{base}-{row['reasoning_effort']}"
+            else:
+                row["strategy_id"] = f"direct:{row['model']}:{row['reasoning_effort']}"
+            row["strategy"] = "direct"
+            row["reasoning_policy"] = "fixed"
+            row["worker_model"] = None
+            row["worker_reasoning_effort"] = None
+            row["first_passed"] = row["passed"] and row["repair_cycles"] == 0
+            row["review_cycles"] = 0
+            row["model_usage"] = [{
+                "role": "direct",
+                "model": row["model"],
+                "reasoning_effort": row["reasoning_effort"],
+                "calls": row["repair_cycles"] + 1,
+                "input_tokens": row["input_tokens"],
+                "cached_input_tokens": row["cached_input_tokens"],
+                "output_tokens": row["output_tokens"],
+            }]
+    return rows
+
+
+def usage_cost(usage: dict[str, Any], prices: dict[str, Any]) -> float:
+    model = usage["model"]
+    if model not in prices:
+        raise ValueError(f"missing price snapshot for {model}")
+    price = prices[model]
+    cached = usage["cached_input_tokens"]
+    uncached = max(0, usage["input_tokens"] - cached)
+    return (
+        uncached * price["input"]
+        + cached * price["cached_input"]
+        + usage["output_tokens"] * price["output"]
+    ) / 1_000_000
+
+
+def cost(row: dict[str, Any], prices: dict[str, Any]) -> float:
+    return sum(usage_cost(usage, prices) for usage in row["model_usage"])
+
+
+def pct(n: float, d: float) -> str:
+    return f"{(100 * n / d):.1f}%" if d else "n/a"
+
+
+def signed_pct(value: float) -> str:
+    return f"{value:+.1%}"
+
+
+def yes_no(value: bool) -> str:
+    return "yes" if value else "no"
+
+
+def composition(row: dict[str, Any]) -> str:
+    if row["strategy"] == "direct":
+        return f"{row['model']} / {row['reasoning_effort']}"
+    policy = row.get("reasoning_policy", "fixed")
+    if policy == "adaptive":
+        return f"{row['model']} parent → {row['worker_model']} worker / adaptive"
+    return f"{row['model']} parent → {row['worker_model']} worker / {row['reasoning_effort']}"
+
+
+def token_metrics(items: list[dict[str, Any]]) -> dict[str, float]:
+    count = len(items)
+    total_input = sum(item["input_tokens"] for item in items)
+    total_cached = sum(item["cached_input_tokens"] for item in items)
+    total_output = sum(item["output_tokens"] for item in items)
+    parent_tokens = 0
+    worker_tokens = 0
+    for item in items:
+        for usage in item.get("model_usage", []):
+            tokens = usage.get("input_tokens", 0) + usage.get("output_tokens", 0)
+            if usage.get("role") == "parent":
+                parent_tokens += tokens
+            elif usage.get("role") == "worker":
+                worker_tokens += tokens
+    return {
+        "total_tokens": (total_input + total_output) / count,
+        "parent_tokens": parent_tokens / count,
+        "worker_tokens": worker_tokens / count,
+        "cached_input_tokens": total_cached / count,
+        "net_new_input_tokens": (total_input - total_cached) / count,
+        "cache_rate": total_cached / total_input if total_input else 0.0,
+    }
+
+
+def relative_change(value: float, reference: float) -> float | None:
+    return value / reference - 1 if reference else None
+
+
+def fmt_avg_tokens(value: float) -> str:
+    return f"{round(value):,}"
+
+
+def fmt_change(value: float | None) -> str:
+    return signed_pct(value) if value is not None else "n/a"
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--results", required=True)
+    ap.add_argument("--prices", required=True)
+    ap.add_argument("--analysis", required=True)
+    ap.add_argument("--output", required=True)
+    ap.add_argument("--title", default="Codex strategy benchmark report")
+    args = ap.parse_args()
+
+    rows = load_jsonl(Path(args.results))
+    prices = json.loads(Path(args.prices).read_text())
+    analysis = json.loads(Path(args.analysis).read_text())
+
+    total_cost = sum(cost(row, prices) for row in rows)
+    total_input = sum(row["input_tokens"] for row in rows)
+    total_cached = sum(row["cached_input_tokens"] for row in rows)
+    total_output = sum(row["output_tokens"] for row in rows)
+    total_tokens = total_input + total_output
+    net_new_input = total_input - total_cached
+    passed = sum(1 for row in rows if row["passed"])
+    first_passed = sum(1 for row in rows if row["first_passed"])
+    infra_failures = sum(1 for row in rows if row.get("codex_exit_code", 0) != 0)
+    repairs = sum(row["repair_cycles"] for row in rows)
+    reviews = sum(row["review_cycles"] for row in rows)
+
+    grouped: dict[str, list[dict[str, Any]]] = defaultdict(list)
+    for row in rows:
+        grouped[row["strategy_id"]].append(row)
+    strategy_tokens = {strategy_id: token_metrics(items) for strategy_id, items in grouped.items()}
+    sol_tokens = strategy_tokens.get("sol-direct")
+
+    lines = [
+        f"# {args.title}",
+        "",
+        "> Dollar figures are **API-equivalent reference costs** calculated from the pinned API price snapshot. Flow cost includes parent and worker usage. They are not ChatGPT subscription charges.",
+        "",
+        "## Overall",
+        "",
+        f"- Runs completed: **{len(rows)}**",
+        f"- Final pass: **{passed}/{len(rows)} ({pct(passed, len(rows))})**",
+        f"- First pass: **{first_passed}/{len(rows)} ({pct(first_passed, len(rows))})**",
+        f"- Infrastructure/CLI failures: **{infra_failures}**",
+        f"- Repair cycles: **{repairs}**",
+        f"- Parent review cycles: **{reviews}**",
+        f"- API-equivalent reference cost: **${total_cost:.6f}**",
+        f"- Total tokens: **{total_tokens:,}**",
+        f"- Input tokens: **{total_input:,}** — cached **{total_cached:,}**, net-new **{net_new_input:,}**",
+        f"- Output tokens: **{total_output:,}**",
+        "",
+        "## Strategy results",
+        "",
+        "| Strategy | Composition | Runs | Final pass | First pass | Repairs | Reviews | Avg wall | Avg reference cost |",
+        "| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |",
+    ]
+
+    for strategy_id, items in sorted(grouped.items()):
+        item_passed = sum(1 for item in items if item["passed"])
+        item_first = sum(1 for item in items if item["first_passed"])
+        item_repairs = sum(item["repair_cycles"] for item in items)
+        item_reviews = sum(item["review_cycles"] for item in items)
+        item_cost = sum(cost(item, prices) for item in items)
+        item_wall = sum(item.get("wall_time_seconds", 0) for item in items) / len(items)
+        lines.append(
+            f"| {strategy_id} | {composition(items[0])} | {len(items)} | {pct(item_passed, len(items))} | "
+            f"{pct(item_first, len(items))} | {item_repairs} | {item_reviews} | {item_wall:.1f}s | ${item_cost / len(items):.6f} |"
+        )
+
+    lines.extend([
+        "",
+        "## Token efficiency",
+        "",
+        "This table separates raw token volume from where the work ran. Runtime Parent/Worker values come from FlowPilot role-attributed telemetry; net-new input excludes cached input. Deltas use `sol-direct` as the paired high-capability baseline when present.",
+        "",
+        "| Strategy | Avg total tokens | Avg Parent tokens | Avg Worker tokens | Avg cached input | Avg net-new input | Cache rate | Total Δ vs Sol | Net-new Δ vs Sol | Parent reduction vs Sol |",
+        "| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |",
+    ])
+    for strategy_id, items in sorted(grouped.items()):
+        metrics = strategy_tokens[strategy_id]
+        if sol_tokens is not None:
+            total_delta = relative_change(metrics["total_tokens"], sol_tokens["total_tokens"])
+            net_new_delta = relative_change(metrics["net_new_input_tokens"], sol_tokens["net_new_input_tokens"])
+        else:
+            total_delta = net_new_delta = None
+        if items[0]["strategy"] != "direct" and sol_tokens is not None:
+            parent_reduction = 1 - metrics["parent_tokens"] / sol_tokens["total_tokens"] if sol_tokens["total_tokens"] else None
+        else:
+            parent_reduction = None
+        lines.append(
+            f"| {strategy_id} | {fmt_avg_tokens(metrics['total_tokens'])} | {fmt_avg_tokens(metrics['parent_tokens'])} | "
+            f"{fmt_avg_tokens(metrics['worker_tokens'])} | {fmt_avg_tokens(metrics['cached_input_tokens'])} | "
+            f"{fmt_avg_tokens(metrics['net_new_input_tokens'])} | {metrics['cache_rate']:.1%} | "
+            f"{fmt_change(total_delta)} | {fmt_change(net_new_delta)} | {fmt_change(parent_reduction)} |"
+        )
+
+    lines.extend([
+        "",
+        "## Sol capability evidence",
+        "",
+        "Sol is compared only with other direct strategies at the same reasoning effort.",
+        "",
+        "| Class | Comparator | Pass gain | First-pass gain | Repair reduction | Enough evidence | Advantage |",
+        "| --- | --- | ---: | ---: | ---: | ---: | ---: |",
+    ])
+    for task_class in ("routine", "complex", "critical"):
+        item = analysis.get("sol_capability_evidence", {}).get(task_class)
+        if not item:
+            lines.append(f"| {task_class} | n/a | n/a | n/a | n/a | no | no |")
+            continue
+        lines.append(
+            f"| {task_class} | {item['competitor_strategy_id']} | {signed_pct(item['pass_rate_gain'])} | "
+            f"{signed_pct(item['first_pass_rate_gain'])} | {item['average_repair_reduction']:+.2f} | "
+            f"{yes_no(item['evidence_sufficient'])} | {yes_no(item['advantage_demonstrated'])} |"
+        )
+
+    lines.extend([
+        "",
+        "## Fixed-high flow evidence",
+        "",
+        "Flow must preserve Sol quality, reduce total parent+worker cost versus Sol, and improve over Luna direct.",
+        "",
+        "| Class | Pass Δ vs Sol | Cost reduction vs Sol | Pass gain vs Luna | First-pass gain vs Luna | Enough evidence | Advantage |",
+        "| --- | ---: | ---: | ---: | ---: | ---: | ---: |",
+    ])
+    for task_class in ("routine", "complex", "critical"):
+        item = analysis.get("flow_advantage_evidence", {}).get(task_class)
+        if not item:
+            lines.append(f"| {task_class} | n/a | n/a | n/a | n/a | no | no |")
+            continue
+        lines.append(
+            f"| {task_class} | {signed_pct(item['pass_rate_delta_vs_sol'])} | {item['cost_reduction_vs_sol']:.1%} | "
+            f"{signed_pct(item['pass_rate_gain_vs_worker'])} | {signed_pct(item['first_pass_rate_gain_vs_worker'])} | "
+            f"{yes_no(item['evidence_sufficient'])} | {yes_no(item['advantage_demonstrated'])} |"
+        )
+
+    lines.extend([
+        "",
+        "## Adaptive reasoning evidence",
+        "",
+        "Adaptive flow is compared only with fixed-high flow and is excluded from the same-effort Sol comparison.",
+        "",
+        "| Class | Pass gain | First-pass gain | Repair reduction | Cost change | Wall-time change | Enough evidence | Value |",
+        "| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |",
+    ])
+    for task_class in ("routine", "complex", "critical"):
+        item = analysis.get("adaptive_reasoning_evidence", {}).get(task_class)
+        if not item:
+            lines.append(f"| {task_class} | n/a | n/a | n/a | n/a | n/a | no | no |")
+            continue
+        lines.append(
+            f"| {task_class} | {signed_pct(item['pass_rate_gain'])} | {signed_pct(item['first_pass_rate_gain'])} | "
+            f"{item['average_repair_reduction']:+.2f} | {signed_pct(item['cost_change'])} | {signed_pct(item['wall_time_change'])} | "
+            f"{yes_no(item['evidence_sufficient'])} | {yes_no(item['value_demonstrated'])} |"
+        )
+
+    lines.extend(["", "## Advisory routing", ""])
+    recommendations = analysis.get("recommendations", {})
+    for task_class in ("routine", "complex", "critical"):
+        rec = recommendations.get(task_class)
+        if rec:
+            lines.append(
+                f"- **{task_class}**: `{rec['strategy_id']}` — pass {rec['pass_rate']:.1%}, "
+                f"API-equivalent ${rec['average_cost_usd']:.6f}/run, n={rec['samples']}"
+            )
+        else:
+            lines.append(f"- **{task_class}**: no tested strategy passed the evidence gate")
+
+    lines.extend([
+        "",
+        "> Conclusions are advisory and pre-registered thresholds are applied before cost comparison. Benchmark policy is not modified automatically.",
+        "",
+    ])
+    Path(args.output).write_text("\n".join(lines))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())