@optima-chat/optima-agent 0.8.91 → 0.8.92

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.")

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

@@ -0,0 +1,202 @@
+"""Cross-session resume helper: show project status and next action.
+
+Usage:
+    python scripts/status.py --project <name>
+
+Reads phase.json and scans the project directory to determine what has been
+done and what the next step is. Exits 0 always (read-only, no side effects).
+
+Decision tree (top to bottom, first match wins):
+  1. preview_confirmed gate set → show "ready to generate / already generated"
+  2. preview_v*.md exists       → show "run confirm.py"
+  3. prompt.md non-empty AND
+     frame_v*.png exists (clone) → show "run preview.py"
+  4. analysis_v*.json exists    → show "edit first frame / write prompt.md"
+  5. (nothing)                  → show "run analyze_source.py"
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+from _project import resolve_project
+
+
+def _latest(dir_path: Path, prefix: str, suffix: str) -> Path | 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 _gate_status(state: dict) -> bool:
+    return bool(
+        state.get("gates", {})
+        .get("preview_confirmed", {})
+        .get("status", False)
+    )
+
+
+def _section(title: str, lines: list[str]) -> str:
+    body = "\n".join(f"  {l}" for l in lines)
+    return f"{'='*60}\n{title}\n{'='*60}\n{body}\n"
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description="Show project status and next action.")
+    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: phase.json 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 artifact presence ---
+    analysis_path = _latest(project_dir / "source", "analysis_", ".json")
+    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")
+    preview_path = _latest(project_dir, "preview_", ".md")
+    cost_path = project_dir / "cost.json"
+    videos = sorted((project_dir / "videos").glob("*.mp4"))
+    final_videos = [v for v in videos if v.name.startswith("final_")]
+    gate_set = _gate_status(state)
+
+    # --- Build checklist ---
+    def tick(condition: bool) -> str:
+        return "[x]" if condition else "[ ]"
+
+    checklist = []
+    if task_type == "video_clone":
+        checklist.append(f"{tick(analysis_path is not None)} source/analysis_v*.json")
+        checklist.append(f"{tick(grid_path is not None)} frames/extract_v*/grid.jpg")
+        checklist.append(f"{tick(bool(prompt_text))} prompt.md (non-empty)")
+        checklist.append(f"{tick(frame_path is not None)} frames/frame_v*.png")
+    else:
+        checklist.append(f"{tick(bool(prompt_text))} prompt.md (non-empty)")
+    checklist.append(f"{tick(cost_path.is_file())} cost.json (optional)")
+    checklist.append(f"{tick(preview_path is not None)} preview_v*.md")
+    checklist.append(f"{tick(gate_set)} preview_confirmed gate")
+    checklist.append(f"{tick(bool(final_videos))} videos/final_v*.mp4")
+
+    # --- Decision tree: next action ---
+    if gate_set and final_videos:
+        next_action = [
+            "Project complete.",
+            f"Final video: {final_videos[-1].name}",
+            "",
+            "Optional: capture as workflow:",
+            f'  python scripts/save_workflow.py --project {args.project} \\',
+            '    --name <slug> --scene "<scene>" --rating 5 --strategy "<strategy>"',
+        ]
+    elif gate_set and not final_videos:
+        next_action = [
+            "Gate confirmed — ready to generate video.",
+            "",
+            "Run one of:",
+            f"  python scripts/kling_generate.py --project {args.project} --frame frames/frame_v*.png",
+            f"  python scripts/gen_video.py --project {args.project} --frame frames/frame_v*.png",
+        ]
+    elif preview_path is not None:
+        next_action = [
+            f"Preview ready: {preview_path.name}",
+            "",
+            "Review it, then confirm:",
+            f'  python scripts/confirm.py --project {args.project} --quote "<your words>"',
+        ]
+    elif (
+        task_type == "video_gen"
+        and bool(prompt_text)
+    ) or (
+        task_type == "video_clone"
+        and bool(prompt_text)
+        and frame_path is not None
+        and analysis_path is not None
+        and grid_path is not None
+    ):
+        next_action = [
+            "All prep artifacts present — run preview:",
+            f"  python scripts/preview.py --project {args.project}",
+        ]
+    elif bool(prompt_text) and task_type == "video_clone":
+        # Have prompt but missing frame or grid
+        missing_parts = []
+        if frame_path is None:
+            missing_parts.append("frames/frame_v*.png  (edit_first_frame.py)")
+        if grid_path is None:
+            missing_parts.append("frames/extract_v*/grid.jpg  (extract_frames.py)")
+        next_action = ["Still needed:"] + missing_parts
+    elif analysis_path is not None:
+        next_action = [
+            "Analysis done — continue prep:",
+            f"  python scripts/extract_frames.py --project {args.project} --source source/*.mp4",
+            f"  # then edit first frame and write prompt.md",
+        ]
+    else:
+        if task_type == "video_clone":
+            next_action = [
+                "Start here:",
+                f"  python scripts/analyze_source.py --project {args.project} --source <video.mp4>",
+            ]
+        else:
+            next_action = [
+                "Start here — write prompt.md:",
+                f"  {project_dir / 'prompt.md'}",
+            ]
+
+    # --- Log tail ---
+    log_path = project_dir / "log.md"
+    log_lines: list[str] = []
+    if log_path.is_file():
+        all_lines = log_path.read_text(encoding="utf-8").splitlines()
+        # skip header, take last 10 non-empty
+        entries = [l for l in all_lines if l.strip() and not l.startswith("#")]
+        log_lines = entries[-10:]
+
+    # --- Render ---
+    sections = [
+        _section(
+            f"Project: {args.project}  [{task_type}]",
+            [f"Dir: {project_dir}"],
+        ),
+        _section("Prep checklist", checklist),
+        _section("Next action", next_action),
+    ]
+    if log_lines:
+        sections.append(_section("Recent log (last 10)", log_lines))
+
+    print("\n".join(sections))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())