video-editing 1.3.1 → 3.0.0

package/dist/index.js

@@ -1,300 +1,351 @@
 #!/usr/bin/env node
 import {
   CAPABILITIES,
-  COMPOSE_AUDIO_SRC,
-  COMPOSE_ENTRY,
-  COMPOSE_HEIGHT,
-  COMPOSE_VIDEO_SRC,
-  COMPOSE_WIDTH,
-  DEFAULT_DESILENCE,
-  PRESETS,
-  agentizePrompt,
-  artifactPaths,
-  autoGradeForClip,
+  CAPTION_STYLE_DEFAULTS,
+  CloudClient,
+  CloudHttpError,
+  DEFAULT_DOWNLOAD_TIMEOUT_MS,
+  DEFAULT_TIMEOUT_MS,
+  INLINE_MAX_BYTES,
+  MAX_POLL_MS,
+  MAX_RUN_POLL_MS,
+  MULTIPART_THRESHOLD_BYTES,
+  RELAY_DIRECT_ATTEMPTS,
+  RELAY_SUBCHUNK_BYTES,
+  REVIEW_STAGES2,
+  assertRunCompleted,
+  assetContentType2,
+  assetsUrl,
+  bundledSkillDir,
+  bytesSource,
   checkCapabilities,
-  compileTimeline,
-  composeCounts,
-  composeHtml,
-  computeEnvelope,
-  configDir,
-  configEnvPath,
-  cutBoundaries,
-  decideGradeFilter,
-  desilenceEdl,
-  detectSilences,
-  diagnosticsPath,
-  duplicatedPhrase,
-  duplicatedPhrases,
-  duplicatedSpans,
-  edlPath,
-  ensureTranscribed,
-  ensureVerticalMaster,
-  findPhrase,
-  fuzzySuggestions,
-  gatherCompileCtx,
-  generateQcImages,
-  getPreset,
-  learnedEditingGuardrails,
-  loadApiKey,
-  loadTimeline,
-  loadWords,
-  loadWordsBySource,
-  normalizePhrase,
-  normalizeToken,
-  packTranscripts,
-  parseSilenceDetect,
+  collectPlanAssetRefs2,
+  compileRemote,
+  compileUrl,
+  composeUrl,
+  defaultRenderOut,
+  defaultSkillTarget,
+  diagnosticsPath2,
+  downloadTo,
+  emptyDiagnostics,
+  filesUrl,
+  formatRunEvent,
+  framesPngPath,
+  ingestArtifactSet,
+  ingestUrl,
+  initCloudJob,
+  installSkill,
+  instructionPath2,
+  isTerminalRunStatus,
+  isTerminalStatus,
+  jobJsonPath,
+  joinSourceWindows,
+  loadPublicConfigEnv,
+  loadTimeline2,
+  meUrl,
+  multipartRelayUrl,
+  multipartUrl,
+  openFileSource,
+  outWindowToSourceWindows,
+  parseFileContent,
+  parseFileList,
+  parseFilePresign,
+  parseRenderCreate,
+  parseRenderState,
+  parseRunState,
   parseTimeline,
-  planPath,
-  readEdl,
-  render,
-  resolvePhrase,
-  screenTakes,
-  sha256File,
-  silenceDetectArgs,
-  statusPayload,
-  straddlingGap,
-  tightenRange,
-  tightenRanges,
-  timelineFromEdl,
-  timelineHash,
-  timelineJsonPath,
+  planPath2,
+  pollRender,
+  pollRun,
+  projectVideosUrl,
+  projectsUrl,
+  publicConfigDir,
+  publicConfigEnvPath,
+  pullFiles,
+  pullReview2,
+  pushComplete2,
+  pushFiles,
+  pushStage2,
+  pushTimeline2,
+  qaDir,
+  readJobFile,
+  readOutcomesFile2,
+  readPlanSegments,
+  readProbeDuration,
+  renderUrl,
+  rendersUrl,
+  resolveApiBase,
+  resolveApiKey,
+  resolveConfig,
+  resolveRunId2,
+  resolveUrl,
+  resolveVideoId,
+  reviewDir2,
+  reviewUrl,
+  roundJsonPath2,
+  runUrl,
+  sameSha,
+  sanitizeStem,
+  savePublicConfigKey,
+  sha256Hex,
+  shouldMultipart,
+  statAssetsForDoc,
+  stripTrailingSlash,
+  syncAssets2,
+  timelineJsonPath2,
   timelineV2Schema,
-  timelineView,
-  transcribeOne,
-  transcriptFileForSource,
-  updateCaptionsBlock,
+  toVfsPath,
+  transcribeArtifactSet,
+  transcribeCloud,
+  transcribeUrl,
+  uploadMultipart,
+  uploadVfsBytes,
+  uploadVfsPayload,
   usesFromDoc,
+  validateLocal,
   validateTimeline,
-  verify,
-  wordStream,
-  writeAgentManifest,
-  writeBoundaries,
-  writeCompileArtifacts,
-  writeCoverage,
-  writeSilencePrompt,
-  writeTranscriptArtifacts,
-  writeVideoEditingPrompt,
-  writeWarningsFromReview,
-  writeWordDump
-} from "./chunk-63HIQBDT.js";
-import {
-  CommandError,
-  DEFAULT_EDIT_ROOT,
-  VIDEO_EXTS,
-  defaultJobDir,
-  displayedDimensions,
-  ffprobe,
-  initJob,
-  isoNow,
-  loadJob,
-  mediaDuration,
-  pyFixed,
-  pyFixedPad,
-  pyRound,
-  pySpacePad,
-  requireFfmpeg,
-  resolveJob,
-  rotationDegrees,
-  run,
-  runSync,
-  shown,
-  slugify,
-  sourceFromJob,
-  transcriptPath,
-  videoStream
-} from "./chunk-CU3NBKB4.js";
+  verifyCloud,
+  verifyUrl,
+  vfsContentType,
+  vfsLocalPath,
+  videoIdFromJob,
+  waveformPngPath,
+  waveformWordsPath,
+  writeJobFile
+} from "./chunk-W4IIL2T2.js";
 
-// src/transcribe-batch.ts
-import { existsSync, mkdirSync, readdirSync, statSync } from "fs";
-import { basename, extname, join } from "path";
-import pLimit from "p-limit";
-var VIDEO_EXTS2 = /* @__PURE__ */ new Set([
-  ".mp4",
-  ".MP4",
-  ".mov",
-  ".MOV",
-  ".mkv",
-  ".MKV",
-  ".avi",
-  ".AVI",
-  ".m4v"
-]);
-function findVideos(videosDir) {
-  const entries = readdirSync(videosDir).map((name) => join(videosDir, name)).filter((p) => {
-    let isFile;
-    try {
-      isFile = statSync(p).isFile();
-    } catch {
-      return false;
-    }
-    return isFile && VIDEO_EXTS2.has(extname(p));
+// src/timeline-v2/anchors.ts
+function normalizeToken(text) {
+  return text.trim().toLowerCase().replace(/^[^\p{L}\p{N}]+/gu, "").replace(/[^\p{L}\p{N}]+$/gu, "");
+}
+function normalizePhrase(phrase) {
+  return phrase.split(/\s+/).map(normalizeToken).filter((t) => t.length > 0);
+}
+function wordStream(transcript) {
+  const words = [];
+  for (const w of transcript.words ?? []) {
+    if ((w.type ?? "word") !== "word") continue;
+    if (typeof w.start !== "number" || typeof w.end !== "number") continue;
+    words.push(w);
+  }
+  words.sort((a, b) => Number(a.start) - Number(b.start) || Number(a.end) - Number(b.end));
+  return words.map((w, i) => {
+    const text = (w.text ?? "").trim();
+    return { index: i, start: Number(w.start), end: Number(w.end), text, norm: normalizeToken(text) };
   });
-  entries.sort();
-  return entries;
 }
-function stemOf(p) {
-  return basename(p, extname(p));
+function contextAround(stream, from, to, pad = 5) {
+  const before = stream.slice(Math.max(0, from - pad), from).map((w) => w.text);
+  const matched = stream.slice(from, to + 1).map((w) => w.text);
+  const after = stream.slice(to + 1, to + 1 + pad).map((w) => w.text);
+  const parts = [];
+  if (from - pad > 0) parts.push("\u2026");
+  parts.push(...before, `\xAB${matched.join(" ")}\xBB`, ...after);
+  if (to + 1 + pad < stream.length) parts.push("\u2026");
+  return parts.join(" ");
 }
-async function transcribeBatch(videosDir, opts = {}) {
-  const { workers = 4, language, numSpeakers, apiKey } = opts;
-  if (!existsSync(videosDir) || !statSync(videosDir).isDirectory()) {
-    throw new Error(`not a directory: ${videosDir}`);
+function findPhrase(stream, phrase) {
+  const tokens = normalizePhrase(phrase);
+  if (tokens.length === 0) return [];
+  const matches = [];
+  for (let i = 0; i + tokens.length <= stream.length; i++) {
+    let ok = true;
+    for (let j = 0; j < tokens.length; j++) {
+      if (stream[i + j].norm !== tokens[j]) {
+        ok = false;
+        break;
+      }
+    }
+    if (!ok) continue;
+    const last = i + tokens.length - 1;
+    matches.push({
+      occurrence: matches.length + 1,
+      start: stream[i].start,
+      end: stream[last].end,
+      words: stream.slice(i, last + 1).map((w) => ({ start: w.start, end: w.end, text: w.text })),
+      context: contextAround(stream, i, last),
+      wordIndex: i
+    });
   }
-  const editDir = opts.editDir ?? join(videosDir, "edit");
-  mkdirSync(join(editDir, "transcripts"), { recursive: true });
-  const videos = findVideos(videosDir);
-  if (videos.length === 0) {
-    throw new Error(`no videos found in ${videosDir}`);
+  return matches;
+}
+function levenshtein(a, b) {
+  const m = a.length;
+  const n = b.length;
+  if (m === 0) return n;
+  if (n === 0) return m;
+  let prev = new Array(n + 1);
+  let cur = new Array(n + 1);
+  for (let j = 0; j <= n; j++) prev[j] = j;
+  for (let i = 1; i <= m; i++) {
+    cur[0] = i;
+    for (let j = 1; j <= n; j++) {
+      const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+      cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
+    }
+    [prev, cur] = [cur, prev];
+  }
+  return prev[n];
+}
+function fuzzySuggestions(stream, phrase, limit = 3) {
+  const tokens = normalizePhrase(phrase);
+  if (tokens.length === 0 || stream.length === 0) return [];
+  const target = tokens.join(" ");
+  const n = Math.min(tokens.length, stream.length);
+  const scored = [];
+  for (let i = 0; i + n <= stream.length; i++) {
+    const window = stream.slice(i, i + n);
+    const joined = window.map((w) => w.norm).join(" ");
+    const dist = levenshtein(target, joined);
+    const similarity = 1 - dist / Math.max(target.length, joined.length, 1);
+    scored.push({
+      start: window[0].start,
+      end: window[n - 1].end,
+      text: window.map((w) => w.text).join(" "),
+      similarity: Math.round(similarity * 1e3) / 1e3
+    });
+  }
+  scored.sort((a, b) => b.similarity - a.similarity || a.start - b.start);
+  return scored.slice(0, limit).filter((s) => s.similarity > 0);
+}
+function resolvePhrase(stream, phrase, opts = {}) {
+  const matches = findPhrase(stream, phrase);
+  if (matches.length === 0) {
+    return { status: "not-found", suggestions: fuzzySuggestions(stream, phrase) };
   }
-  const alreadyCached = videos.filter(
-    (v) => existsSync(join(editDir, "transcripts", `${stemOf(v)}.json`))
-  );
-  const cachedSet = new Set(alreadyCached);
-  const pending = videos.filter((v) => !cachedSet.has(v));
-  console.error(
-    `found ${videos.length} videos (${alreadyCached.length} cached, ${pending.length} to transcribe)`
-  );
-  if (pending.length === 0) {
-    console.error("nothing to do");
-    return { videos, cached: alreadyCached, transcribed: [], errors: [] };
+  if (opts.occurrence !== void 0) {
+    const m = matches[opts.occurrence - 1];
+    if (!m) return { status: "ambiguous", candidates: matches };
+    return { status: "ok", match: m, matches };
   }
-  console.error(`transcribing ${pending.length} files with ${workers} parallel workers`);
-  const t0 = Date.now();
-  const errors = [];
-  const transcribed = [];
-  const limit = pLimit(workers);
-  await Promise.all(
-    pending.map(
-      (v) => limit(async () => {
-        try {
-          const out = await transcribeOne(v, {
-            editDir,
-            language,
-            numSpeakers,
-            apiKey,
-            verbose: false
-          });
-          transcribed.push(out);
-          console.error(`  + ${stemOf(v)}  ->  ${basename(out)}`);
-        } catch (e) {
-          const message = String(e instanceof Error ? e.message : e);
-          errors.push({ video: v, message });
-          console.error(`  x ${stemOf(v)}  FAILED: ${message}`);
-        }
-      })
-    )
-  );
-  const dt = (Date.now() - t0) / 1e3;
-  console.error(`
-done in ${dt.toFixed(1)}s`);
-  if (errors.length) {
-    console.error(`${errors.length} failures:`);
-    for (const { video, message } of errors) {
-      console.error(`  ${basename(video)}: ${message}`);
+  if (matches.length === 1) return { status: "ok", match: matches[0], matches };
+  if (opts.nearS !== void 0) {
+    const near = opts.nearS;
+    let best = matches[0];
+    for (const m of matches) {
+      if (Math.abs(m.start - near) < Math.abs(best.start - near)) best = m;
     }
+    return { status: "ok", match: best, matches };
   }
-  return { videos, cached: alreadyCached, transcribed, errors };
+  return { status: "ambiguous", candidates: matches };
 }
 export {
   CAPABILITIES,
-  COMPOSE_AUDIO_SRC,
-  COMPOSE_ENTRY,
-  COMPOSE_HEIGHT,
-  COMPOSE_VIDEO_SRC,
-  COMPOSE_WIDTH,
-  CommandError,
-  DEFAULT_DESILENCE,
-  DEFAULT_EDIT_ROOT,
-  PRESETS,
-  VIDEO_EXTS,
-  agentizePrompt,
-  artifactPaths,
-  autoGradeForClip,
+  CAPTION_STYLE_DEFAULTS,
+  CloudClient,
+  CloudHttpError,
+  DEFAULT_DOWNLOAD_TIMEOUT_MS,
+  DEFAULT_TIMEOUT_MS,
+  INLINE_MAX_BYTES,
+  MAX_POLL_MS,
+  MAX_RUN_POLL_MS,
+  MULTIPART_THRESHOLD_BYTES,
+  RELAY_DIRECT_ATTEMPTS,
+  RELAY_SUBCHUNK_BYTES,
+  REVIEW_STAGES2,
+  assertRunCompleted,
+  assetContentType2,
+  assetsUrl,
+  bundledSkillDir,
+  bytesSource,
   checkCapabilities,
-  compileTimeline,
-  composeCounts,
-  composeHtml,
-  computeEnvelope,
-  configDir,
-  configEnvPath,
-  cutBoundaries,
-  decideGradeFilter,
-  defaultJobDir,
-  desilenceEdl,
-  detectSilences,
-  diagnosticsPath,
-  displayedDimensions,
-  duplicatedPhrase,
-  duplicatedPhrases,
-  duplicatedSpans,
-  edlPath,
-  ensureTranscribed,
-  ensureVerticalMaster,
-  ffprobe,
+  collectPlanAssetRefs2,
+  compileRemote,
+  compileUrl,
+  composeUrl,
+  defaultRenderOut,
+  defaultSkillTarget,
+  diagnosticsPath2,
+  downloadTo,
+  emptyDiagnostics,
+  filesUrl,
   findPhrase,
+  formatRunEvent,
+  framesPngPath,
   fuzzySuggestions,
-  gatherCompileCtx,
-  generateQcImages,
-  getPreset,
-  initJob,
-  isoNow,
-  learnedEditingGuardrails,
-  loadApiKey,
-  loadJob,
-  loadTimeline,
-  loadWords,
-  loadWordsBySource,
-  mediaDuration,
+  ingestArtifactSet,
+  ingestUrl,
+  initCloudJob,
+  installSkill,
+  instructionPath2,
+  isTerminalRunStatus,
+  isTerminalStatus,
+  jobJsonPath,
+  joinSourceWindows,
+  loadPublicConfigEnv,
+  loadTimeline2,
+  meUrl,
+  multipartRelayUrl,
+  multipartUrl,
   normalizePhrase,
   normalizeToken,
-  packTranscripts,
-  parseSilenceDetect,
+  openFileSource,
+  outWindowToSourceWindows,
+  parseFileContent,
+  parseFileList,
+  parseFilePresign,
+  parseRenderCreate,
+  parseRenderState,
+  parseRunState,
   parseTimeline,
-  planPath,
-  pyFixed,
-  pyFixedPad,
-  pyRound,
-  pySpacePad,
-  readEdl,
-  render,
-  requireFfmpeg,
-  resolveJob,
+  planPath2,
+  pollRender,
+  pollRun,
+  projectVideosUrl,
+  projectsUrl,
+  publicConfigDir,
+  publicConfigEnvPath,
+  pullFiles,
+  pullReview2,
+  pushComplete2,
+  pushFiles,
+  pushStage2,
+  pushTimeline2,
+  qaDir,
+  readJobFile,
+  readOutcomesFile2,
+  readPlanSegments,
+  readProbeDuration,
+  renderUrl,
+  rendersUrl,
+  resolveApiBase,
+  resolveApiKey,
+  resolveConfig,
   resolvePhrase,
-  rotationDegrees,
-  run,
-  runSync,
-  screenTakes,
-  sha256File,
-  shown,
-  silenceDetectArgs,
-  slugify,
-  sourceFromJob,
-  statusPayload,
-  straddlingGap,
-  tightenRange,
-  tightenRanges,
-  timelineFromEdl,
-  timelineHash,
-  timelineJsonPath,
+  resolveRunId2,
+  resolveUrl,
+  resolveVideoId,
+  reviewDir2,
+  reviewUrl,
+  roundJsonPath2,
+  runUrl,
+  sameSha,
+  sanitizeStem,
+  savePublicConfigKey,
+  sha256Hex,
+  shouldMultipart,
+  statAssetsForDoc,
+  stripTrailingSlash,
+  syncAssets2,
+  timelineJsonPath2,
   timelineV2Schema,
-  timelineView,
-  transcribeBatch,
-  transcribeOne,
-  transcriptFileForSource,
-  transcriptPath,
-  updateCaptionsBlock,
+  toVfsPath,
+  transcribeArtifactSet,
+  transcribeCloud,
+  transcribeUrl,
+  uploadMultipart,
+  uploadVfsBytes,
+  uploadVfsPayload,
   usesFromDoc,
+  validateLocal,
   validateTimeline,
-  verify,
-  videoStream,
+  verifyCloud,
+  verifyUrl,
+  vfsContentType,
+  vfsLocalPath,
+  videoIdFromJob,
+  waveformPngPath,
+  waveformWordsPath,
   wordStream,
-  writeAgentManifest,
-  writeBoundaries,
-  writeCompileArtifacts,
-  writeCoverage,
-  writeSilencePrompt,
-  writeTranscriptArtifacts,
-  writeVideoEditingPrompt,
-  writeWarningsFromReview,
-  writeWordDump
+  writeJobFile
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "video-editing",
-  "version": "1.3.1",
-  "description": "Standalone TypeScript library + CLI for editing talking-head reels: transcribe, screen, cut (EDL), render vertical 9:16, QC, content-verify.",
+  "version": "3.0.0",
+  "description": "Pure-API cloud CLI + client for editing talking-head reels with clipready: upload once, then transcription, timeline authoring, compile, render, verify and QA all run in the cloud. Node ≥ 20 + an API key — no ffmpeg.",
   "type": "module",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Itay Elgazar",
@@ -45,25 +45,8 @@
     "skills",
     "LICENSE"
   ],
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "prepublishOnly": "pnpm build"
-  },
   "dependencies": {
-    "@napi-rs/canvas": "^0.1.65",
     "commander": "^12.1.0",
-    "p-limit": "^6.1.0",
     "zod": "^3"
-  },
-  "devDependencies": {
-    "@types/node": "^22.10.0",
-    "tsup": "^8.3.5",
-    "tsx": "^4.19.2",
-    "typescript": "^5.7.2",
-    "vitest": "^2.1.8"
   }
 }