codex-flow 2.1.13__py3-none-any.whl

codex_flow/data/scripts/telemetry_core/repair.py

@@ -0,0 +1,223 @@
+"""Deterministic historical telemetry backfill and repair engine."""
+from __future__ import annotations
+
+import copy
+from pathlib import Path
+from typing import Any
+
+from .app_server import (
+    enrich_run_metadata,
+    extract_transcript_insights,
+    find_session_transcript,
+    quota_delta,
+    transcript_turn_usage,
+)
+from .common import (
+    LAST_FILE,
+    atomic_json,
+    iter_run_files,
+    now_ms,
+    numeric_ms,
+    read_json_object,
+)
+
+
+def _has_summary(val: Any) -> bool:
+    if not isinstance(val, dict):
+        return False
+    return any(bool(v) for v in val.values())
+
+
+def repair_run(
+    run: dict[str, Any],
+    *,
+    report: dict[str, Any] | None = None,
+) -> dict[str, Any]:
+    """Repair a single telemetry run in-place by backfilling recoverable fields.
+
+    Principles:
+    1. Only fills missing fields, never overwrites existing valid data.
+    2. Safe skips when transcript is missing or unreadable.
+    3. Backfills quota delta only if both before and after snapshots exist.
+    """
+    if not isinstance(run, dict):
+        return run
+
+    before_summary = _has_summary(run.get("summary_info"))
+    before_skills = bool(run.get("skills_used"))
+    before_tools = bool(run.get("tools_used"))
+    before_trajectory = bool(run.get("trajectory"))
+    before_logs = bool(run.get("logs"))
+    before_quota = bool(run.get("quota_change_during_run"))
+
+    transcript_path = run.get("transcript_path")
+    turn_id = run.get("turn_id")
+    has_valid_transcript = (
+        isinstance(transcript_path, str)
+        and bool(transcript_path)
+        and Path(transcript_path).is_file()
+    )
+
+    if not has_valid_transcript:
+        thread_path = (
+            run.get("thread", {}).get("path")
+            if isinstance(run.get("thread"), dict)
+            else None
+        )
+        if thread_path and Path(thread_path).is_file():
+            transcript_path = thread_path
+            run["transcript_path"] = thread_path
+            has_valid_transcript = True
+        else:
+            resolved = find_session_transcript(run.get("session_id"))
+            if resolved and Path(resolved).is_file():
+                transcript_path = resolved
+                run["transcript_path"] = resolved
+                has_valid_transcript = True
+
+    if has_valid_transcript:
+        insights = extract_transcript_insights(transcript_path, turn_id)
+        if isinstance(insights, dict):
+            for key in ("skills_used", "tools_used", "trajectory", "logs"):
+                if not run.get(key) and insights.get(key):
+                    run[key] = insights[key]
+            if not before_summary and _has_summary(insights.get("summary_info")):
+                run["summary_info"] = insights["summary_info"]
+
+        parent = run.get("parent")
+        if isinstance(parent, dict):
+            u = parent.get("usage_delta")
+            total = u.get("total_tokens") if isinstance(u, dict) else None
+            if total is None or total == 0:
+                recovered_usage = transcript_turn_usage(transcript_path, turn_id)
+                if recovered_usage and recovered_usage.get("total_tokens", 0) > 0:
+                    parent["usage_delta"] = recovered_usage
+                    if report is not None:
+                        report["tokens_restored"] = True
+
+    parent_model = (run.get("parent") or {}).get("model") if isinstance(run.get("parent"), dict) else None
+    if (run.get("cwd") == "/" or (parent_model == "gpt-5.6-terra" and not has_valid_transcript)) and not run.get("is_system_task"):
+        run["is_system_task"] = True
+
+    if run.get("finished_at_ms") is None and run.get("prompt_seen") is True:
+        started = numeric_ms(run.get("started_at_ms"))
+        if started and (now_ms() - started) > 300_000:
+            if not run.get("status") or run.get("status") == "running":
+                run["status"] = "aborted"
+                if report is not None:
+                    report["aborted_marked"] = True
+
+    enrich_run_metadata(run)
+
+    quota_change = run.get("quota_change_during_run")
+    if not quota_change:
+        before = run.get("quota_before")
+        after = run.get("quota_after")
+        if isinstance(before, list) and before and isinstance(after, list) and after:
+            run["quota_change_during_run"] = quota_delta(before, after)
+
+    if report is not None:
+        report["task_summaries_restored"] = not before_summary and _has_summary(run.get("summary_info"))
+        report["skills_tools_restored"] = (
+            (not before_skills and bool(run.get("skills_used")))
+            or (not before_tools and bool(run.get("tools_used")))
+        )
+        report["trajectories_restored"] = not before_trajectory and bool(run.get("trajectory"))
+        report["logs_restored"] = not before_logs and bool(run.get("logs"))
+        if not before_quota:
+            report["quota_deltas_restored"] = bool(run.get("quota_change_during_run"))
+            report["quota_deltas_impossible"] = not bool(run.get("quota_change_during_run"))
+        else:
+            report["quota_deltas_restored"] = False
+            report["quota_deltas_impossible"] = False
+        report["transcript_missing"] = not has_valid_transcript
+
+    return run
+
+
+def format_repair_summary(stats: dict[str, int]) -> str:
+    val_width = max((len(str(v)) for v in stats.values()), default=1)
+    val_width = max(val_width, 2)
+    col_width = 25
+
+    lines = [
+        "Telemetry repair complete\n",
+        f"{'scanned:':<{col_width}}{stats.get('scanned', 0):>{val_width}}",
+        f"{'repaired:':<{col_width}}{stats.get('repaired', 0):>{val_width}}",
+        f"{'unchanged:':<{col_width}}{stats.get('unchanged', 0):>{val_width}}",
+        f"{'transcript missing:':<{col_width}}{stats.get('transcript_missing', 0):>{val_width}}",
+        "",
+        f"{'task summaries restored:':<{col_width}}{stats.get('task_summaries_restored', 0):>{val_width}}",
+        f"{'skills/tools restored:':<{col_width}}{stats.get('skills_tools_restored', 0):>{val_width}}",
+        f"{'trajectories restored:':<{col_width}}{stats.get('trajectories_restored', 0):>{val_width}}",
+        f"{'logs restored:':<{col_width}}{stats.get('logs_restored', 0):>{val_width}}",
+        f"{'quota deltas restored:':<{col_width}}{stats.get('quota_deltas_restored', 0):>{val_width}}",
+        f"{'quota deltas impossible:':<{col_width}}{stats.get('quota_deltas_impossible', 0):>{val_width}}",
+    ]
+    return "\n".join(lines)
+
+
+def repair_history(dry_run: bool = False, verbose: bool = True) -> dict[str, int]:
+    """Scan and repair all historical run records deterministically."""
+    stats = {
+        "scanned": 0,
+        "repaired": 0,
+        "unchanged": 0,
+        "transcript_missing": 0,
+        "task_summaries_restored": 0,
+        "skills_tools_restored": 0,
+        "trajectories_restored": 0,
+        "logs_restored": 0,
+        "quota_deltas_restored": 0,
+        "quota_deltas_impossible": 0,
+    }
+
+    last = read_json_object(LAST_FILE)
+
+    for path in iter_run_files():
+        run = read_json_object(path)
+        if not isinstance(run, dict):
+            continue
+
+        stats["scanned"] += 1
+
+        run_report: dict[str, Any] = {}
+        original = copy.deepcopy(run)
+
+        repair_run(run, report=run_report)
+
+        changed = (run != original)
+
+        if run_report.get("task_summaries_restored"):
+            stats["task_summaries_restored"] += 1
+        if run_report.get("skills_tools_restored"):
+            stats["skills_tools_restored"] += 1
+        if run_report.get("trajectories_restored"):
+            stats["trajectories_restored"] += 1
+        if run_report.get("logs_restored"):
+            stats["logs_restored"] += 1
+        if run_report.get("quota_deltas_restored"):
+            stats["quota_deltas_restored"] += 1
+        if run_report.get("quota_deltas_impossible"):
+            stats["quota_deltas_impossible"] += 1
+
+        if changed:
+            stats["repaired"] += 1
+            if not dry_run:
+                atomic_json(path, run)
+                if (
+                    isinstance(last, dict)
+                    and last.get("session_id") == run.get("session_id")
+                    and last.get("turn_id") == run.get("turn_id")
+                ):
+                    atomic_json(LAST_FILE, run)
+        else:
+            if run_report.get("transcript_missing"):
+                stats["transcript_missing"] += 1
+            else:
+                stats["unchanged"] += 1
+
+    if verbose:
+        print(format_repair_summary(stats))
+
+    return stats

codex_flow/data/scripts/ui.py

@@ -0,0 +1,266 @@
+#!/usr/bin/env python3
+"""Localized user-facing CLI surfaces for codex-flow."""
+from __future__ import annotations
+
+import argparse
+import os
+import re
+from pathlib import Path
+
+from localization import (
+    configured_language,
+    detect_system_language,
+    resolve_language,
+    set_configured_language,
+    tr,
+)
+
+CODEX_HOME = Path(os.environ.get("CODEX_HOME", Path.home() / ".codex"))
+STATE_DIR = CODEX_HOME / "codex-flow"
+POLICY = CODEX_HOME / "codex-flow.toml"
+
+
+def T(en: str, zh: str, lang: str) -> str:
+    return tr(en, zh, lang=lang)
+
+
+def display_width(text: str) -> int:
+    import unicodedata
+    return sum(2 if unicodedata.east_asian_width(ch) in ("W", "F") else 1 for ch in text)
+
+
+def policy_value(section: str, key: str, default: str = "") -> str:
+    try:
+        text = POLICY.read_text(encoding="utf-8")
+    except OSError:
+        return default
+    m = re.search(rf"(?ms)^\[{re.escape(section)}\]\s*\n(.*?)(?=^\[[^\n]+\]\s*$|\Z)", text)
+    if not m:
+        return default
+    k = re.search(rf"(?m)^\s*{re.escape(key)}\s*=\s*(.*?)\s*$", m.group(1))
+    if not k:
+        return default
+    value = re.sub(r"\s+#.*$", "", k.group(1)).strip()
+    if len(value) >= 2 and value[0] == value[-1] == '"':
+        value = value[1:-1]
+    return value or default
+
+
+def source_dir() -> Path | None:
+    try:
+        path = Path((STATE_DIR / "source").read_text(encoding="utf-8").strip())
+        return path if path.exists() else None
+    except OSError:
+        return None
+
+
+def compact_path(path: Path) -> str:
+    try:
+        home = str(Path.home())
+        text = str(path)
+        return "~" + text[len(home):] if text.startswith(home) else text
+    except Exception:
+        return str(path)
+
+
+def box_line(content: str, width: int = 68) -> str:
+    return f"  │  {content}{' ' * max(0, width - display_width(content))} │"
+
+
+def status(lang: str) -> int:
+    src = source_dir()
+    installed = "unknown"
+    available = "unknown"
+    try:
+        installed = (STATE_DIR / "version").read_text(encoding="utf-8").strip() or installed
+    except OSError:
+        pass
+    if src:
+        try:
+            available = (src / "VERSION").read_text(encoding="utf-8").strip() or available
+        except OSError:
+            pass
+
+    print(f"\n📦 {T('codex-flow status', 'codex-flow 状态', lang)}\n")
+    print("  ╭─ " + T("Version & Paths", "版本与路径", lang) + " " + "─" * (51 if lang == "en" else 55) + "╮")
+    print(box_line(f"• {T('Installed', '已安装', lang)}:   v{installed}"))
+    if src:
+        print(box_line(f"• {T('Checkout', '源码目录', lang)}:    {compact_path(src)} (v{available})"))
+    else:
+        print(box_line(f"• {T('Checkout', '源码目录', lang)}:    {T('unavailable', '不可用', lang)}"))
+    print(box_line(f"• {T('Runtime', '运行时', lang)}:     FlowPilot (flow-pilot)"))
+    if POLICY.exists():
+        print("  ├─ " + T("Strategy & Model Routing", "策略与模型路由", lang) + " " + "─" * (40 if lang == "en" else 46) + "┤")
+        strategy_enabled = policy_value("strategy", "enabled", "true")
+        strategy = policy_value("strategy", "profile", "efficient")
+        routing = policy_value("routing", "mode", "adaptive")
+        p_policy = policy_value("parent", "model_policy", "unknown")
+        p_effort = policy_value("parent", "min_reasoning_effort", "unknown")
+        w_model = policy_value("worker", "resolved_model", "unknown")
+        w_effort = policy_value("worker", "min_reasoning_effort", "unknown")
+        rollout_mode = policy_value("reasoning.rollout", "mode", "shadow")
+        rollout_map = "/".join(
+            policy_value("reasoning.rollout", key, fallback)
+            for key, fallback in (
+                ("minimum", "high"),
+                ("routine", "high"),
+                ("complex", "xhigh"),
+                ("critical", "max"),
+            )
+        )
+        t_enabled = policy_value("telemetry", "enabled", "true")
+        t_notify = policy_value("telemetry", "notifications", "false")
+        retention = policy_value("telemetry", "retention_days", "30")
+        configured = configured_language(POLICY)
+        effective = resolve_language(POLICY)
+        state = "● " + T("enabled", "已启用", lang) if strategy_enabled == "true" else "○ " + T("disabled", "已禁用", lang)
+        print(box_line(f"• {T('Strategy', '执行策略', lang)}:    {strategy} ({state})"))
+        print(box_line(f"• {T('Routing', '路由模式', lang)}:     {routing}"))
+        print(box_line(f"• {T('Reasoning rollout', '推理 rollout', lang)}: {rollout_mode} ({rollout_map})"))
+        print(box_line(f"• {T('Parent', '父 Agent', lang)}:      {p_policy} ({T('min effort', '最低推理', lang)}: {p_effort})"))
+        print(box_line(f"• {T('Worker', '子 Agent', lang)}:      {w_model} ({T('min effort', '最低推理', lang)}: {w_effort})"))
+        print(box_line(f"• {T('Telemetry', '遥测', lang)}:   {'● ' + T('enabled','已启用',lang) if t_enabled == 'true' else '○ ' + T('disabled','已禁用',lang)}"))
+        print(box_line(f"• {T('Notify', '通知', lang)}:      {'● ' + T('system notification','系统通知',lang) if t_notify == 'true' else '○ ' + T('disabled','已禁用',lang)}"))
+        print(box_line(f"• {T('Retention', '保留周期', lang)}:   {retention} {T('days per-run data', '天（单次任务数据）', lang)}"))
+        print(box_line(f"• {T('Language', '语言', lang)}:    {configured} ({T('effective', '当前生效', lang)}: {effective})"))
+    print("  ╰" + "─" * 69 + "╯\n")
+    return 0
+
+
+def language(args: list[str], lang: str) -> int:
+    if not args:
+        configured = configured_language(POLICY)
+        system = detect_system_language()
+        effective = resolve_language(POLICY)
+        print(T(
+            f"Language: configured={configured}, system={system}, effective={effective}",
+            f"语言：配置={configured}，系统={system}，当前生效={effective}",
+            lang,
+        ))
+        print(T(
+            "Set with: codex-flow language auto|zh|en",
+            "设置方式：codex-flow language auto|zh|en",
+            lang,
+        ))
+        return 0
+    if len(args) != 1:
+        print(T("Usage: codex-flow language auto|zh|en", "用法：codex-flow language auto|zh|en", lang))
+        return 2
+    try:
+        configured = set_configured_language(args[0], POLICY)
+    except ValueError:
+        print(T("Language must be auto, zh, or en.", "语言必须是 auto、zh 或 en。", lang))
+        return 2
+    effective = resolve_language(POLICY)
+    out_lang = effective
+    print(T(
+        f"Language set to {configured} (effective: {effective}).",
+        f"语言已设置为 {configured}（当前生效：{effective}）。",
+        out_lang,
+    ))
+    return 0
+
+
+def help_text(lang: str) -> int:
+    if lang == "zh":
+        print("""
+用法: codex-flow <命令> [选项]
+
+  交互控制台
+    codex-flow                  启动交互式管理控制台（TTY 下无参数）
+
+  核心命令
+    status                      查看版本与当前生效的 FlowPilot 策略
+    strategy show               查看持久化 strategy / routing
+    strategy profiles           查看 efficient/balanced/quality/speed
+    strategy set <profile>      设置默认执行策略
+    strategy enabled            查看策略分发总开关
+    strategy enable             开启 FlowPilot 自动策略分发
+    strategy disable            关闭 FlowPilot 自动策略分发
+    strategy routing <mode>     设置 adaptive/direct/delegate 路由约束
+    strategy plan [选项]        从结构化 TaskProfile 生成 ExecutionPlan(JSON)
+    language [auto|zh|en]       查看或设置界面语言（默认 auto 跟随系统）
+    update                      拉取源码、保留策略并刷新安装
+    doctor                      检查安装、策略运行时和遥测链路
+    overlay [start|stop|toggle] macOS 原生悬浮窗
+    usage last [--json]         查看最近一次任务遥测摘要
+    usage list [选项]           浏览任务历史（-n N、--project P、--today、--json）
+    usage show <#|id> [选项]    查看指定任务遥测摘要
+    usage stats [选项]          查看聚合遥测统计（--project P、--days N）
+    telemetry repair [--dry-run] 扫描并回填历史遥测可恢复字段（支持 --json）
+    telemetry latency report [--json] 查看脱敏 Worker 延迟 p50/p95
+
+  Benchmark 命令
+    benchmark-local             使用本地 Codex 会话运行内置 Benchmark
+    benchmark-corpus            仅物化测试语料，不调用模型
+    benchmark                   运行可复现的 Codex Benchmark manifest
+    benchmark-analyze           分析 Benchmark JSONL
+
+  维护
+    uninstall                   移除 codex-flow 管理的文件与 hooks
+
+  提示:
+    默认策略为 efficient，路由为 adaptive；这与旧版 FlowPilot 行为兼容。
+    strategy disable 只关闭 codex-flow 自动分发，不关闭 Codex 原生 Agent 能力。
+    对话中的明确策略/路由指令只覆盖当前任务，不修改持久化配置。
+""")
+    else:
+        print("""
+Usage: codex-flow <command> [options]
+
+  Interactive Console
+    codex-flow                  Launch the interactive management console (no args in TTY)
+
+  Core Commands
+    status                      Show installed version and effective FlowPilot strategy
+    strategy show               Show persistent strategy / routing
+    strategy profiles           List efficient/balanced/quality/speed profiles
+    strategy set <profile>      Set the default execution strategy
+    strategy enabled            Show the strategy dispatch master switch
+    strategy enable             Enable FlowPilot automatic strategy dispatch
+    strategy disable            Disable FlowPilot automatic strategy dispatch
+    strategy routing <mode>     Set adaptive/direct/delegate routing constraint
+    strategy plan [options]     Compile a structured TaskProfile to ExecutionPlan JSON
+    language [auto|zh|en]       Show or set UI language (auto follows the system)
+    update                      Pull checkout, preserve policy, refresh installation
+    doctor                      Verify installation, strategy runtime, and telemetry wiring
+    overlay [start|stop|toggle] Native macOS floating widget
+    usage last [--json]         Show the last task telemetry summary
+    usage list [options]        List task history (-n N, --project P, --today, --json)
+    usage show <#|id> [opt]     Show specific task telemetry summary
+    usage stats [options]       Show aggregated telemetry stats (--project P, --days N)
+    telemetry repair [--dry-run] Backfill recoverable fields in history (supports --json)
+    telemetry latency report [--json] Show redacted Worker latency p50/p95
+
+  Benchmark Commands
+    benchmark-local             Run built-in benchmark via local Codex session
+    benchmark-corpus            Materialize corpus without calling any model
+    benchmark                   Run a reproducible Codex benchmark manifest
+    benchmark-analyze           Analyze benchmark JSONL
+
+  Maintenance
+    uninstall                   Remove codex-flow-managed files and hooks
+
+  Tip:
+    The default is efficient + adaptive, preserving previous FlowPilot behavior.
+    strategy disable turns off codex-flow auto-dispatch, not Codex native Agent capability.
+    Explicit strategy/routing instructions in a prompt override only the current task.
+""")
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("command", nargs="?", default="help")
+    parser.add_argument("rest", nargs="*")
+    ns = parser.parse_args()
+    lang = resolve_language(POLICY)
+    if ns.command == "status":
+        return status(lang)
+    if ns.command == "language":
+        return language(ns.rest, lang)
+    return help_text(lang)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

codex_flow/data/scripts/update-homebrew-formula.py

@@ -0,0 +1,146 @@
+#!/usr/bin/env python3
+"""Update Homebrew Formula for codex-flow using release manifests."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+FORMULA_PATH = ROOT / "packaging" / "homebrew" / "codex-flow.rb"
+
+TEMPLATE = """class CodexFlow < Formula
+  desc "Intelligent, Efficient, Adaptive Multi-Agent Strategy Orchestration for Codex"
+  homepage "https://github.com/ParsifalC/codex-flow"
+  version "{version}"
+
+  on_macos do
+    if Hardware::CPU.arm?
+      url "{darwin_arm64_url}"
+      sha256 "{darwin_arm64_sha}"
+    else
+      url "{darwin_x86_64_url}"
+      sha256 "{darwin_x86_64_sha}"
+    end
+  end
+
+  on_linux do
+    if Hardware::CPU.arm?
+      url "{linux_arm64_url}"
+      sha256 "{linux_arm64_sha}"
+    else
+      url "{linux_x86_64_url}"
+      sha256 "{linux_x86_64_sha}"
+    end
+  end
+
+  def install
+    libexec.install Dir["*"]
+    bin.write_exec_script libexec/"bin/codex-flow"
+    bin.write_exec_script libexec/"bin/codex-flow-mcp"
+    bash_completion.install libexec/"completions/codex-flow.bash" => "codex-flow" if (libexec/"completions/codex-flow.bash").exist?
+  end
+
+  def caveats
+    <<~EOS
+      To initialize FlowPilot into your Codex environment, run:
+        codex-flow install
+
+      Or launch the interactive terminal console:
+        codex-flow
+    EOS
+  end
+
+  test do
+    assert_match "codex-flow", shell_output("#{{bin}}/codex-flow --help", 0)
+  end
+end
+"""
+
+
+def sync_to_tap(repo: str, token: str, branch: str, formula_content: str, version: str) -> None:
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        clone_url = f"https://x-access-token:{token}@github.com/{repo}.git"
+        print(f"Cloning {repo} ({branch})...")
+        subprocess.run(
+            ["git", "clone", "--depth", "1", "--branch", branch, clone_url, tmp_dir],
+            check=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        target = Path(tmp_dir) / "Formula" / "codex-flow.rb"
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(formula_content, encoding="utf-8")
+
+        status = subprocess.run(
+            ["git", "-C", tmp_dir, "status", "--porcelain"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        if not status.stdout.strip():
+            print(f"Formula in {repo} is already up to date for version {version}")
+            return
+
+        subprocess.run(["git", "-C", tmp_dir, "config", "user.name", "Parsifal"], check=True)
+        subprocess.run(["git", "-C", tmp_dir, "config", "user.email", "parsifal@users.noreply.github.com"], check=True)
+        subprocess.run(["git", "-C", tmp_dir, "add", "Formula/codex-flow.rb"], check=True)
+        subprocess.run(["git", "-C", tmp_dir, "commit", "-m", f"chore(formula): update codex-flow to v{version}"], check=True)
+        subprocess.run(["git", "-C", tmp_dir, "push", "origin", branch], check=True)
+        print(f"Successfully pushed updated formula to {repo} ({branch}) for version {version}")
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description="Update Homebrew formula for codex-flow")
+    parser.add_argument("--manifest", type=Path, default=ROOT / "dist" / "codex-flow-update.json")
+    parser.add_argument("--output", type=Path, default=FORMULA_PATH)
+    parser.add_argument("--tap-repo", type=str, default="", help="GitHub tap repo (e.g. ParsifalC/homebrew-tap)")
+    parser.add_argument("--tap-token", type=str, default=os.getenv("HOMEBREW_TAP_TOKEN", ""), help="GitHub token for tap repo")
+    parser.add_argument("--tap-branch", type=str, default="main", help="Tap branch to push to")
+    args = parser.parse_args()
+
+    if not args.manifest.exists():
+        raise SystemExit(f"Manifest not found: {args.manifest}")
+
+    data = json.loads(args.manifest.read_text(encoding="utf-8"))
+    version = data["version"]
+    artifacts = data["artifacts"]
+
+    content = TEMPLATE.format(
+        version=version,
+        darwin_arm64_url=artifacts["darwin-arm64"]["url"],
+        darwin_arm64_sha=artifacts["darwin-arm64"]["sha256"],
+        darwin_x86_64_url=artifacts["darwin-x86_64"]["url"],
+        darwin_x86_64_sha=artifacts["darwin-x86_64"]["sha256"],
+        linux_arm64_url=artifacts["linux-arm64"]["url"],
+        linux_arm64_sha=artifacts["linux-arm64"]["sha256"],
+        linux_x86_64_url=artifacts["linux-x86_64"]["url"],
+        linux_x86_64_sha=artifacts["linux-x86_64"]["sha256"],
+    )
+
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    args.output.write_text(content, encoding="utf-8")
+    print(f"Updated {args.output} for version {version}")
+
+    if args.tap_repo:
+        token = args.tap_token.strip()
+        if not token:
+            print(f"::warning::HOMEBREW_TAP_TOKEN is not provided. Skipping push to {args.tap_repo}.")
+        else:
+            sync_to_tap(
+                repo=args.tap_repo,
+                token=token,
+                branch=args.tap_branch,
+                formula_content=content,
+                version=version,
+            )
+
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())