chainlesschain 0.47.6 → 0.47.7

package/src/skills/video-editing/prompts/structure-proposal.md

@@ -0,0 +1,16 @@
+# Structure Proposal
+
+从全部场景中选 8-15 个匹配用户创意的场景。
+
+**输入**: 用户指令 + 音乐段落总结 + 全部场景列表
+**输出**: 严格 JSON
+
+```json
+{
+  "theme": "<the picked angle>",
+  "narrative_logic": "<why these scenes in this order>",
+  "scene_indices": [3, 7, 12, 18, 24]
+}
+```
+
+**铁律**: 选中的每个场景都必须把 `{{MAIN_CHARACTER_NAME}}` 作为主要视觉主体。只输出 JSON。

package/src/skills/video-editing/prompts/vlog-scene-caption.md

@@ -0,0 +1,18 @@
+# Vlog Scene Caption
+
+分析旅行 vlog 场景的剪辑潜力。
+
+**输入**: 帧序列 + 地点上下文
+**输出**: 严格 JSON
+
+```json
+{
+  "classification": "landscape | activity | talking | transit | food",
+  "visual_analysis": "<风光/构图/光线>",
+  "journey_context": "<这个场景在旅程中的位置>",
+  "creator_presence": "primary | background | absent",
+  "score": { "landscape_beauty": 0, "authenticity": 0, "expression": 0 }
+}
+```
+
+每项 0-5。只输出 JSON。

package/src/skills/video-editing/render/audio-mix.js

@@ -0,0 +1,128 @@
+/**
+ * audio-mix.js — 混音：视频 + 背景音乐
+ *
+ * MVP: 简单叠加 + loudnorm
+ * Phase 4 扩展: 对话区 ducking + 结尾 fade
+ */
+
+import { spawn } from "child_process";
+
+export async function mixAudio(videoPath, audioPath, outputPath, options = {}) {
+  const bgmVolume = options.bgmVolume ?? 0.3;
+
+  return new Promise((resolve, reject) => {
+    const filter = [
+      `[1:a]volume=${bgmVolume},loudnorm=I=-16:LRA=11:TP=-1.5[bgm]`,
+      `[0:a][bgm]amix=inputs=2:duration=first:dropout_transition=2[aout]`,
+    ].join(";");
+
+    const args = [
+      "-y",
+      "-i",
+      videoPath,
+      "-i",
+      audioPath,
+      "-filter_complex",
+      filter,
+      "-map",
+      "0:v",
+      "-map",
+      "[aout]",
+      "-c:v",
+      "copy",
+      "-c:a",
+      "aac",
+      "-b:a",
+      "192k",
+      "-shortest",
+      outputPath,
+    ];
+
+    const proc = spawn("ffmpeg", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    proc.stderr.on("data", (d) => (stderr += d));
+    proc.on("close", (code) => {
+      if (code !== 0)
+        return reject(
+          new Error(`ffmpeg mix exit ${code}: ${stderr.slice(-300)}`),
+        );
+      resolve(outputPath);
+    });
+    proc.on("error", reject);
+  });
+}
+
+export async function mixAudioWithDucking(
+  videoPath,
+  audioPath,
+  outputPath,
+  options = {},
+) {
+  const bgmVolume = options.bgmVolume ?? 0.3;
+  const fadeOutDuration = options.fadeOutDuration ?? 3;
+
+  return new Promise((resolve, reject) => {
+    const filter = [
+      `[0:a]aresample=async=1[speech]`,
+      `[1:a]volume=${bgmVolume},loudnorm=I=-16:LRA=11:TP=-1.5[bgm_norm]`,
+      `[bgm_norm][speech]sidechaincompress=threshold=0.02:ratio=6:attack=200:release=1000[bgm_duck]`,
+      `[speech][bgm_duck]amix=inputs=2:duration=first:dropout_transition=2,afade=t=out:d=${fadeOutDuration}:curve=tri[aout]`,
+    ].join(";");
+
+    const args = buildFfmpegArgs(videoPath, audioPath, outputPath, filter);
+    const proc = spawn("ffmpeg", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    proc.stderr.on("data", (d) => (stderr += d.toString("utf8")));
+    proc.on("close", (code) => {
+      if (code !== 0)
+        return reject(
+          new Error(`ffmpeg ducking mix exit ${code}: ${stderr.slice(-300)}`),
+        );
+      resolve(outputPath);
+    });
+    proc.on("error", reject);
+  });
+}
+
+export function buildDuckingFilter(options = {}) {
+  const bgmVolume = options.bgmVolume ?? 0.3;
+  const fadeOutDuration = options.fadeOutDuration ?? 3;
+  return [
+    `[0:a]aresample=async=1[speech]`,
+    `[1:a]volume=${bgmVolume},loudnorm=I=-16:LRA=11:TP=-1.5[bgm_norm]`,
+    `[bgm_norm][speech]sidechaincompress=threshold=0.02:ratio=6:attack=200:release=1000[bgm_duck]`,
+    `[speech][bgm_duck]amix=inputs=2:duration=first:dropout_transition=2,afade=t=out:d=${fadeOutDuration}:curve=tri[aout]`,
+  ].join(";");
+}
+
+export function buildSimpleFilter(options = {}) {
+  const bgmVolume = options.bgmVolume ?? 0.3;
+  return [
+    `[1:a]volume=${bgmVolume},loudnorm=I=-16:LRA=11:TP=-1.5[bgm]`,
+    `[0:a][bgm]amix=inputs=2:duration=first:dropout_transition=2[aout]`,
+  ].join(";");
+}
+
+function buildFfmpegArgs(videoPath, audioPath, outputPath, filter) {
+  return [
+    "-y",
+    "-i",
+    videoPath,
+    "-i",
+    audioPath,
+    "-filter_complex",
+    filter,
+    "-map",
+    "0:v",
+    "-map",
+    "[aout]",
+    "-c:v",
+    "copy",
+    "-c:a",
+    "aac",
+    "-b:a",
+    "192k",
+    "-shortest",
+    outputPath,
+  ];
+}

package/src/skills/video-editing/render/ffmpeg-concat.js

@@ -0,0 +1,45 @@
+/**
+ * ffmpeg-concat.js — concat demuxer 拼接多个片段
+ */
+
+import { spawn } from "child_process";
+import { promises as fs } from "fs";
+import path from "path";
+
+export async function concatClips(clipPaths, workDir) {
+  if (clipPaths.length === 0) throw new Error("No clips to concatenate");
+
+  if (clipPaths.length === 1) return clipPaths[0];
+
+  const listPath = path.join(workDir, "concat_list.txt");
+  const lines = clipPaths.map((p) => `file '${p.replace(/'/g, "'\\''")}'`);
+  await fs.writeFile(listPath, lines.join("\n"));
+
+  const outPath = path.join(workDir, "concat_output.mp4");
+
+  return new Promise((resolve, reject) => {
+    const args = [
+      "-y",
+      "-f",
+      "concat",
+      "-safe",
+      "0",
+      "-i",
+      listPath,
+      "-c",
+      "copy",
+      outPath,
+    ];
+    const proc = spawn("ffmpeg", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    proc.stderr.on("data", (d) => (stderr += d));
+    proc.on("close", (code) => {
+      if (code !== 0)
+        return reject(
+          new Error(`ffmpeg concat exit ${code}: ${stderr.slice(-300)}`),
+        );
+      resolve(outPath);
+    });
+    proc.on("error", reject);
+  });
+}

package/src/skills/video-editing/render/ffmpeg-extract.js

@@ -0,0 +1,67 @@
+/**
+ * ffmpeg-extract.js — 按 shot_point 从视频中抽取片段
+ */
+
+import { spawn } from "child_process";
+import { promises as fs } from "fs";
+import path from "path";
+
+export async function extractClips(videoPath, shotPoints, workDir) {
+  const clipsDir = path.join(workDir, "clips");
+  await fs.mkdir(clipsDir, { recursive: true });
+
+  const clipPaths = [];
+
+  for (let i = 0; i < shotPoints.length; i++) {
+    const entry = shotPoints[i];
+    const clips = entry.clips || [];
+
+    for (let j = 0; j < clips.length; j++) {
+      const clip = clips[j];
+      const outFile = path.join(clipsDir, `clip_${i}_${j}.mp4`);
+      await extractSingle(
+        videoPath,
+        clip.start,
+        clip.duration || clip.end - clip.start,
+        outFile,
+      );
+      clipPaths.push(outFile);
+    }
+  }
+
+  return clipPaths;
+}
+
+function extractSingle(videoPath, startSec, duration, outFile) {
+  return new Promise((resolve, reject) => {
+    const args = [
+      "-y",
+      "-ss",
+      String(startSec),
+      "-i",
+      videoPath,
+      "-t",
+      String(duration),
+      "-c",
+      "copy",
+      "-avoid_negative_ts",
+      "make_zero",
+      outFile,
+    ];
+    const proc = spawn("ffmpeg", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stderr = "";
+    proc.stderr.on("data", (d) => (stderr += d));
+    proc.on("close", (code) => {
+      if (code !== 0)
+        return reject(
+          new Error(`ffmpeg extract exit ${code}: ${stderr.slice(-300)}`),
+        );
+      resolve(outFile);
+    });
+    proc.on("error", reject);
+  });
+}
+
+export async function extractSingleClip(videoPath, start, end, outFile) {
+  return extractSingle(videoPath, start, end - start, outFile);
+}

package/src/skills/video-editing/reviewer.js

@@ -0,0 +1,161 @@
+/**
+ * reviewer.js — Reviewer Gate: VLM 检查 commit 质量
+ *
+ * 在 commit 前调用 VLM 检查主角占比/美学分:
+ *   - protagonist_ratio >= threshold → pass
+ *   - 不达标 → reject (触发 rerun)
+ *
+ * 扩展 ApprovalGate 为 quality-check policy 类型。
+ */
+
+export const DEFAULT_THRESHOLDS = {
+  protagonist_ratio: 0.5,
+  aesthetic_score: 2.5,
+};
+
+/**
+ * Quality checker registry.
+ * Each checker: { name, check(entry, context) => { pass, score, reason } }
+ */
+const checkerRegistry = new Map();
+
+export function registerChecker(name, checkFn) {
+  checkerRegistry.set(name, { name, check: checkFn });
+}
+
+export function getChecker(name) {
+  return checkerRegistry.get(name);
+}
+
+export function listCheckers() {
+  return Array.from(checkerRegistry.keys());
+}
+
+// ── Built-in checkers ─────────────────────────────────────────
+
+registerChecker("vision-protagonist", async (entry, context) => {
+  if (!context.llmCall) {
+    return { pass: true, score: 0.5, reason: "No VLM available, skipped" };
+  }
+
+  const result = await context.llmCall({
+    type: "protagonist-detect",
+    clips: entry.clips,
+    mainCharacter: context.mainCharacter,
+  });
+
+  const ratio = result?.protagonist_ratio ?? result?.ratio ?? 0;
+  const threshold =
+    context.thresholds?.protagonist_ratio ??
+    DEFAULT_THRESHOLDS.protagonist_ratio;
+
+  return {
+    pass: ratio >= threshold,
+    score: ratio,
+    reason:
+      ratio >= threshold
+        ? `Protagonist ratio ${(ratio * 100).toFixed(0)}% >= ${(threshold * 100).toFixed(0)}%`
+        : `Protagonist ratio ${(ratio * 100).toFixed(0)}% < ${(threshold * 100).toFixed(0)}% threshold`,
+  };
+});
+
+registerChecker("aesthetic-score", async (entry, context) => {
+  if (!context.llmCall) {
+    return { pass: true, score: 3.0, reason: "No VLM available, skipped" };
+  }
+
+  const result = await context.llmCall({
+    type: "aesthetic-analysis",
+    clips: entry.clips,
+  });
+
+  const score = result?.overall_aesthetic_score ?? 3.0;
+  const threshold =
+    context.thresholds?.aesthetic_score ?? DEFAULT_THRESHOLDS.aesthetic_score;
+
+  return {
+    pass: score >= threshold,
+    score,
+    reason:
+      score >= threshold
+        ? `Aesthetic ${score.toFixed(1)} >= ${threshold}`
+        : `Aesthetic ${score.toFixed(1)} < ${threshold} threshold`,
+  };
+});
+
+/**
+ * Review an entry against specified checkers.
+ *
+ * @param {object} entry - shot_point entry with clips
+ * @param {string[]} checkerNames - names of checkers to run
+ * @param {object} context - { llmCall, mainCharacter, thresholds }
+ * @returns {{ pass: boolean, checks: object[], aggregateScore: number }}
+ */
+export async function reviewEntry(entry, checkerNames, context) {
+  const checks = [];
+
+  for (const name of checkerNames) {
+    const checker = checkerRegistry.get(name);
+    if (!checker) {
+      checks.push({
+        name,
+        pass: true,
+        score: 0,
+        reason: `Unknown checker: ${name}`,
+      });
+      continue;
+    }
+
+    try {
+      const result = await checker.check(entry, context);
+      checks.push({ name, ...result });
+    } catch (err) {
+      checks.push({
+        name,
+        pass: false,
+        score: 0,
+        reason: `Checker error: ${err.message}`,
+      });
+    }
+  }
+
+  const allPass = checks.every((c) => c.pass);
+  const aggregateScore =
+    checks.length > 0
+      ? checks.reduce((s, c) => s + c.score, 0) / checks.length
+      : 0;
+
+  return { pass: allPass, checks, aggregateScore };
+}
+
+/**
+ * Quality-check policy for ApprovalGate integration.
+ *
+ * Usage:
+ *   const policy = createQualityCheckPolicy(["vision-protagonist"], { thresholds, onFail: "rerun" });
+ *   const result = await policy.evaluate(entry, context);
+ */
+export function createQualityCheckPolicy(checkerNames, options = {}) {
+  return {
+    type: "quality-check",
+    checkers: checkerNames,
+    onFail: options.onFail || "rerun",
+    thresholds: options.thresholds || DEFAULT_THRESHOLDS,
+
+    async evaluate(entry, context) {
+      const mergedCtx = {
+        ...context,
+        thresholds: {
+          ...DEFAULT_THRESHOLDS,
+          ...this.thresholds,
+          ...context.thresholds,
+        },
+      };
+      const review = await reviewEntry(entry, this.checkers, mergedCtx);
+      return {
+        ...review,
+        action: review.pass ? "approve" : this.onFail,
+      };
+    },
+  };
+}

package/src/skills/video-editing/tools/commit.js

@@ -0,0 +1,108 @@
+/**
+ * video_commit_clip — 提交选定片段（最多 3 段拼接成一个镜头）
+ */
+
+import { promises as fs } from "fs";
+import path from "path";
+
+export const TOOL_DEF = {
+  name: "video_commit_clip",
+  description:
+    "Finalize shot selection with multi-clip stitching (up to 3 clips per output).",
+  inputSchema: {
+    type: "object",
+    properties: {
+      section_idx: {
+        type: "number",
+        description: "Section index in shot plan",
+      },
+      shot_idx: { type: "number", description: "Shot index within section" },
+      clips: {
+        type: "array",
+        items: {
+          type: "object",
+          properties: {
+            start: { type: "number" },
+            end: { type: "number" },
+          },
+          required: ["start", "end"],
+        },
+        maxItems: 3,
+        description: "1-3 clips to stitch",
+      },
+    },
+    required: ["section_idx", "shot_idx", "clips"],
+  },
+  isReadOnly: false,
+  riskLevel: "MEDIUM",
+  availableInPlanMode: false,
+};
+
+export async function execute({ section_idx, shot_idx, clips }, context) {
+  if (!clips || clips.length === 0) {
+    return { status: "error", message: "No clips provided." };
+  }
+  if (clips.length > 3) {
+    return { status: "error", message: "Max 3 clips per commit." };
+  }
+
+  for (const clip of clips) {
+    if (clip.end <= clip.start) {
+      return {
+        status: "error",
+        message: `Invalid clip: start=${clip.start} >= end=${clip.end}`,
+      };
+    }
+  }
+
+  const committed = context.committedClips || [];
+  for (const clip of clips) {
+    for (const existing of committed) {
+      if (clip.start < existing.end && clip.end > existing.start) {
+        return {
+          status: "conflict",
+          message: `Clip [${clip.start}-${clip.end}] overlaps with committed [${existing.start}-${existing.end}]`,
+        };
+      }
+    }
+  }
+
+  const totalDuration = clips.reduce((s, c) => s + (c.end - c.start), 0);
+  const entry = {
+    section_idx,
+    shot_idx,
+    clips: clips.map((c, i) => ({
+      idx: i,
+      start: c.start,
+      end: c.end,
+      duration: parseFloat((c.end - c.start).toFixed(3)),
+    })),
+    total_duration: parseFloat(totalDuration.toFixed(3)),
+    committed_at: new Date().toISOString(),
+  };
+
+  committed.push(
+    ...clips.map((c) => ({
+      start: c.start,
+      end: c.end,
+      section_idx,
+      shot_idx,
+    })),
+  );
+  context.committedClips = committed;
+
+  if (context.shotPointPath) {
+    let existing = [];
+    try {
+      const raw = await fs.readFile(context.shotPointPath, "utf-8");
+      existing = JSON.parse(raw);
+    } catch {}
+    existing.push(entry);
+    await fs.writeFile(
+      context.shotPointPath,
+      JSON.stringify(existing, null, 2),
+    );
+  }
+
+  return { status: "success", ...entry };
+}

package/src/skills/video-editing/tools/review-clip.js

@@ -0,0 +1,46 @@
+/**
+ * video_review_clip — 检查候选片段与已 commit 片段的时间区间冲突
+ */
+
+export const TOOL_DEF = {
+  name: "video_review_clip",
+  description:
+    "Check a candidate clip for overlap against previously committed clips.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      start: { type: "number", description: "Candidate start time (seconds)" },
+      end: { type: "number", description: "Candidate end time (seconds)" },
+    },
+    required: ["start", "end"],
+  },
+  isReadOnly: true,
+  riskLevel: "LOW",
+  availableInPlanMode: true,
+};
+
+export function execute({ start, end }, context) {
+  const committed = context.committedClips || [];
+  const overlaps = [];
+
+  for (const clip of committed) {
+    if (start < clip.end && end > clip.start) {
+      overlaps.push({
+        conflict_with: clip,
+        overlap_start: Math.max(start, clip.start),
+        overlap_end: Math.min(end, clip.end),
+        overlap_duration: Math.min(end, clip.end) - Math.max(start, clip.start),
+      });
+    }
+  }
+
+  return {
+    candidate: { start, end, duration: end - start },
+    has_conflict: overlaps.length > 0,
+    overlaps,
+    suggestion:
+      overlaps.length > 0
+        ? `Avoid time ranges: ${overlaps.map((o) => `[${o.overlap_start.toFixed(1)}-${o.overlap_end.toFixed(1)}]`).join(", ")}`
+        : "No conflicts, safe to commit.",
+  };
+}

package/src/skills/video-editing/tools/semantic-retrieval.js

@@ -0,0 +1,56 @@
+/**
+ * video_semantic_retrieval — 在 scene 索引中按范围拉候选镜头
+ */
+
+import { promises as fs } from "fs";
+import path from "path";
+
+export const TOOL_DEF = {
+  name: "video_semantic_retrieval",
+  description:
+    "Explore scene metadata within a bounded range to discover candidate shots.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      scene_start: {
+        type: "number",
+        description: "Start scene index (inclusive)",
+      },
+      scene_end: { type: "number", description: "End scene index (inclusive)" },
+      query: {
+        type: "string",
+        description: "Optional semantic query to filter by",
+      },
+    },
+    required: ["scene_start", "scene_end"],
+  },
+  isReadOnly: true,
+  riskLevel: "LOW",
+  availableInPlanMode: true,
+};
+
+export async function execute({ scene_start, scene_end, query }, context) {
+  const scenePath = path.join(context.assetDir, "scene.json");
+  const raw = await fs.readFile(scenePath, "utf-8");
+  const { scenes } = JSON.parse(raw);
+
+  const start = Math.max(0, scene_start);
+  const end = Math.min(scenes.length - 1, scene_end);
+  let candidates = scenes.slice(start, end + 1).map((s, i) => ({
+    scene_idx: start + i,
+    ...s,
+  }));
+
+  if (query) {
+    const q = query.toLowerCase();
+    candidates = candidates.filter((c) =>
+      JSON.stringify(c).toLowerCase().includes(q),
+    );
+  }
+
+  return {
+    total_scenes: scenes.length,
+    range: [start, end],
+    candidates,
+  };
+}