@optima-chat/optima-agent 0.8.91 → 0.8.92

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

@@ -0,0 +1,106 @@
+"""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

@@ -0,0 +1,182 @@
+"""Phase 3: generate video via Kling 3.0 over PiAPI.
+
+Usage:
+    python scripts/kling_generate.py --project <name> --frame <path> \
+        [--duration 10] [--aspect-ratio 9:16] [--mode std] \
+        [--cfg-scale 0.5] [--no-audio]
+
+Pipeline (ported verbatim from references/kling-api.md):
+    1. Gate: requires preview_confirmed.
+    2. Upload first frame to freeimage.host → get public URL.
+    3. POST /api/v1/task to PiAPI with kling model + 3.0 params.
+    4. Poll /api/v1/task/{id} every 15s until status=='completed'.
+    5. Download mp4 with 3-attempt retry (5s backoff).
+
+Reads prompt from <project>/prompt.md. Writes output to <project>/videos/
+with a versioned filename.
+
+Requires: PIAPI_KEY env var. Run `python scripts/preflight.py` first if unsure.
+"""
+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
+
+# Lazy import of requests so py_compile / gate checks work without the dep.
+try:
+    import requests  # type: ignore
+except ImportError:  # pragma: no cover
+    requests = None
+
+FREEIMAGE_KEY = "6d207e02198a847aa98d0a2a901485a5"
+FREEIMAGE_URL = "https://freeimage.host/api/1/upload"
+PIAPI_BASE = "https://api.piapi.ai/api/v1"
+DEFAULT_NEGATIVE = (
+    "slow motion, dreamy, ethereal, cinematic, blurry, "
+    "distorted, deformed hands, extra fingers"
+)
+
+
+def _upload_frame(frame: Path) -> str:
+    img_b64 = base64.b64encode(frame.read_bytes()).decode()
+    r = requests.post(
+        FREEIMAGE_URL,
+        data={"key": FREEIMAGE_KEY, "action": "upload",
+              "source": img_b64, "format": "json"},
+        timeout=60,
+    )
+    r.raise_for_status()
+    data = r.json()
+    return data["image"]["url"]
+
+
+def _submit(api_key: str, prompt: str, image_url: str,
+            duration: int, aspect: str, mode: str,
+            cfg: float, audio: bool) -> str:
+    payload = {
+        "model": "kling",
+        "task_type": "video_generation",
+        "input": {
+            "prompt": prompt,
+            "negative_prompt": DEFAULT_NEGATIVE,
+            "image_url": image_url,
+            "duration": duration,
+            "aspect_ratio": aspect,
+            "mode": mode,
+            "version": "3.0",
+            "cfg_scale": float(cfg),  # MUST be float
+            "enable_audio": audio,
+        },
+        "config": {"service_mode": "public"},
+    }
+    r = requests.post(
+        f"{PIAPI_BASE}/task",
+        headers={"x-api-key": api_key, "Content-Type": "application/json"},
+        json=payload, timeout=60,
+    )
+    r.raise_for_status()
+    return r.json()["data"]["task_id"]
+
+
+def _poll(api_key: str, task_id: str) -> str:
+    while True:
+        r = requests.get(
+            f"{PIAPI_BASE}/task/{task_id}",
+            headers={"x-api-key": api_key}, timeout=60,
+        )
+        r.raise_for_status()
+        d = r.json().get("data", {})
+        status = d.get("status", "")
+        if status == "completed":
+            return d["output"]["video"]  # 3.0 uses output.video
+        if status == "failed":
+            raise RuntimeError(d.get("error", d))
+        print(f"  status: {status} — polling again in 15s")
+        time.sleep(15)
+
+
+def _download(url: str, out: Path) -> None:
+    last_err = None
+    for attempt in range(3):
+        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}/3 failed: {e}")
+            time.sleep(5)
+    raise RuntimeError(f"download failed after 3 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
+
+    api_key = os.environ.get("PIAPI_KEY", "2fccd94d5825b15840a27b8110e077b29ee3adb38c62fedd95d9e922ad440954")
+    if not api_key:
+        print("ERROR: PIAPI_KEY env var not set. See preflight.py.", file=sys.stderr)
+        return 1
+
+    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()
+
+    print("Uploading frame to freeimage.host …")
+    image_url = _upload_frame(frame)
+    print(f"  image_url: {image_url}")
+
+    print("Submitting video generation task …")
+    task_id = _submit(
+        api_key, prompt, image_url,
+        duration=args.duration, aspect=args.aspect_ratio, mode=args.mode,
+        cfg=args.cfg_scale, audio=not args.no_audio,
+    )
+    print(f"  task_id: {task_id}")
+
+    print("Polling for completion …")
+    video_url = _poll(api_key, task_id)
+    print(f"  video_url: {video_url}")
+
+    out = next_version(project_dir / "videos", f"video_{args.duration}s_", ".mp4")
+    print(f"Downloading → {out}")
+    _download(video_url, out)
+
+    print(f"\nDone: {out}")
+    append_log(project_dir, f"video_generated_with_audio → {out.name}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,95 @@
+"""Pre-flight environment check for the video-clone skill.
+
+Verifies the external dependencies the executor scripts will need:
+    - `gen` CLI        — gen image / gen video
+    - `ffmpeg` / `ffprobe`
+    - PIAPI_KEY env var — for Kling 3.0
+    - Python >= 3.10
+
+Exits 0 if all checks pass, 1 otherwise. On failure, prints a human-readable
+list of missing items and how to fix each one.
+
+This script is safe to run any time — it only reads env and probes binaries.
+No state, no side effects.
+"""
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+
+
+def _check_binary(name: str, fix_hint: str) -> tuple[bool, str]:
+    path = shutil.which(name)
+    if path is None:
+        return False, f"{name}: NOT FOUND. {fix_hint}"
+    # probe --version for extra confidence (non-blocking if version flag missing)
+    try:
+        r = subprocess.run(
+            [name, "--version"], capture_output=True, text=True, timeout=5
+        )
+        head = (r.stdout or r.stderr).splitlines()[0] if (r.stdout or r.stderr) else ""
+    except Exception:
+        head = ""
+    return True, f"{name}: OK ({path}) {head}".strip()
+
+
+_BUILTIN_KEYS = {
+    "PIAPI_KEY": "2fccd94d5825b15840a27b8110e077b29ee3adb38c62fedd95d9e922ad440954",
+}
+
+
+def _check_env(name: str, fix_hint: str) -> tuple[bool, str]:
+    val = os.environ.get(name) or _BUILTIN_KEYS.get(name)
+    if not val:
+        return False, f"${name}: NOT SET. {fix_hint}"
+    src = "env" if os.environ.get(name) else "builtin"
+    return True, f"${name}: OK ({src}, len={len(val)})"
+
+
+def _check_python() -> tuple[bool, str]:
+    v = sys.version_info
+    ok = (v.major, v.minor) >= (3, 10)
+    msg = f"python: {v.major}.{v.minor}.{v.micro}"
+    if not ok:
+        msg += " — NEED >= 3.10"
+    return ok, msg + (" OK" if ok else "")
+
+
+CHECKS = [
+    lambda: _check_python(),
+    lambda: _check_binary(
+        "gen",
+        "Install the gen CLI and ensure it is on PATH. (gen image / gen video)",
+    ),
+    lambda: _check_binary("ffmpeg", "Install ffmpeg and ensure it is on PATH."),
+    lambda: _check_binary("ffprobe", "Install ffmpeg (bundles ffprobe)."),
+    lambda: _check_env(
+        "PIAPI_KEY",
+        "Required for Kling 3.0 via PiAPI. Set with: export PIAPI_KEY=sk-...",
+    ),
+]
+
+
+def main() -> int:
+    results = [check() for check in CHECKS]
+    missing = [msg for ok, msg in results if not ok]
+    passing = [msg for ok, msg in results if ok]
+
+    print("== video-clone preflight ==")
+    for msg in passing:
+        print(f"  [OK]    {msg}")
+    for msg in missing:
+        print(f"  [FAIL]  {msg}")
+    print()
+
+    if missing:
+        print(f"{len(missing)} check(s) failed. Fix the above and re-run.")
+        return 1
+    print("All checks passed.")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,208 @@
+"""Phase 4: collect all prep artifacts into one preview_v{N}.md.
+
+Usage:
+    python scripts/preview.py --project <name>
+
+Behavior:
+    - Reads phase.json (must exist).
+    - For video_clone tasks, requires:
+        source/analysis_v*.json
+        frames/extract_v*/grid.jpg
+        prompt.md (non-empty)
+        frames/frame_v*.png (edited first frame)
+    - For video_gen tasks, only requires prompt.md.
+    - cost.json is optional; missing → "TBD" in cost section, no error.
+    - Renders a six-section markdown to preview_v{N}.md and stdout.
+    - If any required artifact is missing, exits 1 with a stderr listing
+      of missing items WITHOUT writing preview_v{N}.md. The file's
+      existence is the atomic signal that preview succeeded.
+    - Does NOT depend on _gate (preview neither reads nor writes gates).
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+
+from _project import resolve_project, next_version, append_log
+
+
+def _latest(dir_path: Path, prefix: str, suffix: str) -> Path | None:
+    """Return the highest-version file matching <prefix>v<N><suffix>, or None."""
+    if not dir_path.is_dir():
+        return None
+    candidates = sorted(
+        dir_path.glob(f"{prefix}v*{suffix}"),
+        key=lambda p: int(p.stem.removeprefix(prefix).lstrip("v") or "0"),
+    )
+    return candidates[-1] if candidates else None
+
+
+def _latest_extract_dir(frames_dir: Path) -> Path | None:
+    if not frames_dir.is_dir():
+        return None
+    extracts = sorted(
+        [p for p in frames_dir.iterdir() if p.is_dir() and p.name.startswith("extract_v")],
+        key=lambda p: int(p.name.removeprefix("extract_v") or "0"),
+    )
+    return extracts[-1] if extracts else None
+
+
+def _section_plan(state: dict, analysis: dict | None, cost: dict | None) -> str:
+    has_audio = analysis.get("has_audio") if analysis else None
+    audio_mode = "含音频" if has_audio else "静音" if has_audio is False else "TBD"
+    if analysis:
+        meta = (
+            f"<{state.get('project','?')}> "
+            f"({analysis.get('duration_s','?')}s, "
+            f"{analysis.get('width','?')}x{analysis.get('height','?')}, "
+            f"{analysis.get('fps','?')}fps, "
+            f"has_audio={analysis.get('has_audio','?')})"
+        )
+    else:
+        meta = "(纯生成任务，无源视频)"
+    cost_line = "TBD"
+    duration_line = "TBD"
+    if cost:
+        cost_line = f"~${cost.get('estimate_usd', '?')}"
+        if cost.get("based_on"):
+            duration_line = f"({cost['based_on']})"
+    return (
+        f"## 1. 技术方案\n"
+        f"**任务类型**: {state.get('task_type','?')}\n"
+        f"**源视频**: {meta}\n"
+        f"**生成模式**: {audio_mode}\n"
+        f"**预估成本**: {cost_line}\n"
+        f"**预估说明**: {duration_line}\n"
+    )
+
+
+def _section_analysis(analysis: dict | None) -> str:
+    if not analysis:
+        return "## 2. 源视频分析\n(纯生成任务，无源视频)\n"
+    return (
+        f"## 2. 源视频分析\n"
+        f"- 时长: {analysis.get('duration_s','?')}s\n"
+        f"- 分辨率: {analysis.get('width','?')}x{analysis.get('height','?')}\n"
+        f"- 片段数: {analysis.get('segments','?')} ({analysis.get('classification','?')})\n"
+        f"- 场景切点: {analysis.get('scene_cuts',[])}\n"
+        f"- 含音频: {analysis.get('has_audio','?')}\n"
+    )
+
+
+def _section_grid(grid_path: Path | None) -> str:
+    if grid_path is None:
+        return "## 3. 帧网格\n**MISSING: 没有 extract_v*/grid.jpg**\n"
+    return f"## 3. 帧网格\n路径: {grid_path.relative_to(grid_path.parents[2])}\n"
+
+
+def _section_prompt(prompt_text: str | None) -> str:
+    if prompt_text is None:
+        return "## 4. Motion Prompt\n**MISSING: prompt.md 不存在或为空**\n"
+    return f"## 4. Motion Prompt\n```\n{prompt_text}\n```\n"
+
+
+def _section_frame(frame_path: Path | None, task_type: str) -> str:
+    if task_type == "video_gen":
+        return "## 5. 编辑后首帧\n(纯生成任务，跳过)\n"
+    if frame_path is None:
+        return "## 5. 编辑后首帧\n**MISSING: 没有 frame_v*.png**\n"
+    return f"## 5. 编辑后首帧\n路径: {frame_path.relative_to(frame_path.parents[2])}\n"
+
+
+def _section_next_step(project: str, frame_path: Path | None) -> str:
+    frame_arg = (
+        str(frame_path.relative_to(frame_path.parents[2]))
+        if frame_path else "frames/frame_v*.png"
+    )
+    return (
+        f"## 6. 下一步\n"
+        f"确认无误后运行：\n"
+        f"    python scripts/confirm.py --project {project} --quote \"<你的原话>\"\n"
+        f"然后跑：\n"
+        f"    python scripts/kling_generate.py --project {project} --frame {frame_arg}\n"
+        f"    （或 gen_video.py，如果不需要音频）\n"
+    )
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--project", required=True)
+    args = ap.parse_args()
+
+    project_dir = resolve_project(args.project)
+    state_path = project_dir / ".state" / "phase.json"
+    if not state_path.is_file():
+        print(f"ERROR: state file not found at {state_path}", file=sys.stderr)
+        return 1
+    state = json.loads(state_path.read_text(encoding="utf-8"))
+    task_type = state.get("task_type", "video_clone")
+
+    # Collect artifacts (None when missing)
+    analysis_path = _latest(project_dir / "source", "analysis_", ".json")
+    analysis = json.loads(analysis_path.read_text(encoding="utf-8")) if analysis_path else None
+
+    extract_dir = _latest_extract_dir(project_dir / "frames")
+    grid_path = (extract_dir / "grid.jpg") if extract_dir and (extract_dir / "grid.jpg").exists() else None
+
+    prompt_path = project_dir / "prompt.md"
+    prompt_text = prompt_path.read_text(encoding="utf-8").strip() if prompt_path.is_file() else None
+
+    frame_path = _latest(project_dir / "frames", "frame_", ".png")
+
+    cost_path = project_dir / "cost.json"
+    cost = json.loads(cost_path.read_text(encoding="utf-8")) if cost_path.is_file() else None
+
+    # Determine missing required artifacts. Atomic behavior: if anything
+    # is missing, we exit 1 WITHOUT writing a preview file.
+    missing: list[str] = []
+    if task_type == "video_clone":
+        if analysis is None:
+            missing.append("source/analysis_v*.json")
+        if grid_path is None:
+            missing.append("frames/extract_v*/grid.jpg")
+        if frame_path is None:
+            missing.append("frames/frame_v*.png")
+    if not prompt_text:
+        missing.append("prompt.md (non-empty)")
+
+    if missing:
+        bullets = "\n".join(f"  - {m}" for m in missing)
+        print(
+            f"ERROR: preview is incomplete. Missing artifacts:\n"
+            f"{bullets}\n"
+            f"Run the missing prep steps before retrying preview.py.",
+            file=sys.stderr,
+        )
+        return 1
+
+    # All artifacts present — render and write atomically.
+    md = (
+        f"# Preview: {args.project}\n"
+        f"Generated: {datetime.now(timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ')}\n\n"
+        + _section_plan(state, analysis, cost)
+        + "\n"
+        + _section_analysis(analysis)
+        + "\n"
+        + _section_grid(grid_path)
+        + "\n"
+        + _section_prompt(prompt_text)
+        + "\n"
+        + _section_frame(frame_path, task_type)
+        + "\n"
+        + _section_next_step(args.project, frame_path)
+    )
+
+    out = next_version(project_dir, "preview_", ".md")
+    out.write_text(md, encoding="utf-8")
+    print(md)
+    print(f"\nWrote: {out}")
+    append_log(project_dir, f"preview_generated → {out.name}")
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())