@optima-chat/optima-agent 0.8.95 → 0.8.97

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

@@ -1,96 +0,0 @@
-"""Shared implementation for confirm.py.
-
-run_confirm() handles:
-    - argparse with --project / --quote / --force
-    - quote validation (non-empty)
-    - negation heuristic (refuses quotes that sound like corrections unless --force)
-    - resolving the project directory via GEN_OUTPUT_ROOT
-    - automatically passing caller=Path(sys.argv[0]).name to _gate.set_gate()
-"""
-from __future__ import annotations
-
-import argparse
-import os
-import sys
-from pathlib import Path
-
-import _gate
-
-NEGATION_MARKERS = (
-    "不", "别", "改", "调整", "不行", "不对", "再", "换",
-    "no", "not", "don't", "dont", "modify", "change", "different", "wrong",
-)
-
-GATE_NAME = "preview_confirmed"
-
-
-def _gen_output_root() -> Path:
-    override = os.environ.get("GEN_OUTPUT_ROOT")
-    if override:
-        return Path(override)
-    return Path.cwd() / "gen-output"
-
-
-def _looks_like_negation(quote: str) -> bool:
-    low = quote.lower()
-    return any(m in low for m in NEGATION_MARKERS)
-
-
-def run_confirm() -> int:
-    ap = argparse.ArgumentParser(
-        description=f"Record user confirmation for {GATE_NAME}."
-    )
-    ap.add_argument("--project", required=True, help="Project name under video-clone/")
-    ap.add_argument(
-        "--quote", required=True,
-        help="The user's actual confirmation words (verbatim). Required.",
-    )
-    ap.add_argument(
-        "--force", action="store_true",
-        help="Required if the quote contains negation markers "
-             "(used when user said something like 'no audio, rest is fine').",
-    )
-    args = ap.parse_args()
-
-    quote = args.quote.strip()
-    if not quote:
-        print(
-            "ERROR: --quote is empty. You must pass the user's actual "
-            "confirmation words.",
-            file=sys.stderr,
-        )
-        return 1
-
-    if _looks_like_negation(quote) and not args.force:
-        print(
-            f"ERROR: quote looks like a correction / negation: {quote!r}\n"
-            f"If the user really confirmed (e.g. 'no audio, rest is fine'), "
-            f"re-run with --force. Otherwise, go back and get a cleaner "
-            f"confirmation from the user.",
-            file=sys.stderr,
-        )
-        return 1
-
-    project_dir = _gen_output_root() / "video-clone" / args.project
-    if not project_dir.is_dir():
-        print(
-            f"ERROR: project directory not found at {project_dir}\n"
-            f"Run init_project.py first.",
-            file=sys.stderr,
-        )
-        return 1
-
-    # IMPORTANT: caller is sys.argv[0] (the entry script), not __file__.
-    # We want the audit to record "confirm.py", not "_confirm.py".
-    caller = Path(sys.argv[0]).name if sys.argv and sys.argv[0] else "<unknown>"
-
-    try:
-        _gate.set_gate(project_dir, GATE_NAME, quote, caller=caller)
-    except (ValueError, FileNotFoundError, KeyError) as e:
-        print(f"ERROR: {e}", file=sys.stderr)
-        return 1
-
-    print(f"OK: {GATE_NAME} recorded for project {args.project}")
-    print(f"    quote:  {quote}")
-    print(f"    caller: {caller}")
-    return 0

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

@@ -1,125 +0,0 @@
-"""Unit tests for _confirm.run_confirm() — caller injection + quote validation."""
-from __future__ import annotations
-
-import json
-import os
-import sys
-import tempfile
-from pathlib import Path
-from unittest.mock import patch
-
-SCRIPTS_DIR = Path(__file__).parent
-sys.path.insert(0, str(SCRIPTS_DIR))
-
-import _confirm  # noqa: E402
-import _gate  # noqa: E402
-
-TEMPLATE = json.loads(
-    (SCRIPTS_DIR.parent / "assets" / "phase-state-template.json").read_text(encoding="utf-8")
-)
-
-
-def _make_project(root: Path, name: str = "p1") -> Path:
-    proj = root / "video-clone" / name
-    (proj / ".state").mkdir(parents=True)
-    state = json.loads(json.dumps(TEMPLATE))
-    state["project"] = name
-    state["task_type"] = "video_clone"
-    (proj / ".state" / "phase.json").write_text(json.dumps(state), encoding="utf-8")
-    return proj
-
-
-def _run_with_argv(argv, env=None):
-    old_argv = sys.argv
-    old_env = dict(os.environ)
-    try:
-        sys.argv = argv
-        if env:
-            os.environ.update(env)
-        return _confirm.run_confirm()
-    finally:
-        sys.argv = old_argv
-        os.environ.clear()
-        os.environ.update(old_env)
-
-
-def test_run_confirm_injects_caller_from_argv0():
-    with tempfile.TemporaryDirectory() as td:
-        _make_project(Path(td))
-        rc = _run_with_argv(
-            ["confirm.py", "--project", "p1", "--quote", "OK 开始"],
-            env={"GEN_OUTPUT_ROOT": td},
-        )
-        assert rc == 0
-        state = _gate.load_state(Path(td) / "video-clone" / "p1")
-        history = state["history"]
-        assert history[-1]["caller"] == "confirm.py"
-        assert history[-1]["user_quote"] == "OK 开始"
-    print("PASS test_run_confirm_injects_caller_from_argv0")
-
-
-def test_run_confirm_empty_quote_returns_one():
-    with tempfile.TemporaryDirectory() as td:
-        _make_project(Path(td))
-        rc = _run_with_argv(
-            ["confirm.py", "--project", "p1", "--quote", "   "],
-            env={"GEN_OUTPUT_ROOT": td},
-        )
-        assert rc == 1
-    print("PASS test_run_confirm_empty_quote_returns_one")
-
-
-def test_run_confirm_negation_without_force_returns_one():
-    with tempfile.TemporaryDirectory() as td:
-        _make_project(Path(td))
-        rc = _run_with_argv(
-            ["confirm.py", "--project", "p1", "--quote", "不要这样改"],
-            env={"GEN_OUTPUT_ROOT": td},
-        )
-        assert rc == 1
-    print("PASS test_run_confirm_negation_without_force_returns_one")
-
-
-def test_run_confirm_negation_with_force_returns_zero():
-    with tempfile.TemporaryDirectory() as td:
-        _make_project(Path(td))
-        rc = _run_with_argv(
-            ["confirm.py", "--project", "p1", "--quote", "no audio, rest is fine", "--force"],
-            env={"GEN_OUTPUT_ROOT": td},
-        )
-        assert rc == 0
-    print("PASS test_run_confirm_negation_with_force_returns_zero")
-
-
-def test_run_confirm_missing_project_returns_one():
-    with tempfile.TemporaryDirectory() as td:
-        rc = _run_with_argv(
-            ["confirm.py", "--project", "does-not-exist", "--quote", "ok"],
-            env={"GEN_OUTPUT_ROOT": td},
-        )
-        assert rc == 1
-    print("PASS test_run_confirm_missing_project_returns_one")
-
-
-def test_run_confirm_success_writes_history_with_caller():
-    with tempfile.TemporaryDirectory() as td:
-        _make_project(Path(td), "p2")
-        rc = _run_with_argv(
-            ["confirm.py", "--project", "p2", "--quote", "好的，开始"],
-            env={"GEN_OUTPUT_ROOT": td},
-        )
-        assert rc == 0
-        state = _gate.load_state(Path(td) / "video-clone" / "p2")
-        assert state["gates"]["preview_confirmed"]["status"] is True
-        assert state["history"][-1]["caller"] == "confirm.py"
-    print("PASS test_run_confirm_success_writes_history_with_caller")
-
-
-if __name__ == "__main__":
-    test_run_confirm_injects_caller_from_argv0()
-    test_run_confirm_empty_quote_returns_one()
-    test_run_confirm_negation_without_force_returns_one()
-    test_run_confirm_negation_with_force_returns_zero()
-    test_run_confirm_missing_project_returns_one()
-    test_run_confirm_success_writes_history_with_caller()
-    print("All 6 _confirm tests passed.")

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

@@ -1,162 +0,0 @@
-"""Phase-state machine for the video-clone skill.
-
-Every executable script that spends money or writes durable artifacts calls
-`require_gate()` at startup. If the required gate is not yet confirmed, the
-script exits with code 1 and prints a [HARD-GATE BLOCKED] message describing
-exactly how to unblock it.
-
-State lives in `<project_dir>/.state/phase.json` (one file per project).
-The schema is defined in `assets/phase-state-template.json`.
-
-This module is stdlib-only. Import it from sibling scripts with:
-
-    from _gate import require_gate
-    require_gate(project_dir, "preview_confirmed")
-
-Gates (single):
-    preview_confirmed — user reviewed the preview bundle and confirmed
-                        they want video generation to proceed.
-"""
-from __future__ import annotations
-
-import json
-import sys
-from datetime import datetime, timezone
-from pathlib import Path
-
-GATE_NAMES = ("preview_confirmed",)
-STATE_REL = Path(".state") / "phase.json"
-
-
-def _state_path(project_dir: Path | str) -> Path:
-    return Path(project_dir) / STATE_REL
-
-
-def load_state(project_dir: Path | str) -> dict:
-    """Read and parse .state/phase.json for the given project directory."""
-    path = _state_path(project_dir)
-    if not path.exists():
-        raise FileNotFoundError(
-            f"No phase state at {path}. Run init_project.py first."
-        )
-    return json.loads(path.read_text(encoding="utf-8"))
-
-
-def save_state(project_dir: Path | str, state: dict) -> None:
-    """Atomically overwrite .state/phase.json."""
-    path = _state_path(project_dir)
-    path.parent.mkdir(parents=True, exist_ok=True)
-    tmp = path.with_suffix(".json.tmp")
-    tmp.write_text(json.dumps(state, indent=2, ensure_ascii=False), encoding="utf-8")
-    tmp.replace(path)
-
-
-def _now_iso() -> str:
-    return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")
-
-
-def append_history(state: dict, event: str, **extra) -> None:
-    entry = {"event": event, "at": _now_iso()}
-    entry.update(extra)
-    state.setdefault("history", []).append(entry)
-
-
-def set_gate(
-    project_dir: Path | str,
-    gate_name: str,
-    user_quote: str,
-    *,
-    caller: str,
-) -> None:
-    """Flip a gate from false → true and log the user's confirmation quote.
-
-    Raises ValueError if gate_name is unknown, user_quote is empty, or
-    caller is empty/whitespace. caller is keyword-only and required so
-    bypassing _confirm.run_confirm() either fails or leaves a visible
-    `caller` field in history[].
-    """
-    if gate_name not in GATE_NAMES:
-        raise ValueError(
-            f"unknown gate: {gate_name!r}. valid: {', '.join(GATE_NAMES)}"
-        )
-    if not user_quote or not user_quote.strip():
-        raise ValueError("user_quote is required and must be non-empty")
-    if not caller or not caller.strip():
-        raise ValueError("caller is required and must be non-empty")
-
-    state = load_state(project_dir)
-    if gate_name not in state.get("gates", {}):
-        raise KeyError(
-            f"gate {gate_name!r} not found in state — likely an old "
-            f"3-gate schema. Either complete this project with the "
-            f"previous version of the scripts (PR #65), or start a new "
-            f"project with init_project.py."
-        )
-    now = _now_iso()
-    state["gates"][gate_name] = {
-        "status": True,
-        "confirmed_at": now,
-        "user_quote": user_quote,
-    }
-    append_history(state, gate_name, user_quote=user_quote, caller=caller)
-    save_state(project_dir, state)
-
-
-def require_gate(project_dir: Path | str, gate_name: str) -> None:
-    """Assert the given gate is confirmed. Exits with code 1 on failure.
-
-    This is the mechanical HARD-GATE enforcement. Do not catch SystemExit
-    to "handle" the failure — the entire point is that Claude cannot
-    bypass it.
-    """
-    if gate_name not in GATE_NAMES:
-        _fail(
-            f"require_gate called with unknown gate {gate_name!r}. "
-            f"valid: {', '.join(GATE_NAMES)}"
-        )
-
-    try:
-        state = load_state(project_dir)
-    except FileNotFoundError as e:
-        _fail(str(e))
-
-    gates = state.get("gates", {})
-    if gate_name not in gates:
-        _fail(
-            f"\n[HARD-GATE BLOCKED] {Path(sys.argv[0]).name} expected "
-            f"gate {gate_name!r} but it is not present in {project_dir}/"
-            f".state/phase.json.\n"
-            f"This is most likely an old 3-gate schema project. Either:\n"
-            f"  1. Complete this project with the previous version of "
-            f"the scripts (PR #65), or\n"
-            f"  2. Start a new project with: "
-            f"python scripts/init_project.py --name <new-name> "
-            f"--task-type <video_clone|video_gen>\n"
-        )
-
-    gate = gates.get(gate_name, {})
-    if gate.get("status") is True:
-        return  # gate satisfied, continue
-
-    script_name = Path(sys.argv[0]).name if sys.argv and sys.argv[0] else "<script>"
-    msg = (
-        f"\n[HARD-GATE BLOCKED] {script_name} needs {gate_name}=True\n"
-        f"Current state: {gate_name}={gate.get('status', False)}\n"
-        f"Project: {Path(project_dir).resolve()}\n"
-        f"\n"
-        f"To proceed:\n"
-        f"  1. Show the preview bundle to the user and wait for their confirmation.\n"
-        f"  2. Run: python scripts/confirm.py "
-        f"--project <name> --quote \"<user's actual words>\"\n"
-        f"  3. Retry this command.\n"
-        f"\n"
-        f"Claude: do NOT rationalize past this. The gate exists because "
-        f"text instructions alone did not stop prior bypass attempts. "
-        f"Go get the real user confirmation.\n"
-    )
-    _fail(msg)
-
-
-def _fail(message: str) -> None:
-    print(message, file=sys.stderr)
-    sys.exit(1)

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

@@ -1,226 +0,0 @@
-"""E2E gate-enforcement tests for single-gate model.
-
-7 cases:
-  1. analyze_source.py runs WITHOUT gate (no gate requirement)
-  2. extract_frames.py runs WITHOUT gate (no gate requirement)
-  3. edit_first_frame.py runs WITHOUT gate (no gate requirement)
-  4. kling_generate.py is BLOCKED by missing preview_confirmed gate
-  5. gen_video.py is BLOCKED by missing preview_confirmed gate
-  6. save_workflow.py is BLOCKED by missing preview_confirmed gate
-  7. Old 3-gate schema is REJECTED by require_gate with informative message
-
-Run: python scripts/_gate_e2e_test.py
-"""
-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 = False,
-                  old_schema: bool = False) -> Path:
-    proj = tmp / "video-clone" / "e2e-proj"
-    for sub in ("source", "frames", "videos", ".state"):
-        (proj / sub).mkdir(parents=True)
-
-    if old_schema:
-        state = {
-            "schema_version": 0,
-            "project": "e2e-proj",
-            "task_type": "video_clone",
-            "created_at": "2025-01-01T00:00:00Z",
-            "current_phase": 0,
-            "gates": {
-                "plan_confirmed":   {"status": True, "confirmed_at": "x", "user_quote": "y"},
-                "prompt_confirmed": {"status": True, "confirmed_at": "x", "user_quote": "y"},
-                "frame_confirmed":  {"status": True, "confirmed_at": "x", "user_quote": "y"},
-            },
-            "history": [],
-        }
-    else:
-        state = {
-            "schema_version": 1,
-            "project": "e2e-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"
-    )
-    return proj
-
-
-def _run(tmp: Path, script: str, extra: list[str] | None = None,
-         extra_env: dict | None = None) -> subprocess.CompletedProcess:
-    env = os.environ.copy()
-    env["GEN_OUTPUT_ROOT"] = str(tmp)
-    if extra_env:
-        env.update(extra_env)
-    cmd = [sys.executable, str(SCRIPTS_DIR / script),
-           "--project", "e2e-proj"]
-    if extra:
-        cmd += extra
-    return subprocess.run(cmd, capture_output=True, text=True, env=env)
-
-
-# ------------------------------------------------------------------
-# Case 1: analyze_source.py runs without gate
-# ------------------------------------------------------------------
-def test_analyze_source_runs_without_gate():
-    """analyze_source.py must not call require_gate; a missing source file
-    is the expected failure (not a gate block)."""
-    with tempfile.TemporaryDirectory() as td:
-        tmp = Path(td)
-        _make_project(tmp, gate=False)
-        result = _run(tmp, "analyze_source.py", ["--source", "nonexistent.mp4"])
-        assert "HARD-GATE BLOCKED" not in result.stderr, (
-            f"analyze_source must not gate-block. stderr: {result.stderr}"
-        )
-        assert result.returncode != 0  # fails due to missing file, not gate
-    print("PASS test_analyze_source_runs_without_gate")
-
-
-# ------------------------------------------------------------------
-# Case 2: extract_frames.py runs without gate
-# ------------------------------------------------------------------
-def test_extract_frames_runs_without_gate():
-    with tempfile.TemporaryDirectory() as td:
-        tmp = Path(td)
-        _make_project(tmp, gate=False)
-        result = _run(tmp, "extract_frames.py", ["--source", "nonexistent.mp4"])
-        assert "HARD-GATE BLOCKED" not in result.stderr, (
-            f"extract_frames must not gate-block. stderr: {result.stderr}"
-        )
-    print("PASS test_extract_frames_runs_without_gate")
-
-
-# ------------------------------------------------------------------
-# Case 3: edit_first_frame.py runs without gate
-# ------------------------------------------------------------------
-def test_edit_first_frame_runs_without_gate():
-    with tempfile.TemporaryDirectory() as td:
-        tmp = Path(td)
-        _make_project(tmp, gate=False)
-        result = _run(tmp, "edit_first_frame.py", ["--image", "nonexistent.png"])
-        assert "HARD-GATE BLOCKED" not in result.stderr, (
-            f"edit_first_frame must not gate-block. stderr: {result.stderr}"
-        )
-    print("PASS test_edit_first_frame_runs_without_gate")
-
-
-# ------------------------------------------------------------------
-# Case 4: kling_generate.py is BLOCKED without preview_confirmed
-# ------------------------------------------------------------------
-def test_kling_generate_blocked_without_gate():
-    with tempfile.TemporaryDirectory() as td:
-        tmp = Path(td)
-        _make_project(tmp, gate=False)
-        result = _run(tmp, "kling_generate.py",
-                      ["--frame", "frames/frame_v1.png"],
-                      extra_env={"PIAPI_KEY": "dummy"})
-        assert result.returncode == 1, (
-            f"Expected exit 1\nstdout: {result.stdout}\nstderr: {result.stderr}"
-        )
-        assert "HARD-GATE BLOCKED" in result.stderr, (
-            f"Expected HARD-GATE BLOCKED in stderr:\n{result.stderr}"
-        )
-    print("PASS test_kling_generate_blocked_without_gate")
-
-
-# ------------------------------------------------------------------
-# Case 5: gen_video.py is BLOCKED without preview_confirmed
-# ------------------------------------------------------------------
-def test_gen_video_blocked_without_gate():
-    with tempfile.TemporaryDirectory() as td:
-        tmp = Path(td)
-        _make_project(tmp, gate=False)
-        result = _run(tmp, "gen_video.py", ["--frame", "frames/frame_v1.png"])
-        assert result.returncode == 1, (
-            f"Expected exit 1\nstdout: {result.stdout}\nstderr: {result.stderr}"
-        )
-        assert "HARD-GATE BLOCKED" in result.stderr, (
-            f"Expected HARD-GATE BLOCKED in stderr:\n{result.stderr}"
-        )
-    print("PASS test_gen_video_blocked_without_gate")
-
-
-# ------------------------------------------------------------------
-# Case 6: save_workflow.py is BLOCKED without preview_confirmed
-# ------------------------------------------------------------------
-def test_save_workflow_blocked_without_gate():
-    with tempfile.TemporaryDirectory() as td:
-        tmp = Path(td)
-        _make_project(tmp, gate=False)
-        result = _run(tmp, "save_workflow.py",
-                      ["--name", "wf1", "--scene", "test",
-                       "--rating", "3", "--strategy", "test strat"])
-        assert result.returncode == 1, (
-            f"Expected exit 1\nstdout: {result.stdout}\nstderr: {result.stderr}"
-        )
-        assert "HARD-GATE BLOCKED" in result.stderr, (
-            f"Expected HARD-GATE BLOCKED in stderr:\n{result.stderr}"
-        )
-    print("PASS test_save_workflow_blocked_without_gate")
-
-
-# ------------------------------------------------------------------
-# Case 7: Old 3-gate schema is REJECTED with informative message
-# ------------------------------------------------------------------
-def test_old_3gate_schema_rejected_at_gate_check():
-    """When any gated script encounters an old 3-gate schema, require_gate
-    must exit 1 with a message mentioning the old schema."""
-    with tempfile.TemporaryDirectory() as td:
-        tmp = Path(td)
-        _make_project(tmp, old_schema=True)
-        result = _run(tmp, "kling_generate.py",
-                      ["--frame", "frames/frame_v1.png"],
-                      extra_env={"PIAPI_KEY": "dummy"})
-        assert result.returncode == 1
-        stderr = result.stderr
-        assert any(kw in stderr for kw in (
-            "old 3-gate", "schema", "plan_confirmed", "HARD-GATE BLOCKED"
-        )), f"Expected old-schema rejection message in stderr:\n{stderr}"
-    print("PASS test_old_3gate_schema_rejected_at_gate_check")
-
-
-TESTS = [
-    ("analyze_source runs without gate", test_analyze_source_runs_without_gate),
-    ("extract_frames runs without gate", test_extract_frames_runs_without_gate),
-    ("edit_first_frame runs without gate", test_edit_first_frame_runs_without_gate),
-    ("kling_generate blocked without gate", test_kling_generate_blocked_without_gate),
-    ("gen_video blocked without gate", test_gen_video_blocked_without_gate),
-    ("save_workflow blocked without gate", test_save_workflow_blocked_without_gate),
-    ("old 3-gate schema rejected", test_old_3gate_schema_rejected_at_gate_check),
-]
-
-
-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())