akari-video 0.1.0

package/vendor/skills/compile-review-session/bin/core/canvas-compiler.mjs

@@ -0,0 +1,105 @@
+// キャンバス面（contract-2026-07-26-canvas-surface）の review/canvas/c-NNNN/ 記録原本を
+// review.json annotation へ着地させるための純関数群。session 系（compiler.mjs / time-mapping.mjs）と
+// 違い、キャンバスには timeline/cuts が存在しないため参照解決は不要 — target は常に
+// `canvas:<id>` に固定される。v0 は録音なし（audio は常に null）のため、strokes + メモを
+// 1 annotation に集約する経路のみを実装する（契約 §3「録音なしでも成立する」・
+// report.md の調査結果: 録音ありの発話ペアリング経路は本タスクでは未実装）。
+
+const CANVAS_ID_PATTERN = /^c-(\d{4,})$/;
+const STROKE_ID_PATTERN = /^st-\d{4,}$/;
+
+export function isValidCanvasId(id) {
+  return typeof id === "string" && CANVAS_ID_PATTERN.test(id);
+}
+
+/** canvas.json（契約 §2）の構造検証。不正なら null を返す（呼び出し側が warning + skip する）。 */
+export function validateCanvasManifest(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+  if (value.version !== 0) return null;
+  if (typeof value.id !== "string" || !isValidCanvasId(value.id)) return null;
+  if (typeof value.createdAt !== "string" || !value.createdAt.trim()) return null;
+  const aspect = value.aspect;
+  if (!aspect || typeof aspect !== "object"
+    || !Number.isFinite(aspect.w) || aspect.w <= 0
+    || !Number.isFinite(aspect.h) || aspect.h <= 0) {
+    return null;
+  }
+  if (value.background !== null) {
+    const background = value.background;
+    if (
+      !background || typeof background !== "object"
+      || typeof background.ref !== "string" || !background.ref.trim()
+      || typeof background.hash !== "string" || !/^sha256:[a-f0-9]{64}$/.test(background.hash)
+    ) {
+      return null;
+    }
+  }
+  if (value.audio !== null && typeof value.audio !== "string") return null;
+  if (value.memo !== undefined && value.memo !== null && typeof value.memo !== "string") return null;
+  if (!["recorded", "compiled"].includes(value.status)) return null;
+  return value;
+}
+
+/** strokes.json（review-session §4.1 と同型・space canvas-rect・frame なし）1 要素の検証。 */
+export function validateCanvasStroke(stroke) {
+  return Boolean(
+    stroke
+    && typeof stroke === "object"
+    && STROKE_ID_PATTERN.test(stroke.id)
+    && stroke.tool === "pen"
+    && stroke.space === "canvas-rect"
+    && Array.isArray(stroke.points)
+    && stroke.points.length >= 2
+    && stroke.points.every((point) => (
+      Array.isArray(point)
+      && point.length === 2
+      && point.every((value) => Number.isFinite(value) && value >= 0 && value <= 1)
+    )),
+  );
+}
+
+export function simplifyCanvasStrokePoints(points, maximum = 100) {
+  if (points.length <= maximum) return points;
+  return Array.from({ length: maximum }, (_, index) => (
+    points[Math.round((index * (points.length - 1)) / (maximum - 1))]
+  ));
+}
+
+/**
+ * 録音なしキャンバスの着地（契約 §4「strokes + 添付メモを1 annotation にまとめて着地
+ * （分割の材料がないため）」）。全ストロークを canvasRef 付きで埋め込む。
+ */
+export function buildMemoOnlyCanvasAnnotation({ canvasId, strokes, memo, createdAt }) {
+  const trimmedMemo = typeof memo === "string" ? memo.trim() : "";
+  const text = trimmedMemo || "キャンバスにペンで構図案を記録（メモなし）";
+  const embeddedStrokes = strokes.length > 0
+    ? strokes.map((stroke) => ({
+      tool: "pen",
+      space: "canvas-rect",
+      points: simplifyCanvasStrokePoints(stroke.points),
+      canvasRef: `${canvasId}/${stroke.id}`,
+    }))
+    : null;
+  return {
+    createdAt,
+    sourceT: null,
+    sourceRange: null,
+    timelineT: null,
+    target: `canvas:${canvasId}`,
+    targetKind: null,
+    region: null,
+    strokes: embeddedStrokes,
+    refs: null,
+    insertPosition: null,
+    intent: null,
+    text,
+    // 録音なし v0（audio は常に null）: メモは typed テキストとして扱う（契約 §3）。
+    input: "typed",
+    audio: null,
+    transcript: null,
+    session: null,
+    poses: null,
+    status: "open",
+    response: null,
+  };
+}

package/vendor/skills/compile-review-session/bin/core/compiler.mjs

@@ -0,0 +1,221 @@
+import { resolveUtteranceReference } from "./time-mapping.mjs";
+
+function joinText(parts) {
+  return parts.reduce((result, part) => {
+    const text = String(part ?? "").trim();
+    if (!text) return result;
+    if (!result) return text;
+    const needsSpace = /[A-Za-z0-9]$/.test(result) && /^[A-Za-z0-9]/.test(text);
+    return `${result}${needsSpace ? " " : ""}${text}`;
+  }, "");
+}
+
+function makeUtterance(words, fallback) {
+  const validWords = words.filter((word) => (
+    Number.isFinite(word?.start)
+    && Number.isFinite(word?.end)
+    && word.end > word.start
+    && String(word?.text ?? "").trim()
+  ));
+  if (validWords.length === 0) {
+    return {
+      text: String(fallback.text ?? "").trim(),
+      recT: [fallback.start, fallback.end],
+      words: [],
+    };
+  }
+  return {
+    text: joinText(validWords.map((word) => word.text)),
+    recT: [validWords[0].start, validWords.at(-1).end],
+    words: validWords,
+  };
+}
+
+export function segmentUtterances(segments, mergeGapSeconds = 0.3) {
+  const sorted = [...segments]
+    .filter((segment) => (
+      Number.isFinite(segment?.start)
+      && Number.isFinite(segment?.end)
+      && segment.end > segment.start
+      && String(segment?.text ?? "").trim()
+    ))
+    .sort((left, right) => left.start - right.start);
+  const merged = [];
+  for (const segment of sorted) {
+    const normalized = {
+      start: segment.start,
+      end: segment.end,
+      text: String(segment.text).trim(),
+      words: Array.isArray(segment.words) ? [...segment.words].sort((a, b) => a.start - b.start) : [],
+    };
+    const previous = merged.at(-1);
+    if (previous && normalized.start - previous.end < mergeGapSeconds) {
+      previous.end = Math.max(previous.end, normalized.end);
+      previous.text = joinText([previous.text, normalized.text]);
+      previous.words.push(...normalized.words);
+    } else {
+      merged.push(normalized);
+    }
+  }
+
+  const utterances = [];
+  for (const segment of merged) {
+    if (segment.words.length === 0) {
+      utterances.push(makeUtterance([], segment));
+      continue;
+    }
+    const chunks = [];
+    let current = [];
+    for (let index = 0; index < segment.words.length; index += 1) {
+      const word = segment.words[index];
+      current.push(word);
+      const hasMore = index < segment.words.length - 1;
+      if (hasMore && /[。！？!?]/.test(String(word.text ?? ""))) {
+        chunks.push(current);
+        current = [];
+      }
+    }
+    if (current.length > 0) chunks.push(current);
+    if (chunks.length === 1) {
+      utterances.push({
+        ...makeUtterance(chunks[0], segment),
+        // backend の segment 原文はゼロ幅 token を落とした words 結合より忠実。
+        text: segment.text,
+      });
+    } else {
+      for (const chunk of chunks) utterances.push(makeUtterance(chunk, segment));
+    }
+  }
+  return utterances.filter((utterance) => utterance.text);
+}
+
+const DISCARD_PATTERNS = [
+  { pattern: /音声\s*チェック|マイク\s*チェック/, reason: "システム動作確認であり編集指示ではない" },
+  { pattern: /これは\s*テスト|テストです/, reason: "テスト発話であり編集指示ではない" },
+  { pattern: /独り言|雑談/, reason: "独り言・雑談であり編集指示ではない" },
+];
+
+const EDITING_TERMS = /テロップ|字幕|文字|カット|削除|場面|シーン|切り替え|タイミング|BGM|背景の音楽|音量|大き|小さ|静か|調整|短く|長く|明る|暗く|色|クロップ|ズーム|効果音|ナレーション/;
+const REQUEST_TERMS = /して|ほしい|ください|下げ|上げ|削除|カット|調整|変え|直し|大き|小さ/;
+
+export function provisionalJudgement(transcript) {
+  const text = String(transcript ?? "").replace(/\s+/g, " ").trim();
+  const discard = DISCARD_PATTERNS.find(({ pattern }) => pattern.test(text));
+  if (discard && !EDITING_TERMS.test(text.replace(discard.pattern, ""))) {
+    return { action: "discard", reason: discard.reason, text: null, confidence: "high" };
+  }
+
+  let normalized = null;
+  if (/テロップ|字幕/.test(text) && /文字|大き|拡大/.test(text)) {
+    normalized = "テロップの文字を大きくする";
+  } else if (/カット|場面|シーン/.test(text) && /削除|カットして/.test(text)) {
+    normalized = "このカットを削除する";
+  } else if (/シーン\s*切り替え|切り替え/.test(text) && /タイミング|調整/.test(text)) {
+    normalized = "シーン切り替えのタイミングを調整する";
+  } else if (/BGM|背景の音楽|音楽/.test(text) && /静か|音量|下げ/.test(text)) {
+    normalized = "BGMの音量を下げる";
+  } else if (EDITING_TERMS.test(text) && REQUEST_TERMS.test(text)) {
+    normalized = text
+      .replace(/してください[。.!！?？]?$/, "する")
+      .replace(/してほしい[。.!！?？]?$/, "する")
+      .replace(/して欲しい[。.!！?？]?$/, "する")
+      .replace(/[。.!！?？]+$/, "");
+  }
+
+  if (normalized) {
+    return { action: "annotate", reason: "編集対象と変更要求を含む", text: normalized, confidence: "high" };
+  }
+  return {
+    action: "annotate",
+    reason: "編集指示か否か、または命令形への正規化に確信がない",
+    text: text || "発話内容を確認する",
+    confidence: "low",
+  };
+}
+
+function confirmationText(normalizedText, reference, judgement) {
+  const candidateText = reference.candidates.length > 0
+    ? `候補 timelineT: ${reference.candidates.map((value) => value.toFixed(3)).join(", ")}`
+    : `暫定位置 timelineT: ${reference.timelineT.toFixed(3)}`;
+  const reason = judgement.confidence === "low" ? judgement.reason : "参照先が一意に決まらない";
+  return `[要確認] ${normalizedText}（${candidateText}。${reason}ため、この対象でよいか確認してください）`;
+}
+
+export function buildProposals({ utterances, trace, cutMap, strokes = [] }) {
+  return utterances.map((utterance, index) => {
+    const reference = resolveUtteranceReference({ utterance, trace, cutMap, strokes });
+    const provisional = provisionalJudgement(utterance.text);
+    return {
+      index,
+      transcript: utterance.text,
+      recRange: utterance.recT,
+      reference,
+      provisional,
+      decision: null,
+    };
+  });
+}
+
+export function chooseProposalDecision(proposal) {
+  const decision = proposal.decision && typeof proposal.decision === "object"
+    ? proposal.decision
+    : proposal.provisional;
+  const action = decision.action === "discard" ? "discard" : "annotate";
+  const confidence = decision.confidence === "low" ? "low" : (
+    proposal.reference.confidence === "low" ? "low" : "high"
+  );
+  return {
+    action,
+    reason: String(decision.reason ?? proposal.provisional.reason ?? "理由未記入"),
+    text: action === "annotate"
+      ? String(decision.text ?? proposal.provisional.text ?? proposal.transcript).trim()
+      : null,
+    confidence,
+  };
+}
+
+export function proposalToAnnotation({ proposal, decision, sessionId, audioPath, createdAt }) {
+  const needsConfirmation = decision.confidence === "low" || proposal.reference.confidence === "low";
+  const pairedStroke = proposal.reference.pairedStroke;
+  const simplifiedPoints = pairedStroke
+    ? simplifyStrokePoints(pairedStroke.points)
+    : null;
+  return {
+    createdAt,
+    sourceT: proposal.reference.sourceT,
+    sourceRange: proposal.reference.sourceRange,
+    timelineT: proposal.reference.timelineT,
+    target: proposal.reference.target,
+    text: needsConfirmation
+      ? confirmationText(decision.text, proposal.reference, decision)
+      : decision.text,
+    input: "session",
+    audio: audioPath,
+    strokes: pairedStroke ? [{
+      tool: "pen",
+      space: "content-rect",
+      frame: {
+        sourceT: pairedStroke.frame.sourceT,
+        cutIndex: pairedStroke.frame.cutIndex,
+      },
+      points: simplifiedPoints,
+      sessionRef: `${sessionId}/${pairedStroke.id}`,
+    }] : null,
+    poses: null,
+    status: "open",
+    response: null,
+    transcript: proposal.transcript,
+    session: {
+      id: sessionId,
+      recRange: proposal.recRange,
+      confidence: needsConfirmation ? "low" : "high",
+    },
+  };
+}
+
+function simplifyStrokePoints(points, maximum = 100) {
+  if (points.length <= maximum) return points;
+  return Array.from({ length: maximum }, (_, index) => (
+    points[Math.round(index * (points.length - 1) / (maximum - 1))]
+  ));
+}

package/vendor/skills/compile-review-session/bin/core/review-store.mjs

@@ -0,0 +1,74 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export const EMPTY_REVIEW_SOURCE = '{\n  "version": 0,\n  "annotations": [\n  ]\n}\n';
+
+export async function writeAtomic(destination, source) {
+  await fs.mkdir(path.dirname(destination), { recursive: true });
+  const temporary = `${destination}.${process.pid}.${Date.now()}.tmp`;
+  try {
+    await fs.writeFile(temporary, source);
+    await fs.rename(temporary, destination);
+  } catch (error) {
+    await fs.rm(temporary, { force: true }).catch(() => {});
+    throw error;
+  }
+}
+
+export async function writeJsonAtomic(destination, value) {
+  await writeAtomic(destination, `${JSON.stringify(value, null, 2)}\n`);
+}
+
+export function appendAnnotationLine(source, annotation) {
+  const closing = /\n([ \t]*)\](\s*\}\s*\n?)$/.exec(source);
+  if (!closing) throw new Error("review.json の annotations 配列の閉じ括弧を確認できません");
+  const indent = closing[1];
+  const itemIndent = `${indent}  `;
+  const beforeClosing = source.slice(0, closing.index);
+  const isEmpty = /\[\s*$/.test(beforeClosing);
+  const serialized = JSON.stringify(annotation);
+  const line = isEmpty ? `${itemIndent}${serialized}` : `${itemIndent}, ${serialized}`;
+  return `${beforeClosing}\n${line}\n${indent}]${closing[2]}`;
+}
+
+export function nextAnnotationNumber(annotations) {
+  return annotations.reduce((maximum, annotation) => {
+    const match = /^a-(\d{4,})$/.exec(annotation?.id);
+    return match ? Math.max(maximum, Number(match[1])) : maximum;
+  }, 0) + 1;
+}
+
+export function formatAnnotationId(number) {
+  return `a-${String(number).padStart(4, "0")}`;
+}
+
+export async function appendAnnotationsAtomic(reviewPath, annotations) {
+  let source;
+  try {
+    source = await fs.readFile(reviewPath, "utf8");
+  } catch (error) {
+    if (error?.code !== "ENOENT") throw error;
+    source = EMPTY_REVIEW_SOURCE;
+  }
+
+  let parsed;
+  try {
+    parsed = JSON.parse(source);
+  } catch {
+    throw new Error("review.json が有効な JSON ではありません");
+  }
+  if (!parsed || !Array.isArray(parsed.annotations)) {
+    throw new Error("review.json に annotations 配列がありません");
+  }
+
+  let nextNumber = nextAnnotationNumber(parsed.annotations);
+  let updated = source;
+  const assigned = annotations.map((annotation) => {
+    const withId = { ...annotation, id: formatAnnotationId(nextNumber) };
+    nextNumber += 1;
+    updated = appendAnnotationLine(updated, withId);
+    return withId;
+  });
+  if (assigned.length > 0) await writeAtomic(reviewPath, updated);
+  return assigned;
+}