@optima-chat/optima-agent 0.8.91 → 0.8.93

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())

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

@@ -0,0 +1,169 @@
+"""Tests for preview.py — Phase 4 artifact collection."""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+SCRIPTS_DIR = Path(__file__).parent
+SKILL_ROOT = SCRIPTS_DIR.parent
+
+
+def _make_project(tmp: Path, task_type: str = "video_clone") -> Path:
+    proj = tmp / "video-clone" / "test-proj"
+    for sub in ("source", "frames", "videos", ".state"):
+        (proj / sub).mkdir(parents=True)
+    state = {
+        "schema_version": 1,
+        "project": "test-proj",
+        "task_type": task_type,
+        "created_at": "2025-01-01T00:00:00Z",
+        "current_phase": 0,
+        "gates": {
+            "preview_confirmed": {"status": False, "confirmed_at": None, "user_quote": None}
+        },
+        "history": [],
+    }
+    (proj / ".state" / "phase.json").write_text(
+        json.dumps(state, indent=2), encoding="utf-8"
+    )
+    return proj
+
+
+def _run(tmp: Path, extra_args: list[str] | None = None) -> subprocess.CompletedProcess:
+    env = os.environ.copy()
+    env["GEN_OUTPUT_ROOT"] = str(tmp)
+    cmd = [sys.executable, str(SCRIPTS_DIR / "preview.py"), "--project", "test-proj"]
+    if extra_args:
+        cmd += extra_args
+    return subprocess.run(cmd, capture_output=True, text=True, env=env)
+
+
+def _add_analysis(proj: Path) -> None:
+    analysis = {
+        "duration_s": 10,
+        "width": 1280,
+        "height": 720,
+        "fps": 30.0,
+        "has_audio": False,
+        "segments": 1,
+        "classification": "single",
+        "scene_cuts": [],
+    }
+    (proj / "source" / "analysis_v1.json").write_text(
+        json.dumps(analysis), encoding="utf-8"
+    )
+
+
+def _add_grid(proj: Path) -> None:
+    extract = proj / "frames" / "extract_v1"
+    extract.mkdir(parents=True, exist_ok=True)
+    (extract / "grid.jpg").write_bytes(b"\xff\xd8\xff\xe0dummy")
+
+
+def _add_prompt(proj: Path) -> None:
+    (proj / "prompt.md").write_text("A person walking.", encoding="utf-8")
+
+
+def _add_frame(proj: Path) -> None:
+    (proj / "frames" / "frame_v1.png").write_bytes(b"\x89PNG\r\ndummy")
+
+
+def test_preview_full_artifacts_writes_v1():
+    with tempfile.TemporaryDirectory() as td:
+        tmp = Path(td)
+        proj = _make_project(tmp)
+        _add_analysis(proj)
+        _add_grid(proj)
+        _add_prompt(proj)
+        _add_frame(proj)
+
+        result = _run(tmp)
+        assert result.returncode == 0, f"Expected 0 but got {result.returncode}\nstderr: {result.stderr}"
+        out_file = proj / "preview_v1.md"
+        assert out_file.is_file(), "preview_v1.md should be written"
+        content = out_file.read_text(encoding="utf-8")
+        assert "# Preview: test-proj" in content
+        assert "## 1. 技术方案" in content
+        assert "## 4. Motion Prompt" in content
+        assert "A person walking." in content
+    print("PASS test_preview_full_artifacts_writes_v1")
+
+
+def test_preview_missing_prompt_does_not_write_file_and_exits_one():
+    with tempfile.TemporaryDirectory() as td:
+        tmp = Path(td)
+        proj = _make_project(tmp)
+        _add_analysis(proj)
+        _add_grid(proj)
+        # NO prompt
+        _add_frame(proj)
+
+        result = _run(tmp)
+        assert result.returncode == 1, f"Expected 1 but got {result.returncode}"
+        assert "prompt.md" in result.stderr
+        out_file = proj / "preview_v1.md"
+        assert not out_file.exists(), "preview file must NOT be written on failure"
+    print("PASS test_preview_missing_prompt_does_not_write_file_and_exits_one")
+
+
+def test_preview_missing_cost_json_uses_tbd():
+    with tempfile.TemporaryDirectory() as td:
+        tmp = Path(td)
+        proj = _make_project(tmp)
+        _add_analysis(proj)
+        _add_grid(proj)
+        _add_prompt(proj)
+        _add_frame(proj)
+        # No cost.json
+
+        result = _run(tmp)
+        assert result.returncode == 0, f"stderr: {result.stderr}"
+        content = (proj / "preview_v1.md").read_text(encoding="utf-8")
+        assert "TBD" in content
+    print("PASS test_preview_missing_cost_json_uses_tbd")
+
+
+def test_preview_rerun_creates_v2():
+    with tempfile.TemporaryDirectory() as td:
+        tmp = Path(td)
+        proj = _make_project(tmp)
+        _add_analysis(proj)
+        _add_grid(proj)
+        _add_prompt(proj)
+        _add_frame(proj)
+
+        r1 = _run(tmp)
+        assert r1.returncode == 0
+        assert (proj / "preview_v1.md").is_file()
+
+        r2 = _run(tmp)
+        assert r2.returncode == 0
+        assert (proj / "preview_v2.md").is_file()
+    print("PASS test_preview_rerun_creates_v2")
+
+
+def test_preview_video_gen_only_needs_prompt():
+    with tempfile.TemporaryDirectory() as td:
+        tmp = Path(td)
+        proj = _make_project(tmp, task_type="video_gen")
+        _add_prompt(proj)
+        # No analysis, no grid, no frame
+
+        result = _run(tmp)
+        assert result.returncode == 0, f"Expected 0 but got {result.returncode}\nstderr: {result.stderr}"
+        content = (proj / "preview_v1.md").read_text(encoding="utf-8")
+        assert "纯生成任务" in content
+    print("PASS test_preview_video_gen_only_needs_prompt")
+
+
+if __name__ == "__main__":
+    test_preview_full_artifacts_writes_v1()
+    test_preview_missing_prompt_does_not_write_file_and_exits_one()
+    test_preview_missing_cost_json_uses_tbd()
+    test_preview_rerun_creates_v2()
+    test_preview_video_gen_only_needs_prompt()
+    print("\nAll 5 preview tests passed.")

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

@@ -0,0 +1,129 @@
+"""Phase 5: capture a successful project as a reusable workflow.
+
+Usage:
+    python scripts/save_workflow.py --name handheld-phone-swap \
+        --project <source-project> \
+        --scene "手持vlog + 单物品替换" \
+        --rating 5 \
+        --strategy "双图首帧, t=15s选帧, 简单手部动作"
+
+Creates <gen-output>/video-clone/workflows/<name>.md (must not exist) and
+appends a row to workflows/README.md index.
+
+This is where experience becomes durable. Without Phase 5, the workflow
+library stays stuck at 2 entries forever.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from _gate import require_gate
+from _project import gen_output_root, resolve_project
+
+
+README_HEADER = """# Video Clone Workflows
+
+| Workflow | 适用场景 | 效果 | 关键策略 |
+|---|---|---|---|
+"""
+
+
+def _load_or_init_readme(readme: Path) -> str:
+    if readme.exists():
+        return readme.read_text(encoding="utf-8")
+    return README_HEADER
+
+
+def _append_index_row(readme_text: str, name: str, scene: str,
+                      rating: int, strategy: str) -> str:
+    stars = "⭐" * max(1, min(5, rating))
+    row = f"| [{name}]({name}.md) | {scene} | {stars} | {strategy} |\n"
+    if name in readme_text:
+        # already indexed — don't duplicate. Caller should edit manually.
+        return readme_text
+    return readme_text.rstrip() + "\n" + row
+
+
+def _workflow_body(name: str, scene: str, strategy: str, project: str) -> str:
+    return f"""# {name}
+
+## 适用场景
+{scene}
+
+## 策略
+
+### 首帧
+{strategy}
+
+### Prompt
+（从 {project}/prompt.md 提取可复用片段）
+
+### 视频生成
+（从 {project}/log.md 提取成功的参数组合）
+
+### 后处理
+（特殊 ffmpeg 参数，如有）
+
+## 成功案例
+- {project}
+
+## 踩坑记录
+- （试过但失败的方法）
+"""
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--name", required=True, help="workflow slug")
+    ap.add_argument("--project", required=True, help="source project name")
+    ap.add_argument("--scene", required=True, help="适用场景 one-liner")
+    ap.add_argument("--rating", type=int, choices=range(1, 6), required=True)
+    ap.add_argument("--strategy", required=True, help="key strategy one-liner")
+    args = ap.parse_args()
+
+    project_dir = resolve_project(args.project)
+    require_gate(project_dir, "preview_confirmed")
+
+    videos = list((project_dir / "videos").glob("*.mp4"))
+    if not videos:
+        print(
+            f"ERROR: cannot save workflow — no videos in {project_dir / 'videos'}.\n"
+            f"Run kling_generate.py or gen_video.py first.",
+            file=sys.stderr,
+        )
+        return 1
+
+    workflows = gen_output_root() / "video-clone" / "workflows"
+    workflows.mkdir(parents=True, exist_ok=True)
+
+    wf_file = workflows / f"{args.name}.md"
+    if wf_file.exists():
+        print(
+            f"ERROR: workflow {wf_file} already exists. Edit it by hand or "
+            f"pick a different --name.",
+            file=sys.stderr,
+        )
+        return 1
+
+    wf_file.write_text(
+        _workflow_body(args.name, args.scene, args.strategy, args.project),
+        encoding="utf-8",
+    )
+
+    readme = workflows / "README.md"
+    readme_text = _load_or_init_readme(readme)
+    readme_text = _append_index_row(
+        readme_text, args.name, args.scene, args.rating, args.strategy
+    )
+    readme.write_text(readme_text, encoding="utf-8")
+
+    print(f"Saved workflow: {wf_file}")
+    print(f"Updated index:  {readme}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

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

@@ -0,0 +1,106 @@
+"""Tests for save_workflow.py — Phase 5 workflow capture."""
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+SCRIPTS_DIR = Path(__file__).parent
+
+
+def _make_project(tmp: Path, gate: bool = True) -> Path:
+    proj = tmp / "video-clone" / "test-proj"
+    for sub in ("source", "frames", "videos", ".state"):
+        (proj / sub).mkdir(parents=True)
+    state = {
+        "schema_version": 1,
+        "project": "test-proj",
+        "task_type": "video_clone",
+        "created_at": "2025-01-01T00:00:00Z",
+        "current_phase": 0,
+        "gates": {
+            "preview_confirmed": {
+                "status": gate,
+                "confirmed_at": "2025-01-01T00:01:00Z" if gate else None,
+                "user_quote": "go" if gate else None,
+            }
+        },
+        "history": [],
+    }
+    (proj / ".state" / "phase.json").write_text(
+        json.dumps(state, indent=2), encoding="utf-8"
+    )
+    if gate:
+        # Add a video so save_workflow doesn't fail the "no videos" check
+        (proj / "videos" / "final_v1.mp4").write_bytes(b"dummy")
+    return proj
+
+
+def _run(tmp: Path, extra_args: list[str] | None = None) -> subprocess.CompletedProcess:
+    env = os.environ.copy()
+    env["GEN_OUTPUT_ROOT"] = str(tmp)
+    cmd = [
+        sys.executable, str(SCRIPTS_DIR / "save_workflow.py"),
+        "--project", "test-proj",
+        "--name", "test-workflow",
+        "--scene", "手持 vlog",
+        "--rating", "4",
+        "--strategy", "双图首帧",
+    ]
+    if extra_args:
+        cmd += extra_args
+    return subprocess.run(cmd, capture_output=True, text=True, env=env)
+
+
+def test_save_workflow_blocked_without_gate():
+    with tempfile.TemporaryDirectory() as td:
+        tmp = Path(td)
+        _make_project(tmp, gate=False)
+        result = _run(tmp)
+        assert result.returncode == 1, (
+            f"Expected exit 1 without gate\nstdout: {result.stdout}\nstderr: {result.stderr}"
+        )
+        assert "HARD-GATE BLOCKED" in result.stderr or "preview_confirmed" in result.stderr
+    print("PASS test_save_workflow_blocked_without_gate")
+
+
+def test_save_workflow_creates_file_with_gate():
+    with tempfile.TemporaryDirectory() as td:
+        tmp = Path(td)
+        _make_project(tmp, gate=True)
+        result = _run(tmp)
+        assert result.returncode == 0, (
+            f"Expected exit 0\nstdout: {result.stdout}\nstderr: {result.stderr}"
+        )
+        wf_file = tmp / "video-clone" / "workflows" / "test-workflow.md"
+        assert wf_file.is_file(), "workflow file should be created"
+        content = wf_file.read_text(encoding="utf-8")
+        assert "手持 vlog" in content
+        assert "双图首帧" in content
+        # README index should be updated
+        readme = tmp / "video-clone" / "workflows" / "README.md"
+        assert readme.is_file()
+        assert "test-workflow" in readme.read_text(encoding="utf-8")
+    print("PASS test_save_workflow_creates_file_with_gate")
+
+
+def test_save_workflow_rejects_duplicate_name():
+    with tempfile.TemporaryDirectory() as td:
+        tmp = Path(td)
+        _make_project(tmp, gate=True)
+        r1 = _run(tmp)
+        assert r1.returncode == 0
+        r2 = _run(tmp)
+        assert r2.returncode == 1, "second run with same name should exit 1"
+        assert "already exists" in r2.stderr
+    print("PASS test_save_workflow_rejects_duplicate_name")
+
+
+if __name__ == "__main__":
+    test_save_workflow_blocked_without_gate()
+    test_save_workflow_creates_file_with_gate()
+    test_save_workflow_rejects_duplicate_name()
+    print("\nAll 3 save_workflow tests passed.")