@optima-chat/optima-agent 0.8.95 → 0.8.97

package/.claude/skills/video-clone/scripts/_gate_test.py

@@ -1,148 +0,0 @@
-"""Unit tests for _gate.py — single-gate model + caller audit + old-schema rejection."""
-from __future__ import annotations
-
-import json
-import sys
-import tempfile
-from pathlib import Path
-
-# Add scripts dir to path so we can import _gate directly.
-SCRIPTS_DIR = Path(__file__).parent
-sys.path.insert(0, str(SCRIPTS_DIR))
-
-import _gate  # noqa: E402
-
-TEMPLATE = json.loads(
-    (SCRIPTS_DIR.parent / "assets" / "phase-state-template.json").read_text(encoding="utf-8")
-)
-
-
-def _fresh_project(tmp: Path, name: str = "p1") -> Path:
-    p = tmp / name
-    (p / ".state").mkdir(parents=True)
-    state = json.loads(json.dumps(TEMPLATE))  # deep copy
-    state["project"] = name
-    state["task_type"] = "video_clone"
-    (p / ".state" / "phase.json").write_text(json.dumps(state), encoding="utf-8")
-    return p
-
-
-def test_set_gate_writes_caller_to_history():
-    with tempfile.TemporaryDirectory() as td:
-        p = _fresh_project(Path(td))
-        _gate.set_gate(p, "preview_confirmed", "OK 开始", caller="confirm.py")
-        state = _gate.load_state(p)
-        history = state["history"]
-        assert len(history) == 1
-        assert history[0]["event"] == "preview_confirmed"
-        assert history[0]["caller"] == "confirm.py"
-        assert history[0]["user_quote"] == "OK 开始"
-        assert state["gates"]["preview_confirmed"]["status"] is True
-    print("PASS test_set_gate_writes_caller_to_history")
-
-
-def test_set_gate_missing_caller_raises_typeerror():
-    with tempfile.TemporaryDirectory() as td:
-        p = _fresh_project(Path(td))
-        try:
-            _gate.set_gate(p, "preview_confirmed", "OK")  # type: ignore[call-arg]
-        except TypeError:
-            print("PASS test_set_gate_missing_caller_raises_typeerror")
-            return
-        raise AssertionError("expected TypeError")
-
-
-def test_set_gate_empty_caller_raises_valueerror():
-    with tempfile.TemporaryDirectory() as td:
-        p = _fresh_project(Path(td))
-        try:
-            _gate.set_gate(p, "preview_confirmed", "OK", caller="   ")
-        except ValueError:
-            print("PASS test_set_gate_empty_caller_raises_valueerror")
-            return
-        raise AssertionError("expected ValueError")
-
-
-def test_set_gate_records_literal_caller_value():
-    """Bypass via 'caller=ad-hoc' is allowed but leaves visible evidence."""
-    with tempfile.TemporaryDirectory() as td:
-        p = _fresh_project(Path(td))
-        _gate.set_gate(p, "preview_confirmed", "ok", caller="ad-hoc")
-        history = _gate.load_state(p)["history"]
-        assert history[0]["caller"] == "ad-hoc"
-    print("PASS test_set_gate_records_literal_caller_value")
-
-
-def test_require_gate_unset_exits_one():
-    with tempfile.TemporaryDirectory() as td:
-        p = _fresh_project(Path(td))
-        try:
-            _gate.require_gate(p, "preview_confirmed")
-        except SystemExit as e:
-            assert e.code == 1
-            print("PASS test_require_gate_unset_exits_one")
-            return
-        raise AssertionError("expected SystemExit(1)")
-
-
-def test_require_gate_set_returns_none():
-    with tempfile.TemporaryDirectory() as td:
-        p = _fresh_project(Path(td))
-        _gate.set_gate(p, "preview_confirmed", "ok", caller="confirm.py")
-        assert _gate.require_gate(p, "preview_confirmed") is None
-    print("PASS test_require_gate_set_returns_none")
-
-
-def test_old_3gate_schema_rejected():
-    """An old PR #65 phase.json should be rejected, not silently mishandled."""
-    with tempfile.TemporaryDirectory() as td:
-        p = Path(td) / "old"
-        (p / ".state").mkdir(parents=True)
-        old_state = {
-            "schema_version": 1,
-            "project": "old",
-            "task_type": "video_clone",
-            "created_at": "2026-01-01T00:00:00Z",
-            "current_phase": 0,
-            "gates": {
-                "plan_confirmed":   {"status": False, "confirmed_at": None, "user_quote": None},
-                "prompt_confirmed": {"status": False, "confirmed_at": None, "user_quote": None},
-                "frame_confirmed":  {"status": False, "confirmed_at": None, "user_quote": None},
-            },
-            "history": [],
-        }
-        (p / ".state" / "phase.json").write_text(json.dumps(old_state), encoding="utf-8")
-        try:
-            _gate.require_gate(p, "preview_confirmed")
-        except SystemExit as e:
-            assert e.code == 1
-            print("PASS test_old_3gate_schema_rejected")
-            return
-        raise AssertionError("expected SystemExit(1)")
-
-
-def test_save_state_atomic():
-    """Verify save_state writes via tmp+replace (no partial-write race)."""
-    with tempfile.TemporaryDirectory() as td:
-        p = _fresh_project(Path(td))
-        state = _gate.load_state(p)
-        state["project"] = "renamed"
-        _gate.save_state(p, state)
-        # Verify no orphan .json.tmp file
-        tmp = (p / ".state" / "phase.json.tmp")
-        assert not tmp.exists()
-        # Verify the new value persisted
-        assert _gate.load_state(p)["project"] == "renamed"
-    print("PASS test_save_state_atomic")
-
-
-if __name__ == "__main__":
-    test_set_gate_writes_caller_to_history()
-    test_set_gate_missing_caller_raises_typeerror()
-    test_set_gate_empty_caller_raises_valueerror()
-    test_set_gate_records_literal_caller_value()
-    test_require_gate_unset_exits_one()
-    test_require_gate_set_returns_none()
-    test_old_3gate_schema_rejected()
-    test_save_state_atomic()
-    print("\nAll 8 _gate tests passed.")

package/.claude/skills/video-clone/scripts/_project.py

@@ -1,56 +0,0 @@
-"""Tiny helper to resolve a project directory under gen-output/video-clone/.
-
-Used by all executor scripts so they share the same GEN_OUTPUT_ROOT convention.
-"""
-from __future__ import annotations
-
-import os
-import sys
-from pathlib import Path
-
-
-def gen_output_root() -> Path:
-    override = os.environ.get("GEN_OUTPUT_ROOT")
-    if override:
-        return Path(override)
-    return Path.cwd() / "gen-output"
-
-
-def resolve_project(name: str) -> Path:
-    path = gen_output_root() / "video-clone" / name
-    if not path.is_dir():
-        print(
-            f"ERROR: project directory not found at {path}\n"
-            f"Run: python scripts/init_project.py --name {name} --task-type video_clone",
-            file=sys.stderr,
-        )
-        sys.exit(1)
-    return path
-
-
-def next_version(dir_path: Path, prefix: str, suffix: str) -> Path:
-    """Return dir_path / f'{prefix}v{N}{suffix}' with N = highest existing + 1.
-
-    Example: next_version(frames_dir, 'frame_', '.png') →
-             frames_dir/frame_v3.png  (if v1, v2 already exist)
-    """
-    n = 1
-    while (dir_path / f"{prefix}v{n}{suffix}").exists():
-        n += 1
-    return dir_path / f"{prefix}v{n}{suffix}"
-
-
-def append_log(project_dir: Path, event: str) -> None:
-    """Append one human-readable event line to <project_dir>/log.md.
-
-    Format: 'HH:MM:SS  <event>'. Used by status.py to render the History
-    section. This is the human-readable ledger; phase.json:history[] is the
-    machine-significance audit ledger and stays gate-events-only.
-    """
-    from datetime import datetime, timezone
-    log = project_dir / "log.md"
-    line = f"{datetime.now(timezone.utc).strftime('%H:%M:%S')}  {event}\n"
-    if not log.exists():
-        log.write_text("# Log\n\n", encoding="utf-8")
-    with log.open("a", encoding="utf-8") as f:
-        f.write(line)

package/.claude/skills/video-clone/scripts/analyze_source.py

@@ -1,113 +0,0 @@
-"""Phase 1: analyze a source video — ffprobe metadata + scene detection.
-
-Usage:
-    python scripts/analyze_source.py --project <name> --video <path-or-url>
-
-Behavior:
-    1. No gate required. Runs autonomously as part of prep.
-    2. If --video looks like a URL, the caller must download it first; this
-       script operates on a local file path only (downloads are caller's job,
-       because platform parsing is listed in references/url-parsing.md).
-    3. Runs ffprobe to extract duration, resolution, fps, codec info.
-    4. Runs ffmpeg scene detection with select='gt(scene,0.3)' and reports
-       cut count → single or multi-segment classification.
-    5. Writes analysis to <project>/source/analysis.json (versioned).
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import re
-import subprocess
-import sys
-from fractions import Fraction
-from pathlib import Path
-
-from _project import resolve_project, next_version, append_log
-
-
-def _ffprobe(video: Path) -> dict:
-    r = subprocess.run(
-        ["ffprobe", "-v", "quiet", "-print_format", "json",
-         "-show_format", "-show_streams", str(video)],
-        capture_output=True, text=True, check=True,
-    )
-    return json.loads(r.stdout)
-
-
-def _scene_detect(video: Path) -> list[float]:
-    """Return list of scene-change timestamps (seconds)."""
-    r = subprocess.run(
-        ["ffmpeg", "-hide_banner", "-i", str(video),
-         "-vf", "select='gt(scene,0.3)',showinfo",
-         "-vsync", "vfr", "-f", "null", "-"],
-        capture_output=True, text=True,
-    )
-    # scene-change info shows up on stderr
-    return [float(m.group(1)) for m in re.finditer(r"pts_time:(\d+\.?\d*)", r.stderr)]
-
-
-def _parse_fps(rate: str | None) -> float | None:
-    """Parse ffprobe avg_frame_rate ('30000/1001') into a float, safely.
-
-    Replaces the old eval()-based parsing. Returns None for malformed input
-    instead of raising.
-    """
-    if not rate:
-        return None
-    try:
-        return float(Fraction(rate))
-    except (ValueError, ZeroDivisionError):
-        return None
-
-
-def _summarize(meta: dict) -> dict:
-    fmt = meta.get("format", {})
-    streams = meta.get("streams", [])
-    vstream = next((s for s in streams if s.get("codec_type") == "video"), {})
-    astream = next((s for s in streams if s.get("codec_type") == "audio"), {})
-    return {
-        "duration_s": float(fmt.get("duration", 0)),
-        "width": vstream.get("width"),
-        "height": vstream.get("height"),
-        "fps": _parse_fps(vstream.get("avg_frame_rate")) if vstream else None,
-        "vcodec": vstream.get("codec_name"),
-        "has_audio": bool(astream),
-        "acodec": astream.get("codec_name"),
-    }
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--project", required=True)
-    ap.add_argument("--video", required=True, help="local path to source video")
-    args = ap.parse_args()
-
-    project_dir = resolve_project(args.project)
-
-    video = Path(args.video)
-    if not video.is_file():
-        print(f"ERROR: video not found at {video}", file=sys.stderr)
-        return 1
-
-    print(f"Analyzing {video} …")
-    meta = _ffprobe(video)
-    summary = _summarize(meta)
-    cuts = _scene_detect(video)
-    cuts_significant = [t for t in cuts if t > 0.5]
-    segment_count = 1 if len(cuts_significant) <= 1 else len(cuts_significant) + 1
-
-    summary["scene_cuts"] = cuts_significant
-    summary["segments"] = segment_count
-    summary["classification"] = "multi" if segment_count >= 2 else "single"
-
-    out = next_version(project_dir / "source", "analysis_", ".json")
-    out.write_text(json.dumps(summary, indent=2, ensure_ascii=False), encoding="utf-8")
-    print(json.dumps(summary, indent=2, ensure_ascii=False))
-    print(f"\nWrote: {out}")
-    append_log(project_dir, f"analysis_completed → {out.name}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/.claude/skills/video-clone/scripts/analyze_source_test.py

@@ -1,52 +0,0 @@
-"""Unit tests for analyze_source._parse_fps — verifies the eval()→Fraction migration (R3)."""
-from __future__ import annotations
-
-import sys
-from pathlib import Path
-
-SCRIPTS_DIR = Path(__file__).parent
-sys.path.insert(0, str(SCRIPTS_DIR))
-
-from analyze_source import _parse_fps  # noqa: E402
-
-
-def test_parse_fps_30000_over_1001():
-    result = _parse_fps("30000/1001")
-    assert result is not None
-    assert abs(result - 29.97002997) < 1e-6
-    print("PASS test_parse_fps_30000_over_1001")
-
-
-def test_parse_fps_30_over_1():
-    assert _parse_fps("30/1") == 30.0
-    print("PASS test_parse_fps_30_over_1")
-
-
-def test_parse_fps_zero_over_zero():
-    assert _parse_fps("0/0") is None
-    print("PASS test_parse_fps_zero_over_zero")
-
-
-def test_parse_fps_garbage():
-    assert _parse_fps("abc") is None
-    print("PASS test_parse_fps_garbage")
-
-
-def test_parse_fps_none():
-    assert _parse_fps(None) is None
-    print("PASS test_parse_fps_none")
-
-
-def test_parse_fps_empty():
-    assert _parse_fps("") is None
-    print("PASS test_parse_fps_empty")
-
-
-if __name__ == "__main__":
-    test_parse_fps_30000_over_1001()
-    test_parse_fps_30_over_1()
-    test_parse_fps_zero_over_zero()
-    test_parse_fps_garbage()
-    test_parse_fps_none()
-    test_parse_fps_empty()
-    print("\nAll 6 _parse_fps tests passed.")

package/.claude/skills/video-clone/scripts/assemble.py

@@ -1,106 +0,0 @@
-"""Phase 4: post-process and assemble the final video.
-
-Usage:
-    # single-segment — normalize only
-    python scripts/assemble.py --project <name> --single videos/video_v1_10s.mp4
-
-    # multi-segment — normalize each + concat
-    python scripts/assemble.py --project <name> \
-        --multi videos/scene1_v1_5s.mp4 videos/scene2_v1_5s.mp4
-
-Writes to <project>/videos/final_v{N}.mp4 (versioned).
-
-No gate: post-processing always runs on already-generated videos, which by
-definition must have passed the preview_confirmed gate.
-"""
-from __future__ import annotations
-
-import argparse
-import subprocess
-import sys
-from pathlib import Path
-
-from _project import resolve_project, next_version, append_log
-
-
-def _normalize_single(video: Path, out: Path) -> None:
-    subprocess.run(
-        ["ffmpeg", "-y", "-i", str(video),
-         "-r", "30", "-c:v", "libx264", "-crf", "18",
-         "-c:a", "aac", "-b:a", "192k",
-         str(out)],
-        check=True,
-    )
-
-
-def _normalize_clip(video: Path, out: Path) -> None:
-    subprocess.run(
-        ["ffmpeg", "-y", "-i", str(video),
-         "-vf", "scale=720:1280", "-r", "30",
-         "-c:v", "libx264", "-crf", "18",
-         "-c:a", "aac", "-b:a", "128k",
-         str(out)],
-        check=True,
-    )
-
-
-def _concat(norm_clips: list[Path], out: Path, workdir: Path) -> None:
-    concat_list = workdir / "concat_list.txt"
-    concat_list.write_text(
-        "\n".join(f"file '{p.name}'" for p in norm_clips) + "\n",
-        encoding="utf-8",
-    )
-    subprocess.run(
-        ["ffmpeg", "-y", "-f", "concat", "-safe", "0",
-         "-i", str(concat_list),
-         "-c:v", "libx264", "-crf", "18",
-         "-c:a", "aac", "-b:a", "192k",
-         str(out)],
-        check=True, cwd=workdir,
-    )
-    concat_list.unlink(missing_ok=True)
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--project", required=True)
-    group = ap.add_mutually_exclusive_group(required=True)
-    group.add_argument("--single", help="single video to normalize")
-    group.add_argument("--multi", nargs="+", help="2+ videos to normalize and concat")
-    args = ap.parse_args()
-
-    project_dir = resolve_project(args.project)
-    videos_dir = project_dir / "videos"
-    out = next_version(videos_dir, "final_", ".mp4")
-
-    if args.single:
-        src = Path(args.single)
-        if not src.is_absolute():
-            src = project_dir / args.single
-        if not src.is_file():
-            print(f"ERROR: {src} not found", file=sys.stderr)
-            return 1
-        _normalize_single(src, out)
-    else:
-        norm_clips = []
-        for i, clip in enumerate(args.multi, 1):
-            src = Path(clip)
-            if not src.is_absolute():
-                src = project_dir / clip
-            if not src.is_file():
-                print(f"ERROR: {src} not found", file=sys.stderr)
-                return 1
-            norm = videos_dir / f"_norm_{i}.mp4"
-            _normalize_clip(src, norm)
-            norm_clips.append(norm)
-        _concat(norm_clips, out, videos_dir)
-        for n in norm_clips:
-            n.unlink(missing_ok=True)
-
-    print(f"\nFinal video: {out}")
-    append_log(project_dir, f"assembled → {out.name}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/.claude/skills/video-clone/scripts/confirm.py

@@ -1,12 +0,0 @@
-"""Entry point: record user confirmation for preview_confirmed.
-
-Usage:
-    python scripts/confirm.py --project <name> --quote "<verbatim user words>"
-
-The actual logic lives in _confirm.run_confirm().
-"""
-import sys
-from _confirm import run_confirm
-
-if __name__ == "__main__":
-    sys.exit(run_confirm())

package/.claude/skills/video-clone/scripts/edit_first_frame.py

@@ -1,66 +0,0 @@
-"""Phase 2: edit the first frame — swap product via gen image.
-
-Usage:
-    python scripts/edit_first_frame.py --project <name> --frame <path> \
-        --product <path> --prompt "<instruction>" [--seed <int>]
-
-Behavior:
-    - No gate required. Runs autonomously as part of prep.
-    - Invokes `gen image -i <frame> -i <product>` with the given prompt.
-    - Writes output to <project>/frames/frame_v{N}.png (versioned, never
-      overwrites).
-    - Prints the output path so the caller can show it to the user in
-      the preview bundle.
-
-The --prompt argument is the *image edit instruction* (e.g. "swap the coffee
-cup on the table for this water bottle, match lighting"), not the motion
-prompt used for video generation.
-"""
-from __future__ import annotations
-
-import argparse
-import subprocess
-import sys
-from pathlib import Path
-
-from _project import resolve_project, next_version, append_log
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--project", required=True)
-    ap.add_argument("--frame", required=True, help="source frame image")
-    ap.add_argument("--product", required=True, help="product reference image")
-    ap.add_argument("--prompt", required=True, help="image edit instruction")
-    ap.add_argument("--seed", type=int, default=None)
-    args = ap.parse_args()
-
-    project_dir = resolve_project(args.project)
-
-    frame = Path(args.frame)
-    product = Path(args.product)
-    for p, label in ((frame, "frame"), (product, "product")):
-        if not p.is_file():
-            print(f"ERROR: {label} not found at {p}", file=sys.stderr)
-            return 1
-
-    out = next_version(project_dir / "frames", "frame_", ".png")
-    cmd = ["gen", "image", "-i", str(frame), "-i", str(product),
-           "-o", str(out), "-p", args.prompt]
-    if args.seed is not None:
-        cmd += ["--seed", str(args.seed)]
-
-    print(f"Running: {' '.join(cmd)}")
-    r = subprocess.run(cmd)
-    if r.returncode != 0:
-        print(f"ERROR: gen image failed with exit {r.returncode}", file=sys.stderr)
-        return r.returncode
-
-    print(f"\nEdited frame: {out}")
-    print("This frame will be included in the preview bundle.")
-    append_log(project_dir, f"first_frame_edited → {out.name}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/.claude/skills/video-clone/scripts/extract_frames.py

@@ -1,108 +0,0 @@
-"""Phase 1: extract equidistant frames from a video for Claude Opus analysis.
-
-Usage:
-    python scripts/extract_frames.py --project <name> --video <path> [--count 10] [--grid]
-
-Behavior:
-    - No gate required. Runs autonomously as part of prep.
-    - Extracts N equidistant frames to <project>/frames/extract_vN/ via ffmpeg.
-    - If --grid is passed, additionally stitches frames into a 5×2 (or 3×4)
-      contact sheet with ffmpeg's tile filter — this is what Claude Opus
-      reads for frame-by-frame analysis.
-
-The frame set is the input to Phase 1 prompt generation. Each call creates a
-new versioned subdirectory so earlier extractions are preserved.
-"""
-from __future__ import annotations
-
-import argparse
-import subprocess
-import sys
-from pathlib import Path
-
-from _project import resolve_project, next_version, append_log
-
-
-def _duration(video: Path) -> float:
-    r = subprocess.run(
-        ["ffprobe", "-v", "quiet", "-show_entries", "format=duration",
-         "-of", "default=noprint_wrappers=1:nokey=1", str(video)],
-        capture_output=True, text=True, check=True,
-    )
-    return float(r.stdout.strip())
-
-
-def _extract_at(video: Path, t: float, out: Path) -> None:
-    subprocess.run(
-        ["ffmpeg", "-hide_banner", "-loglevel", "error", "-y",
-         "-ss", f"{t:.2f}", "-i", str(video),
-         "-frames:v", "1", "-q:v", "2", str(out)],
-        check=True,
-    )
-
-
-def _tile(frames: list[Path], out: Path, cols: int, rows: int) -> None:
-    # use ffmpeg concat + tile to build a contact sheet
-    # write a temp concat list of still images
-    concat = out.parent / "_concat.txt"
-    concat.write_text(
-        "\n".join(f"file '{p.as_posix()}'\nduration 0.04" for p in frames)
-        + f"\nfile '{frames[-1].as_posix()}'\n",
-        encoding="utf-8",
-    )
-    subprocess.run(
-        ["ffmpeg", "-hide_banner", "-loglevel", "error", "-y",
-         "-f", "concat", "-safe", "0", "-i", str(concat),
-         "-vf", f"tile={cols}x{rows}", "-frames:v", "1", str(out)],
-        check=True,
-    )
-    concat.unlink(missing_ok=True)
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--project", required=True)
-    ap.add_argument("--video", required=True)
-    ap.add_argument("--count", type=int, default=10)
-    ap.add_argument("--grid", action="store_true")
-    args = ap.parse_args()
-
-    project_dir = resolve_project(args.project)
-
-    video = Path(args.video)
-    if not video.is_file():
-        print(f"ERROR: video not found at {video}", file=sys.stderr)
-        return 1
-
-    dur = _duration(video)
-    if dur <= 0:
-        print(f"ERROR: could not read duration from {video}", file=sys.stderr)
-        return 1
-
-    frames_root = project_dir / "frames"
-    out_dir = next_version(frames_root, "extract_", "")
-    out_dir.mkdir(parents=True)
-
-    step = dur / (args.count + 1)
-    frames = []
-    for i in range(1, args.count + 1):
-        t = step * i
-        p = out_dir / f"frame_{i:02d}_t{t:.2f}s.jpg"
-        _extract_at(video, t, p)
-        frames.append(p)
-        print(f"  extracted t={t:.2f}s → {p.name}")
-
-    if args.grid and frames:
-        cols = 5 if args.count % 5 == 0 else 4
-        rows = (args.count + cols - 1) // cols
-        grid_out = out_dir / "grid.jpg"
-        _tile(frames, grid_out, cols, rows)
-        print(f"\nGrid: {grid_out}")
-
-    print(f"\nExtracted {len(frames)} frames to {out_dir}")
-    append_log(project_dir, f"frames_extracted → {out_dir.name}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())