@telepat/rilo 0.1.0

package/src/steps/generateVoiceover.js

@@ -0,0 +1,128 @@
+import { DEFAULT_VIDEO_CONFIG, MODEL_CATEGORIES, getModelInputOptions, resolveModelForCategory } from '../config/models.js';
+import { runModel, extractOutputUri } from '../providers/predictions.js';
+import path from 'node:path';
+import { downloadToFile, ensureDir } from '../media/files.js';
+
+const TTS_WORDS_PER_SECOND = 2.6;
+const MIN_TTS_SPEED = 0.75;
+const MAX_TTS_SPEED = 1.25;
+
+function countWords(text) {
+  return String(text || '')
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean).length;
+}
+
+function clamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+
+function asModelOptions(candidate) {
+  if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+    return {};
+  }
+  return candidate;
+}
+
+export function resolveTtsSpeed(script, targetDurationSec) {
+  const words = countWords(script);
+  const safeTarget = Number.isInteger(targetDurationSec) && targetDurationSec > 0
+    ? targetDurationSec
+    : DEFAULT_VIDEO_CONFIG.durationSec;
+
+  const estimatedAtSpeedOne = words / TTS_WORDS_PER_SECOND;
+  const rawSpeed = estimatedAtSpeedOne / safeTarget;
+  const speed = clamp(rawSpeed || 1, MIN_TTS_SPEED, MAX_TTS_SPEED);
+
+  return {
+    speed,
+    words,
+    estimatedAtSpeedOneSec: Math.round(estimatedAtSpeedOne * 1000) / 1000
+  };
+}
+
+export function buildFixedTimeline(shotsCount, segmentDurationSec = DEFAULT_VIDEO_CONFIG.segmentDurationSec) {
+  const normalizedShotCount = Number.isInteger(shotsCount) && shotsCount > 0 ? shotsCount : DEFAULT_VIDEO_CONFIG.shots;
+  const normalizedSegmentDuration = Number.isInteger(segmentDurationSec) && segmentDurationSec > 0
+    ? segmentDurationSec
+    : DEFAULT_VIDEO_CONFIG.segmentDurationSec;
+
+  return Array.from({ length: normalizedShotCount }, (_, idx) => ({
+    shot: idx + 1,
+    durationSec: normalizedSegmentDuration
+  }));
+}
+
+export function resolveSegmentCountFromAudioDuration(audioDurationSec, segmentDurationSec = DEFAULT_VIDEO_CONFIG.segmentDurationSec) {
+  const normalizedSegmentDuration = Number.isInteger(segmentDurationSec) && segmentDurationSec > 0
+    ? segmentDurationSec
+    : DEFAULT_VIDEO_CONFIG.segmentDurationSec;
+
+  if (!Number.isFinite(audioDurationSec) || audioDurationSec <= 0) {
+    return 1;
+  }
+
+  return Math.max(1, Math.ceil(audioDurationSec / normalizedSegmentDuration));
+}
+
+export async function generateVoiceover(script, options = {}, trace = null) {
+  const deps = options.deps || {};
+  const runModelFn = deps.runModel || runModel;
+  const extractOutputUriFn = deps.extractOutputUri || extractOutputUri;
+
+  const shotsCount = Number.isInteger(options.shotsCount) && options.shotsCount > 0
+    ? options.shotsCount
+    : DEFAULT_VIDEO_CONFIG.shots;
+  const segmentDurationSec = Number.isInteger(options.segmentDurationSec) && options.segmentDurationSec > 0
+    ? options.segmentDurationSec
+    : DEFAULT_VIDEO_CONFIG.segmentDurationSec;
+  const targetDurationSec = Number.isInteger(options.targetDurationSec) && options.targetDurationSec > 0
+    ? options.targetDurationSec
+    : shotsCount * segmentDurationSec;
+  const ttsPlan = resolveTtsSpeed(script, targetDurationSec);
+  const modelId = options.modelId || resolveModelForCategory(MODEL_CATEGORIES.textToSpeech);
+  const modelOptions = asModelOptions(options.modelOptions);
+  const inputOptions = getModelInputOptions(modelId);
+  const allowedFields = new Set(inputOptions.userConfigurable || []);
+
+  const input = {
+    ...modelOptions,
+    text: script
+  };
+
+  if (allowedFields.has('speed') && !Object.prototype.hasOwnProperty.call(modelOptions, 'speed')) {
+    input.speed = ttsPlan.speed;
+  }
+
+  if (allowedFields.has('subtitle_enable') && !Object.prototype.hasOwnProperty.call(modelOptions, 'subtitle_enable')) {
+    input.subtitle_enable = false;
+  }
+
+  const prediction = await runModelFn({
+    model: modelId,
+    input,
+    trace: trace ? { ...trace, step: 'voiceover' } : null
+  });
+
+  return {
+    voiceoverUrl: extractOutputUriFn(prediction.output),
+    timeline: buildFixedTimeline(shotsCount, segmentDurationSec),
+    ttsPlan: {
+      ...ttsPlan,
+      targetDurationSec
+    }
+  };
+}
+
+export async function persistVoiceover(projectDir, voiceoverUrl, options = {}) {
+  const deps = options.deps || {};
+  const ensureDirFn = deps.ensureDir || ensureDir;
+  const downloadToFileFn = deps.downloadToFile || downloadToFile;
+
+  const audioDir = path.join(projectDir, 'assets', 'audio');
+  await ensureDirFn(audioDir);
+  const voicePath = path.join(audioDir, 'voiceover.mp3');
+  await downloadToFileFn(voiceoverUrl, voicePath);
+  return voicePath;
+}

package/src/steps/imageToVideoAdapters.js

@@ -0,0 +1,100 @@
+import { DEFAULT_VIDEO_CONFIG, MODELS } from '../config/models.js';
+
+function normalizeModelOptions(candidate) {
+  if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+    return {};
+  }
+  return candidate;
+}
+
+function secondsToFrames(seconds, fps) {
+  return Math.max(81, Math.round(seconds * fps));
+}
+
+function buildWanInput({ prompt, startImage, endImage, durationSec, videoResolution, modelOptions }) {
+  return {
+    ...normalizeModelOptions(modelOptions),
+    prompt,
+    image: startImage,
+    last_image: endImage,
+    num_frames: secondsToFrames(durationSec, DEFAULT_VIDEO_CONFIG.fps),
+    frames_per_second: DEFAULT_VIDEO_CONFIG.fps,
+    resolution: videoResolution
+  };
+}
+
+function buildKlingInput({ prompt, startImage, endImage, aspectRatio, modelOptions }) {
+  const normalizedOptions = {
+    ...normalizeModelOptions(modelOptions),
+    generate_audio: false
+  };
+
+  return {
+    ...normalizedOptions,
+    prompt,
+    start_image: startImage,
+    end_image: endImage,
+    aspect_ratio: aspectRatio,
+    duration: 5
+  };
+}
+
+function buildPixverseInput({ prompt, startImage, endImage, aspectRatio, modelOptions }) {
+  const normalizedOptions = {
+    ...normalizeModelOptions(modelOptions),
+    generate_audio_switch: false
+  };
+
+  return {
+    ...normalizedOptions,
+    prompt,
+    image: startImage,
+    last_frame_image: endImage,
+    aspect_ratio: aspectRatio,
+    duration: 5
+  };
+}
+
+function buildVeoInput({ prompt, startImage, endImage, aspectRatio, modelOptions }) {
+  return {
+    ...normalizeModelOptions(modelOptions),
+    prompt,
+    image: startImage,
+    last_frame: endImage,
+    aspect_ratio: aspectRatio,
+    duration: 5,
+    generate_audio: false
+  };
+}
+
+const IMAGE_TO_VIDEO_ADAPTERS = {
+  [MODELS.video]: {
+    modelId: MODELS.video,
+    buildInput: buildWanInput
+  },
+  [MODELS.klingVideo3]: {
+    modelId: MODELS.klingVideo3,
+    buildInput: buildKlingInput
+  },
+  [MODELS.pixverseV56]: {
+    modelId: MODELS.pixverseV56,
+    buildInput: buildPixverseInput
+  },
+  [MODELS.veo31]: {
+    modelId: MODELS.veo31,
+    buildInput: buildVeoInput
+  },
+  [MODELS.veo31Fast]: {
+    modelId: MODELS.veo31Fast,
+    buildInput: buildVeoInput
+  }
+};
+
+const DEFAULT_IMAGE_TO_VIDEO_ADAPTER = {
+  modelId: null,
+  buildInput: buildWanInput
+};
+
+export function resolveImageToVideoAdapter(modelId) {
+  return IMAGE_TO_VIDEO_ADAPTERS[modelId] || DEFAULT_IMAGE_TO_VIDEO_ADAPTER;
+}

package/src/steps/script.js

@@ -0,0 +1,177 @@
+import { DEFAULT_VIDEO_CONFIG, MODEL_CATEGORIES, resolveModelForCategory } from '../config/models.js';
+import { runModel, extractOutputText } from '../providers/predictions.js';
+
+const SCRIPT_WORDS_PER_SECOND = 2.6;
+const SCRIPT_RETRY_LIMIT = 3;
+const SHOTS_RETRY_LIMIT = 3;
+
+function extractJsonBlock(text) {
+  const start = text.indexOf('{');
+  const end = text.lastIndexOf('}');
+  if (start === -1 || end === -1 || end <= start) {
+    throw new Error('Model response did not include JSON payload');
+  }
+  return text.slice(start, end + 1);
+}
+
+function countWords(text) {
+  return String(text || '')
+    .trim()
+    .split(/\s+/)
+    .filter(Boolean).length;
+}
+
+function buildWordBudget(targetDurationSec) {
+  const targetWords = Math.max(20, Math.round(targetDurationSec * SCRIPT_WORDS_PER_SECOND));
+  return {
+    targetWords,
+    minWords: Math.max(20, Math.floor(targetWords * 0.9)),
+    maxWords: Math.max(30, Math.ceil(targetWords * 1.1))
+  };
+}
+
+function buildScriptPrompt(story, targetDurationSec, wordBudget, attempt) {
+  const retryInstruction =
+    attempt > 1
+      ? `\nIMPORTANT: previous attempt missed the narration length target. Keep script length strictly between ${wordBudget.minWords} and ${wordBudget.maxWords} words.`
+      : '';
+
+  return `You are writing narration for a short video. Return ONLY JSON with keys: script, tone.\nRequirements:\n- script: narration text matching roughly ${targetDurationSec} seconds of voiceover\n- script length: strictly between ${wordBudget.minWords} and ${wordBudget.maxWords} words (target ${wordBudget.targetWords})\n- tone: concise tone label${retryInstruction}\nStory source:\n${story}`;
+}
+
+function buildShotsPrompt(script, shotCount, tone, attempt) {
+  const retryInstruction =
+    attempt > 1
+      ? `\nIMPORTANT: previous attempt failed shape checks. Return exactly ${shotCount} shots.`
+      : '';
+
+  const toneHint = typeof tone === 'string' && tone.trim() ? tone.trim() : 'neutral';
+  return `You are writing visual keyframe prompts for a short video narration. Return ONLY JSON with key: shots.\nRequirements:\n- shots: array of exactly ${shotCount} short visual descriptions\n- each shot: exactly one sentence, concrete and visually descriptive\n- each shot must be fully self-contained because prompts are generated independently (do not rely on context from other shots)\n- in every shot, restate essential visual context like characters, setting, era/time-of-day, and key scene details when relevant\n- keep continuity of characters/setting across shots while still repeating critical details per shot\n- align with narration pacing and tone: ${toneHint}${retryInstruction}\nNarration:\n${script}`;
+}
+
+function asModelOptions(candidate) {
+  if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+    return {};
+  }
+  return candidate;
+}
+
+function normalizeShotDescription(shot) {
+  if (typeof shot === 'string') {
+    const value = shot.trim();
+    return value.length > 0 ? value : null;
+  }
+
+  if (shot && typeof shot === 'object' && !Array.isArray(shot) && typeof shot.description === 'string') {
+    const value = shot.description.trim();
+    return value.length > 0 ? value : null;
+  }
+
+  return null;
+}
+
+export async function generateScript(story, options = {}, trace = null) {
+  const deps = options.deps || {};
+  const runModelFn = deps.runModel || runModel;
+  const extractOutputTextFn = deps.extractOutputText || extractOutputText;
+
+  const targetDurationSec = Number.isInteger(options.targetDurationSec) && options.targetDurationSec > 0
+    ? options.targetDurationSec
+    : DEFAULT_VIDEO_CONFIG.durationSec;
+  const wordBudget = buildWordBudget(targetDurationSec);
+  const modelId = options.modelId || resolveModelForCategory(MODEL_CATEGORIES.textToText);
+  const modelOptions = asModelOptions(options.modelOptions);
+
+  let bestCandidate = null;
+  let bestDistance = Number.POSITIVE_INFINITY;
+
+  for (let attempt = 1; attempt <= SCRIPT_RETRY_LIMIT; attempt += 1) {
+    const prompt = buildScriptPrompt(story, targetDurationSec, wordBudget, attempt);
+    const prediction = await runModelFn({
+      model: modelId,
+      input: {
+        max_tokens: 1800,
+        temperature: 0.6,
+        ...modelOptions,
+        prompt
+      },
+      trace: trace ? { ...trace, step: 'script', attempt } : null
+    });
+
+    const text = extractOutputTextFn(prediction.output);
+    const parsed = JSON.parse(extractJsonBlock(text));
+
+    if (!parsed.script || typeof parsed.script !== 'string') {
+      continue;
+    }
+
+    const words = countWords(parsed.script);
+    const distance = Math.abs(words - wordBudget.targetWords);
+
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      bestCandidate = {
+        script: parsed.script,
+        tone: parsed.tone || 'neutral',
+        scriptWordCount: words,
+        targetWordCount: wordBudget.targetWords
+      };
+    }
+
+    if (words >= wordBudget.minWords && words <= wordBudget.maxWords) {
+      return bestCandidate;
+    }
+  }
+
+  if (!bestCandidate) {
+    throw new Error('Invalid script output shape');
+  }
+
+  return bestCandidate;
+}
+
+export async function generateShots(script, options = {}, trace = null) {
+  const deps = options.deps || {};
+  const runModelFn = deps.runModel || runModel;
+  const extractOutputTextFn = deps.extractOutputText || extractOutputText;
+
+  const shotCount = Number.isInteger(options.shotCount) && options.shotCount > 0
+    ? options.shotCount
+    : DEFAULT_VIDEO_CONFIG.shots;
+  const tone = typeof options.tone === 'string' ? options.tone : 'neutral';
+  const modelId = options.modelId || resolveModelForCategory(MODEL_CATEGORIES.textToText);
+  const modelOptions = asModelOptions(options.modelOptions);
+
+  for (let attempt = 1; attempt <= SHOTS_RETRY_LIMIT; attempt += 1) {
+    const prompt = buildShotsPrompt(script, shotCount, tone, attempt);
+    const prediction = await runModelFn({
+      model: modelId,
+      input: {
+        max_tokens: 1800,
+        temperature: 0.5,
+        ...modelOptions,
+        prompt
+      },
+      trace: trace ? { ...trace, step: 'shots', attempt } : null
+    });
+
+    const text = extractOutputTextFn(prediction.output);
+    const parsed = JSON.parse(extractJsonBlock(text));
+    const candidateShots = parsed?.shots;
+    const normalizedShots = Array.isArray(candidateShots)
+      ? candidateShots.map((shot) => normalizeShotDescription(shot))
+      : null;
+    const hasValidShape =
+      Array.isArray(normalizedShots) &&
+      normalizedShots.length === shotCount &&
+      normalizedShots.every((shot) => typeof shot === 'string' && shot.length > 0);
+
+    if (hasValidShape) {
+      return {
+        shots: normalizedShots
+      };
+    }
+  }
+
+  throw new Error('Invalid shots output shape');
+}

package/src/steps/textToImageAdapters.js

@@ -0,0 +1,87 @@
+import { MODELS } from '../config/models.js';
+
+function normalizeModelOptions(candidate) {
+  if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) {
+    return {};
+  }
+  return candidate;
+}
+
+function buildCommonPrompt(promptText, tone, index) {
+  return `Cinematic documentary style, coherent character continuity, shot ${index + 1}, tone ${tone}. ${promptText}`;
+}
+
+function buildPrunaInput({ promptText, tone, index, width, height, modelOptions }) {
+  return {
+    ...normalizeModelOptions(modelOptions),
+    prompt: buildCommonPrompt(promptText, tone, index),
+    width,
+    height
+  };
+}
+
+function buildFluxInput({ promptText, tone, index, width, height, modelOptions }) {
+  return {
+    ...normalizeModelOptions(modelOptions),
+    prompt: buildCommonPrompt(promptText, tone, index),
+    aspect_ratio: 'custom',
+    width,
+    height
+  };
+}
+
+function buildFluxSchnellInput({ promptText, tone, index, aspectRatio, modelOptions }) {
+  return {
+    ...normalizeModelOptions(modelOptions),
+    prompt: buildCommonPrompt(promptText, tone, index),
+    aspect_ratio: aspectRatio
+  };
+}
+
+function buildNanoBananaProInput({ promptText, tone, index, aspectRatio, modelOptions }) {
+  return {
+    ...normalizeModelOptions(modelOptions),
+    prompt: buildCommonPrompt(promptText, tone, index),
+    aspect_ratio: aspectRatio
+  };
+}
+
+function buildSeedream4Input({ promptText, tone, index, aspectRatio, modelOptions }) {
+  return {
+    ...normalizeModelOptions(modelOptions),
+    prompt: buildCommonPrompt(promptText, tone, index),
+    aspect_ratio: aspectRatio
+  };
+}
+
+const TEXT_TO_IMAGE_ADAPTERS = {
+  [MODELS.keyframe]: {
+    modelId: MODELS.keyframe,
+    buildInput: buildPrunaInput
+  },
+  [MODELS.flux]: {
+    modelId: MODELS.flux,
+    buildInput: buildFluxInput
+  },
+  [MODELS.fluxSchnell]: {
+    modelId: MODELS.fluxSchnell,
+    buildInput: buildFluxSchnellInput
+  },
+  [MODELS.nanoBananaPro]: {
+    modelId: MODELS.nanoBananaPro,
+    buildInput: buildNanoBananaProInput
+  },
+  [MODELS.seedream4]: {
+    modelId: MODELS.seedream4,
+    buildInput: buildSeedream4Input
+  }
+};
+
+const DEFAULT_TEXT_TO_IMAGE_ADAPTER = {
+  modelId: null,
+  buildInput: buildPrunaInput
+};
+
+export function resolveTextToImageAdapter(modelId) {
+  return TEXT_TO_IMAGE_ADAPTERS[modelId] || DEFAULT_TEXT_TO_IMAGE_ADAPTER;
+}

package/src/store/assetStore.js

@@ -0,0 +1,5 @@
+import { writeProjectArtifacts } from './projectStore.js';
+
+export async function persistArtifacts(projectName, artifacts) {
+  await writeProjectArtifacts(projectName, artifacts);
+}

package/src/store/jobStore.js

@@ -0,0 +1,102 @@
+import { v4 as uuidv4 } from 'uuid';
+import { JobStatus } from '../types/job.js';
+import { emptyPipelineArtifacts } from '../types/media.js';
+import { emptyStepState } from '../types/job.js';
+
+const jobs = new Map();
+const projectRunLocks = new Map();
+
+function normalizeProjectName(project) {
+  return String(project || '').trim().toLowerCase();
+}
+
+export function createJob(payload) {
+  const id = uuidv4();
+  const job = {
+    id,
+    status: JobStatus.PENDING,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    payload,
+    error: null,
+    artifacts: emptyPipelineArtifacts(),
+    steps: emptyStepState()
+  };
+  jobs.set(id, job);
+  return job;
+}
+
+export function updateJob(id, updates) {
+  const current = jobs.get(id);
+  if (!current) return null;
+  const next = {
+    ...current,
+    ...updates,
+    updatedAt: new Date().toISOString()
+  };
+  jobs.set(id, next);
+  return next;
+}
+
+export function getJob(id) {
+  return jobs.get(id) || null;
+}
+
+export function findActiveJobByProject(project, options = {}) {
+  const targetProject = normalizeProjectName(project);
+  if (!targetProject) {
+    return null;
+  }
+
+  const excludeJobId = options.excludeJobId || null;
+  return [...jobs.values()].find((job) => {
+    if (!job || (excludeJobId && job.id === excludeJobId)) {
+      return false;
+    }
+
+    if (job.status !== JobStatus.PENDING && job.status !== JobStatus.RUNNING) {
+      return false;
+    }
+
+    return normalizeProjectName(job.payload?.project) === targetProject;
+  }) || null;
+}
+
+export function acquireProjectRunLock(project, jobId) {
+  const projectName = normalizeProjectName(project);
+  if (!projectName || !jobId) {
+    return false;
+  }
+
+  const currentOwner = projectRunLocks.get(projectName);
+  if (currentOwner && currentOwner !== jobId) {
+    return false;
+  }
+
+  projectRunLocks.set(projectName, jobId);
+  return true;
+}
+
+export function releaseProjectRunLock(project, jobId) {
+  const projectName = normalizeProjectName(project);
+  if (!projectName || !jobId) {
+    return;
+  }
+
+  const currentOwner = projectRunLocks.get(projectName);
+  if (currentOwner === jobId) {
+    projectRunLocks.delete(projectName);
+  }
+}
+
+export function getProjectRunLockOwner(project) {
+  const projectName = normalizeProjectName(project);
+  if (!projectName) {
+    return null;
+  }
+  return projectRunLocks.get(projectName) || null;
+}
+
+export function listPendingJobs() {
+  return [...jobs.values()].filter((job) => job.status === JobStatus.PENDING);
+}