@optima-chat/optima-agent 0.8.95 → 0.8.96

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

@@ -1,59 +0,0 @@
-"""Phase 3 (no-audio path): generate video via `gen video` (Wan 2.6 I2V).
-
-Usage:
-    python scripts/gen_video.py --project <name> --frame <path> \
-        [--duration 10]
-
-Use this instead of kling_generate.py when the video does NOT need audio /
-lip sync (cost ~$0.02 vs ~$1). Prompt is read from <project>/prompt.md.
-
-Gate: requires preview_confirmed.
-"""
-from __future__ import annotations
-
-import argparse
-import subprocess
-import sys
-from pathlib import Path
-
-from _gate import require_gate
-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)
-    ap.add_argument("--duration", type=int, default=10, choices=[5, 10])
-    args = ap.parse_args()
-
-    project_dir = resolve_project(args.project)
-    require_gate(project_dir, "preview_confirmed")
-
-    frame = Path(args.frame)
-    if not frame.is_file():
-        print(f"ERROR: frame not found at {frame}", file=sys.stderr)
-        return 1
-
-    prompt_path = project_dir / "prompt.md"
-    if not prompt_path.is_file():
-        print(f"ERROR: {prompt_path} missing. Write prompt.md first.", file=sys.stderr)
-        return 1
-    prompt = prompt_path.read_text(encoding="utf-8").strip()
-
-    out = next_version(project_dir / "videos", f"video_{args.duration}s_", ".mp4")
-    cmd = ["gen", "video", "-i", str(frame), "-o", str(out),
-           "-p", prompt, "--duration", str(args.duration)]
-    print(f"Running: {' '.join(cmd[:4])} … (prompt trimmed)")
-    r = subprocess.run(cmd)
-    if r.returncode != 0:
-        print(f"ERROR: gen video failed with exit {r.returncode}", file=sys.stderr)
-        return r.returncode
-
-    print(f"\nDone: {out}")
-    append_log(project_dir, f"video_generated_silent → {out.name}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

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

@@ -1,103 +0,0 @@
-"""Initialize a new video-clone project directory + phase state.
-
-Usage:
-    python scripts/init_project.py --name <project-name> --task-type video_clone
-    python scripts/init_project.py --name <project-name> --task-type video_gen
-
-Creates:
-    <gen-output>/video-clone/<name>/
-        source/
-        frames/
-        videos/
-        .state/phase.json   (copied from assets/phase-state-template.json)
-
-By default <gen-output> is `./gen-output`. Override with GEN_OUTPUT_ROOT env.
-
-Refuses to overwrite an existing project directory — pick a new name or
-bump a version suffix (e.g. handheld-phone-swap-v2).
-"""
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-
-VALID_TASK_TYPES = ("video_clone", "video_gen")
-
-SKILL_ROOT = Path(__file__).parent.parent
-TEMPLATE = SKILL_ROOT / "assets" / "phase-state-template.json"
-
-
-def _gen_output_root() -> Path:
-    override = os.environ.get("GEN_OUTPUT_ROOT")
-    if override:
-        return Path(override)
-    return Path.cwd() / "gen-output"
-
-
-def _now_iso() -> str:
-    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser(description="Initialize a video-clone project.")
-    ap.add_argument("--name", required=True, help="Project name (slug).")
-    ap.add_argument(
-        "--task-type",
-        required=True,
-        choices=VALID_TASK_TYPES,
-        help="video_clone or video_gen",
-    )
-    args = ap.parse_args()
-
-    if not TEMPLATE.is_file():
-        print(f"ERROR: state template missing at {TEMPLATE}", file=sys.stderr)
-        return 1
-
-    base = _gen_output_root() / "video-clone" / args.name
-    if base.exists():
-        print(
-            f"ERROR: project already exists at {base}\n"
-            f"Pick a new name or bump a version suffix (e.g. {args.name}-v2).",
-            file=sys.stderr,
-        )
-        return 1
-
-    for sub in ("source", "frames", "videos", ".state"):
-        (base / sub).mkdir(parents=True)
-
-    state = json.loads(TEMPLATE.read_text(encoding="utf-8"))
-    state["project"] = args.name
-    state["task_type"] = args.task_type
-    state["created_at"] = _now_iso()
-    state["history"].append({"event": "project_created", "at": state["created_at"]})
-
-    (base / ".state" / "phase.json").write_text(
-        json.dumps(state, indent=2, ensure_ascii=False), encoding="utf-8"
-    )
-
-    print(f"Created project: {base}")
-    print(f"  phase state: {base / '.state' / 'phase.json'}")
-    print()
-    print("Next steps:")
-    print("  1. (Phase 0 sanity check) Tell the user one sentence describing your")
-    print("     understanding of the task and reference workflow. Wait for 'yes'.")
-    print("  2. Run prep autonomously: analyze_source → extract_frames → write")
-    print("     prompt.md → edit_first_frame → write cost.json → preview.py")
-    print(f"  3. Show preview to user, then run:")
-    print(
-        f"       python scripts/confirm.py --project {args.name} "
-        f"--quote \"<user's actual confirmation>\""
-    )
-    print(f"  4. Run kling_generate.py / gen_video.py → assemble.py")
-    print()
-    print(f"At any time, check status:")
-    print(f"       python scripts/status.py --project {args.name}")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

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

@@ -1,106 +0,0 @@
-"""Tests for init_project.py.
-
-Uses GEN_OUTPUT_ROOT env override to isolate the tests from the real
-gen-output/ directory.
-
-Run: python scripts/init_project_test.py
-"""
-import json
-import os
-import shutil
-import subprocess
-import sys
-import tempfile
-from pathlib import Path
-
-SCRIPTS = Path(__file__).parent
-INIT = SCRIPTS / "init_project.py"
-
-
-def _run(root: Path, *args: str) -> subprocess.CompletedProcess:
-    env = os.environ.copy()
-    env["GEN_OUTPUT_ROOT"] = str(root)
-    return subprocess.run(
-        [sys.executable, str(INIT), *args],
-        capture_output=True, text=True, env=env,
-    )
-
-
-def test_creates_full_structure():
-    with tempfile.TemporaryDirectory() as tmp:
-        root = Path(tmp)
-        r = _run(root, "--name", "myproj", "--task-type", "video_clone")
-        assert r.returncode == 0, f"init failed: {r.stderr}"
-        base = root / "video-clone" / "myproj"
-        assert (base / "source").is_dir()
-        assert (base / "frames").is_dir()
-        assert (base / "videos").is_dir()
-        state_file = base / ".state" / "phase.json"
-        assert state_file.is_file()
-        state = json.loads(state_file.read_text(encoding="utf-8"))
-        assert state["project"] == "myproj"
-        assert state["task_type"] == "video_clone"
-        assert state["created_at"] is not None
-        # Single-gate model: only preview_confirmed, no plan/prompt/frame gates
-        assert "preview_confirmed" in state["gates"], (
-            f"Expected single-gate schema with 'preview_confirmed', got: {list(state['gates'])}"
-        )
-        assert state["gates"]["preview_confirmed"]["status"] is False
-        # Old 3-gate keys must NOT exist
-        for old_gate in ("plan_confirmed", "prompt_confirmed", "frame_confirmed"):
-            assert old_gate not in state["gates"], (
-                f"Old gate '{old_gate}' still present in template"
-            )
-
-
-def test_creates_video_gen_project():
-    with tempfile.TemporaryDirectory() as tmp:
-        root = Path(tmp)
-        r = _run(root, "--name", "genproj", "--task-type", "video_gen")
-        assert r.returncode == 0, f"init failed: {r.stderr}"
-        state_file = root / "video-clone" / "genproj" / ".state" / "phase.json"
-        state = json.loads(state_file.read_text(encoding="utf-8"))
-        assert state["task_type"] == "video_gen"
-        assert "preview_confirmed" in state["gates"]
-
-
-def test_rejects_duplicate():
-    with tempfile.TemporaryDirectory() as tmp:
-        root = Path(tmp)
-        _run(root, "--name", "dup", "--task-type", "video_clone")
-        r = _run(root, "--name", "dup", "--task-type", "video_clone")
-        assert r.returncode == 1, (
-            f"expected exit 1 on duplicate, got {r.returncode}\n"
-            f"stdout: {r.stdout}\nstderr: {r.stderr}"
-        )
-
-
-def test_rejects_unknown_task_type():
-    with tempfile.TemporaryDirectory() as tmp:
-        r = _run(Path(tmp), "--name", "x", "--task-type", "nonsense")
-        assert r.returncode != 0
-
-
-TESTS = [
-    ("creates full structure", test_creates_full_structure),
-    ("creates video_gen project", test_creates_video_gen_project),
-    ("rejects duplicate", test_rejects_duplicate),
-    ("rejects unknown task type", test_rejects_unknown_task_type),
-]
-
-
-def main() -> int:
-    failed = 0
-    for name, fn in TESTS:
-        try:
-            fn()
-            print(f"PASS  {name}")
-        except Exception as e:
-            failed += 1
-            print(f"FAIL  {name}: {type(e).__name__}: {e}")
-    print(f"\n{len(TESTS) - failed}/{len(TESTS)} passed")
-    return 0 if failed == 0 else 1
-
-
-if __name__ == "__main__":
-    sys.exit(main())

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

@@ -1,262 +0,0 @@
-"""Phase 3: generate video with audio via the Optima generation backend.
-
-The generation backend routes to Kling 3.0 (PiAPI) when provider="piapi".
-Billing is automatic — the server's billing middleware deducts credits from
-the user's Optima wallet at submit time and refunds on task failure.
-
-Usage:
-    python scripts/kling_generate.py --project <name> --frame <path> \
-        [--duration 10] [--aspect-ratio 9:16] [--mode std] \
-        [--cfg-scale 0.5] [--no-audio]
-
-Auth & API URL discovery (matches @optima-chat/gen-cli convention):
-    Token:
-        1. OPTIMA_TOKEN env var
-        2. ~/.optima/token.json ("access_token" field)
-    Generation API URL:
-        1. GENERATION_API_URL env var
-        2. ~/.optima/token.json ("env" field) → ci/stage/prod mapping
-        3. default: prod (https://gen-api.optima.onl)
-
-A logged-in user (`optima login`) has both automatically; no server-side
-env injection is required.
-
-Pipeline:
-    1. Gate: requires preview_confirmed.
-    2. POST <GEN_URL>/api/video/generate with provider="piapi" + base64 frame.
-       Server-side billing middleware pre-deducts credits here.
-    3. Poll GET <GEN_URL>/api/task/{id} every 10s until completed/failed.
-    4. Download result_url to <project>/videos/ (3-attempt retry).
-
-Reads prompt from <project>/prompt.md. Writes output with a versioned filename.
-"""
-from __future__ import annotations
-
-import argparse
-import base64
-import json
-import os
-import sys
-import time
-from pathlib import Path
-
-from _gate import require_gate
-from _project import resolve_project, next_version, append_log
-
-try:
-    import requests  # type: ignore
-except ImportError:  # pragma: no cover
-    requests = None
-
-POLL_INTERVAL_S = 10
-POLL_TIMEOUT_S = 15 * 60  # 15 min (server side uses 10 min, leave 5 min headroom)
-DOWNLOAD_RETRIES = 3
-DOWNLOAD_BACKOFF_S = 5
-
-TOKEN_FILE = Path.home() / ".optima" / "token.json"
-API_URLS = {
-    "prod": "https://gen-api.optima.onl",
-    "stage": "https://gen-api.stage.optima.onl",
-}
-
-
-def _load_token_file() -> dict | None:
-    """Read ~/.optima/token.json if present. Returns parsed dict or None."""
-    if not TOKEN_FILE.is_file():
-        return None
-    try:
-        data = json.loads(TOKEN_FILE.read_text(encoding="utf-8"))
-    except (OSError, json.JSONDecodeError):
-        return None
-    if not data.get("access_token"):
-        return None
-    return data
-
-
-def _get_token() -> str:
-    """Resolve the Optima auth token.
-
-    Order matches @optima-chat/gen-cli: env var > token.json. Fail fast with
-    a login hint if neither is available.
-    """
-    env_token = os.environ.get("OPTIMA_TOKEN", "").strip()
-    if env_token:
-        return env_token
-    data = _load_token_file()
-    if data:
-        return data["access_token"]
-    print(
-        "ERROR: Optima token not found. Set OPTIMA_TOKEN or run `optima login`.",
-        file=sys.stderr,
-    )
-    sys.exit(1)
-
-
-def _get_gen_api_url() -> str:
-    """Resolve the generation service base URL.
-
-    Order matches @optima-chat/gen-cli: GENERATION_API_URL > token.json env
-    field > prod default.
-    """
-    override = os.environ.get("GENERATION_API_URL", "").strip()
-    if override:
-        return override.rstrip("/")
-    data = _load_token_file()
-    env = (data or {}).get("env") or "prod"
-    return API_URLS.get(env, API_URLS["prod"])
-
-
-def _auth_header(token: str) -> str:
-    """Accept either 'Bearer xxx' or a raw token; normalize to Bearer form."""
-    return token if token.lower().startswith("bearer ") else f"Bearer {token}"
-
-
-def _submit(gen_url: str, auth: str, prompt: str, frame_b64: str,
-            duration: int, aspect: str, mode: str,
-            cfg: float, audio: bool) -> str:
-    """POST /api/video/generate with provider='piapi'. Returns backend task_id.
-
-    On billing failure the server returns 402 (INSUFFICIENT_CREDITS) or
-    403 (PLAN_RESTRICTED); both are surfaced as actionable errors.
-    """
-    payload = {
-        "provider": "piapi",
-        "image": frame_b64,
-        "prompt": prompt,
-        "duration": duration,
-        "aspect_ratio": aspect,
-        "mode": mode,
-        "cfg_scale": float(cfg),
-        "enable_audio": audio,
-    }
-    r = requests.post(
-        f"{gen_url}/api/video/generate",
-        headers={"Authorization": auth, "Content-Type": "application/json"},
-        json=payload, timeout=60,
-    )
-    if r.status_code == 402:
-        raise RuntimeError(f"INSUFFICIENT_CREDITS: {r.json().get('error', {}).get('message', 'not enough credits')}")
-    if r.status_code == 403:
-        raise RuntimeError(f"PLAN_RESTRICTED: {r.json().get('error', {}).get('message', 'plan does not include video generation')}")
-    r.raise_for_status()
-    return r.json()["task_id"]
-
-
-def _poll(gen_url: str, auth: str, task_id: str) -> tuple[str, dict]:
-    """Poll /api/task/{id} until completed or failed. Returns (result_url, result_meta).
-
-    On client-side timeout the task may still complete server-side (credits
-    already deducted). The task_id is included in the timeout message so the
-    caller can re-check later via GET /api/task/<id>.
-    """
-    start = time.monotonic()
-    while True:
-        if time.monotonic() - start > POLL_TIMEOUT_S:
-            raise RuntimeError(
-                f"polling timed out after {POLL_TIMEOUT_S}s (task_id={task_id}). "
-                f"Task may still complete server-side — query "
-                f"GET /api/task/{task_id} to check status and retrieve the result."
-            )
-        r = requests.get(
-            f"{gen_url}/api/task/{task_id}",
-            headers={"Authorization": auth}, timeout=60,
-        )
-        r.raise_for_status()
-        d = r.json()
-        status = d.get("status", "")
-        if status == "completed":
-            url = d.get("result_url")
-            if not url:
-                raise RuntimeError(
-                    f"task {task_id} completed but result_url missing from response"
-                )
-            return url, d.get("result_meta") or {}
-        if status == "failed":
-            raise RuntimeError(d.get("error_message") or f"task {task_id} failed without error message")
-        print(f"  status: {status} — polling again in {POLL_INTERVAL_S}s")
-        time.sleep(POLL_INTERVAL_S)
-
-
-def _download(url: str, out: Path) -> None:
-    last_err = None
-    for attempt in range(DOWNLOAD_RETRIES):
-        try:
-            r = requests.get(url, timeout=300)
-            r.raise_for_status()
-            out.write_bytes(r.content)
-            return
-        except Exception as e:
-            last_err = e
-            print(f"  download attempt {attempt + 1}/{DOWNLOAD_RETRIES} failed: {e}")
-            time.sleep(DOWNLOAD_BACKOFF_S)
-    raise RuntimeError(f"download failed after {DOWNLOAD_RETRIES} attempts: {last_err}")
-
-
-def main() -> int:
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--project", required=True)
-    ap.add_argument("--frame", required=True, help="confirmed first frame")
-    ap.add_argument("--duration", type=int, default=10, choices=[5, 10])
-    ap.add_argument("--aspect-ratio", default="9:16")
-    ap.add_argument("--mode", default="std", choices=["std", "pro"])
-    ap.add_argument("--cfg-scale", type=float, default=0.5)
-    ap.add_argument("--no-audio", action="store_true")
-    args = ap.parse_args()
-
-    project_dir = resolve_project(args.project)
-    require_gate(project_dir, "preview_confirmed")
-
-    if requests is None:
-        print("ERROR: the 'requests' package is required. Install: pip install requests",
-              file=sys.stderr)
-        return 1
-
-    gen_url = _get_gen_api_url()
-    auth = _auth_header(_get_token())
-
-    frame = Path(args.frame)
-    if not frame.is_file():
-        print(f"ERROR: frame not found at {frame}", file=sys.stderr)
-        return 1
-
-    prompt_path = project_dir / "prompt.md"
-    if not prompt_path.is_file():
-        print(f"ERROR: {prompt_path} missing. Write prompt.md first.", file=sys.stderr)
-        return 1
-    prompt = prompt_path.read_text(encoding="utf-8").strip()
-
-    frame_b64 = base64.b64encode(frame.read_bytes()).decode()
-
-    print("Submitting video generation task …")
-    try:
-        task_id = _submit(
-            gen_url, auth, prompt, frame_b64,
-            duration=args.duration, aspect=args.aspect_ratio, mode=args.mode,
-            cfg=args.cfg_scale, audio=not args.no_audio,
-        )
-    except RuntimeError as e:
-        print(f"ERROR: {e}", file=sys.stderr)
-        return 1
-    print(f"  task_id: {task_id}")
-
-    print("Polling for completion …")
-    try:
-        result_url, result_meta = _poll(gen_url, auth, task_id)
-    except RuntimeError as e:
-        print(f"ERROR: {e}", file=sys.stderr)
-        return 1
-    print(f"  result_url: {result_url}")
-    if result_meta:
-        print(f"  result_meta: {result_meta}")
-
-    out = next_version(project_dir / "videos", f"video_{args.duration}s_", ".mp4")
-    print(f"Downloading → {out}")
-    _download(result_url, out)
-
-    print(f"\nDone: {out}")
-    append_log(project_dir, f"video_generated_with_audio → {out.name} (task {task_id})")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())