codeplay-common 4.4.5 → 4.4.7

package/files/generate-ai-promo-video.js

@@ -31,7 +31,7 @@ const appFilePrefix = `${appUniqueId}. ${sanitizeFileNamePart(appName)}`;
 const playStoreDownloadUrl = `https://play.google.com/store/apps/details?id=${encodeURIComponent(packageId)}`;
 const configuredAppStoreUrl = String(iosStoreConfig.appStoreUrl || '')
   .match(/https:\/\/apps\.apple\.com\/app\/id\d+/)?.[0] || '';
-let appStoreDownloadUrl = /^https:\/\/apps\.apple\.com\/app\/id\d+$/.test(configuredAppStoreUrl)
+const appStoreDownloadUrl = /^https:\/\/apps\.apple\.com\/app\/id\d+$/.test(configuredAppStoreUrl)
   ? configuredAppStoreUrl
   : '';
 const promoDesignIndex = createHash('sha1').update(`${appUniqueId}:${appName}`).digest()[0] % 4;
@@ -51,7 +51,7 @@ const spatialXrVideoPath = path.join(
   spatialXrDirectory,
   `${appFilePrefix}-spatial-xr-3d-sbs-lr-3840x1080.mp4`,
 );
-const iconPath = path.join(projectDirectory, 'src', 'assets', 'icons', 'icon-512.webp');
+const iconPath = path.join(projectDirectory, 'resources', 'icon-only.png');
 const temporaryDirectory = path.join(projectDirectory, 'agent-temp', 'ai-promo-video');
 const captionPath = path.join(temporaryDirectory, `${appUniqueId}-promo-english.ass`);
 const narrationTrackPath = path.join(temporaryDirectory, `${appUniqueId}-promo-narration.wav`);
@@ -65,14 +65,13 @@ const analysisFrameDirectory = path.join(temporaryDirectory, 'ai-analysis');
 const endCardBannerPath = path.join(outputVideoDirectory, `${appFilePrefix}-ai-end-card-banner.png`);
 const promoCopySchemaPath = path.join(temporaryDirectory, 'promo-copy-schema.json');
 const promoCopyResultPath = path.join(temporaryDirectory, 'promo-copy-result.json');
-const ffmpegFallbackDirectory = 'W:\\Tools\\ffmpeg\\bin';
-const sceneCount = 7;
-const minimumSourceDuration = 12;
-const minimumPreferredPromoDuration = 24;
-const maximumPromoDuration = 40;
-let expectedDuration = 34;
-let editSegments = [];
-let sceneWindows = [];
+const ffmpegFallbackDirectory = String(process.env.FFMPEG_BIN || '').trim();
+const minimumSceneCount = 7;
+const minimumSourceDuration = 12;
+let expectedDuration = 34;
+let editSegments = [];
+let sceneWindows = [];
+let sceneCount = minimumSceneCount;
 const thumbnailTime = 2;
 const thumbnailWidth = 3840;
 const thumbnailHeight = 2160;
@@ -81,7 +80,7 @@ const spatialEyeWidth = 1920;
 const spatialEyeHeight = 1080;
 const spatialOutputWidth = spatialEyeWidth * 2;
 const spatialOutputHeight = spatialEyeHeight;
-const promoCopySchemaVersion = 3;
+const promoCopySchemaVersion = 5;
 const promoCopySchema = {
   type: 'object',
   additionalProperties: false,
@@ -170,32 +169,6 @@ function sanitizeFileNamePart(value) {
     .replace(/[. ]+$/g, '') || 'App';
 }
 
-async function askIosStoreDetails() {
-  if (iosStoreConfig.configured === true
-    && (!iosStoreConfig.available || /^https:\/\/apps\.apple\.com\/app\/id\d+$/.test(appStoreDownloadUrl))) {
-    return;
-  }
-  if (!process.stdin.isTTY || !process.stdout.isTTY) {
-    throw new Error('iOS availability must be answered in an interactive terminal.');
-  }
-  const readline = require('node:readline/promises');
-  const prompt = readline.createInterface({ input: process.stdin, output: process.stdout });
-  const appStoreId = (await prompt.question('Enter the numeric Apple App Store ID, or press Enter if unavailable: ')).trim();
-  prompt.close();
-  const available = Boolean(appStoreId);
-  if (available) {
-    if (!/^\d+$/.test(appStoreId)) throw new Error('Apple App Store ID must contain only numbers.');
-    appStoreDownloadUrl = `https://apps.apple.com/app/id${appStoreId}`;
-  }
-  fs.mkdirSync(path.dirname(iosStoreConfigPath), { recursive: true });
-  fs.writeFileSync(iosStoreConfigPath, `${JSON.stringify({
-    configured: true,
-    available: available === 'yes',
-    appStoreId: available === 'yes' ? appStoreDownloadUrl.split('/').pop().replace(/^id/, '') : '',
-    appStoreUrl: appStoreDownloadUrl,
-  }, null, 2)}\n`, 'utf8');
-}
-
 async function ensureEndCardBanner() {
   if (fs.existsSync(endCardBannerPath)) return;
   throw new Error(
@@ -205,7 +178,7 @@ async function ensureEndCardBanner() {
       + '- Final image size must be exactly 1672 × 941 pixels.\n'
       + '- Save it as:\n'
       + `  ${endCardBannerPath}\n`
-      + '- Inspect the current project and use the application’s actual highest-resolution app icon.\n'
+      + `- Use this exact app icon file: ${iconPath}\n`
       + '- Do not generate, redraw, reinterpret, or replace the app icon.\n'
       + '- Use the complete official black “Download on the App Store” badge.\n'
       + '- Use the complete official black “Get it on Google Play” badge.\n'
@@ -253,7 +226,7 @@ function roundTimelineValue(value) {
   return Math.round(value * 100) / 100;
 }
 
-function mapOutputTimeToSource(outputTime) {
+function mapOutputTimeToSource(outputTime) {
   let remainingTime = outputTime;
   for (const segment of editSegments) {
     const segmentDuration = segment.end - segment.start;
@@ -262,62 +235,150 @@ function mapOutputTimeToSource(outputTime) {
     }
     remainingTime -= segmentDuration;
   }
-  return editSegments.at(-1).end - 0.05;
-}
-
-function configurePromoTimeline(sourceDuration) {
-  if (!Number.isFinite(sourceDuration) || sourceDuration < minimumSourceDuration) {
+  return editSegments.at(-1).end - 0.05;
+}
+
+function mapSourceTimeToOutput(sourceTime) {
+  let outputTime = 0;
+  for (const segment of editSegments) {
+    if (sourceTime < segment.start) return outputTime;
+    if (sourceTime <= segment.end) return outputTime + (sourceTime - segment.start);
+    outputTime += segment.end - segment.start;
+  }
+  return outputTime;
+}
+
+function normalizeSkippedRanges(skippedRanges, sourceDuration) {
+  const ranges = skippedRanges
+    .map((range) => ({
+      start: Math.max(0, Math.min(sourceDuration, range.start)),
+      end: Math.max(0, Math.min(sourceDuration, range.end)),
+    }))
+    .filter((range) => range.end > range.start)
+    .sort((left, right) => left.start - right.start);
+
+  return ranges.reduce((merged, range) => {
+    const previous = merged.at(-1);
+    if (previous && range.start <= previous.end) {
+      previous.end = Math.max(previous.end, range.end);
+    } else {
+      merged.push({ ...range });
+    }
+    return merged;
+  }, []);
+}
+
+function buildRetainedSegments(sourceDuration, skippedRanges) {
+  const normalizedRanges = normalizeSkippedRanges(skippedRanges, sourceDuration);
+  const retainedSegments = [];
+  let retainedStart = 0;
+
+  for (const range of normalizedRanges) {
+    if (range.start > retainedStart) {
+      retainedSegments.push({ start: retainedStart, end: range.start });
+    }
+    retainedStart = range.end;
+  }
+  if (retainedStart < sourceDuration) {
+    retainedSegments.push({ start: retainedStart, end: sourceDuration });
+  }
+
+  return {
+    retainedSegments: retainedSegments.map((segment) => ({
+      start: roundTimelineValue(segment.start),
+      end: roundTimelineValue(segment.end),
+    })),
+    skippedDuration: normalizedRanges.reduce(
+      (total, range) => total + (range.end - range.start),
+      0,
+    ),
+  };
+}
+
+function buildSceneWindows(retainedDuration, visualChangeTimes) {
+  const minimumWindowDuration = Math.max(2.5, Math.min(4, retainedDuration / 40));
+  const maximumWindowDuration = Math.max(6, Math.min(10, retainedDuration / 14));
+  const boundaries = [0];
+  const mappedChanges = visualChangeTimes
+    .map((sourceTime) => mapSourceTimeToOutput(sourceTime))
+    .filter((outputTime) => outputTime > 0 && outputTime < retainedDuration)
+    .sort((left, right) => left - right);
+
+  for (const changeTime of mappedChanges) {
+    if (changeTime - boundaries.at(-1) >= minimumWindowDuration) {
+      boundaries.push(changeTime);
+    }
+  }
+  if (retainedDuration - boundaries.at(-1) < minimumWindowDuration) boundaries.pop();
+  boundaries.push(retainedDuration);
+
+  const windows = [];
+  for (let index = 0; index < boundaries.length - 1; index += 1) {
+    const start = boundaries[index];
+    const end = boundaries[index + 1];
+    const splitCount = Math.max(1, Math.ceil((end - start) / maximumWindowDuration));
+    for (let splitIndex = 0; splitIndex < splitCount; splitIndex += 1) {
+      windows.push({
+        start: roundTimelineValue(start + (((end - start) * splitIndex) / splitCount)),
+        end: roundTimelineValue(start + (((end - start) * (splitIndex + 1)) / splitCount)),
+      });
+    }
+  }
+
+  if (windows.length >= minimumSceneCount) return windows;
+  return Array.from({ length: minimumSceneCount }, (_, index) => ({
+    start: roundTimelineValue((retainedDuration * index) / minimumSceneCount),
+    end: index === minimumSceneCount - 1
+      ? retainedDuration
+      : roundTimelineValue((retainedDuration * (index + 1)) / minimumSceneCount),
+  }));
+}
+
+function configurePromoTimeline(sourceDuration, skippedRanges = [], visualChangeTimes = []) {
+  if (!Number.isFinite(sourceDuration) || sourceDuration < minimumSourceDuration) {
     throw new Error(
       `The shortest source video must be at least ${minimumSourceDuration} seconds.`,
     );
   }
 
-  const introTrim = sourceDuration >= 20 ? Math.min(2, sourceDuration * 0.04) : 0;
-  const usableDuration = sourceDuration - introTrim;
-  const preferredDuration = Math.max(
-    minimumPreferredPromoDuration,
-    Math.round(sourceDuration * 0.6),
-  );
-  expectedDuration = roundTimelineValue(Math.min(maximumPromoDuration, usableDuration, preferredDuration));
-
-  const tailDuration = expectedDuration >= minimumPreferredPromoDuration
-    ? roundTimelineValue(Math.min(7, expectedDuration * 0.2))
-    : 0;
-  const mainDuration = roundTimelineValue(expectedDuration - tailDuration);
-  const tailStart = roundTimelineValue(sourceDuration - tailDuration);
-  const mainEnd = roundTimelineValue(introTrim + mainDuration);
-
-  editSegments = tailDuration > 0 && mainEnd + 0.5 < tailStart
-    ? [
-      { start: roundTimelineValue(introTrim), end: mainEnd },
-      { start: tailStart, end: roundTimelineValue(sourceDuration) },
-    ]
-    : [{
-      start: roundTimelineValue(introTrim),
-      end: roundTimelineValue(introTrim + expectedDuration),
-    }];
-
-  sceneWindows = Array.from({ length: sceneCount }, (_, index) => {
-    const start = roundTimelineValue((expectedDuration * index) / sceneCount);
-    const end = index === sceneCount - 1
-      ? expectedDuration
-      : roundTimelineValue((expectedDuration * (index + 1)) / sceneCount);
-    const sceneDuration = end - start;
-    return {
-      start,
-      end,
-      sourceTime: roundTimelineValue(mapOutputTimeToSource(start + (sceneDuration / 2))),
-      maxNarrationWords: Math.max(7, Math.floor(sceneDuration * 2.15)),
-    };
-  });
-  endCardStart = expectedDuration;
+  const { retainedSegments, skippedDuration } = buildRetainedSegments(
+    sourceDuration,
+    skippedRanges,
+  );
+  editSegments = retainedSegments.filter((segment) => segment.end > segment.start);
+  const retainedDuration = editSegments.reduce(
+    (total, segment) => total + (segment.end - segment.start),
+    0,
+  );
+  if (retainedDuration < minimumSourceDuration) {
+    throw new Error(
+      `At least ${minimumSourceDuration} seconds must remain after automatic cleanup.`,
+    );
+  }
+
+  expectedDuration = roundTimelineValue(retainedDuration);
+  sceneWindows = buildSceneWindows(expectedDuration, visualChangeTimes).map((window) => {
+    const sceneDuration = window.end - window.start;
+    return {
+      ...window,
+      sourceTime: roundTimelineValue(mapOutputTimeToSource(
+        window.start + (sceneDuration / 2),
+      )),
+      maxNarrationWords: Math.max(7, Math.floor(sceneDuration * 2.15)),
+    };
+  });
+  sceneCount = sceneWindows.length;
+  promoCopySchema.properties.scenes.minItems = sceneCount;
+  promoCopySchema.properties.scenes.maxItems = sceneCount;
+  endCardStart = expectedDuration;
   expectedDuration = roundTimelineValue(expectedDuration + endCardDuration);
 
   console.log(
-    `Adaptive promo timeline: ${expectedDuration}s from ${sourceDuration.toFixed(2)}s source; `
-      + `${editSegments.length} edit segment${editSegments.length === 1 ? '' : 's'}.`,
-  );
-}
+    `Feature-complete promo timeline: ${expectedDuration}s from ${sourceDuration.toFixed(2)}s source; `
+      + `${sceneCount} scenes and ${editSegments.length} retained segment${editSegments.length === 1 ? '' : 's'}`
+      + `${skippedDuration > 0 ? ` (${skippedDuration.toFixed(2)}s of redundant static footage removed)` : ''}.`,
+  );
+}
 
 function escapeAssText(value) {
   return String(value)
@@ -360,14 +421,85 @@ function commandExists(command) {
   return !result.error && result.status === 0;
 }
 
-function getExecutable(command) {
-  if (commandExists(command)) return command;
-
-  const fallbackPath = path.join(ffmpegFallbackDirectory, `${command}.exe`);
-  return fs.existsSync(fallbackPath) ? fallbackPath : '';
-}
-
-function parseArguments() {
+function getExecutable(command) {
+  if (commandExists(command)) return command;
+
+  if (!ffmpegFallbackDirectory) return '';
+  const executableName = process.platform === 'win32' ? `${command}.exe` : command;
+  const fallbackPath = path.join(ffmpegFallbackDirectory, executableName);
+  return fs.existsSync(fallbackPath) ? fallbackPath : '';
+}
+
+function detectRedundantStaticRanges(ffmpegCommand, inputPath, sourceDuration) {
+  const minimumStaticDuration = Math.max(2, Math.min(4, sourceDuration / 60));
+  const result = spawnSync(ffmpegCommand, [
+    '-hide_banner',
+    '-nostats',
+    '-i', inputPath,
+    '-vf', `freezedetect=n=-50dB:d=${minimumStaticDuration}`,
+    '-an',
+    '-f', 'null',
+    process.platform === 'win32' ? 'NUL' : '/dev/null',
+  ], {
+    encoding: 'utf8',
+    windowsHide: true,
+    maxBuffer: 10 * 1024 * 1024,
+  });
+  if (result.error || result.status !== 0) {
+    console.warn('Static-screen analysis was unavailable; retaining the complete recording.');
+    return [];
+  }
+
+  const events = String(result.stderr || '').matchAll(
+    /lavfi\.freezedetect\.freeze_(start|end):\s*([\d.]+)/g,
+  );
+  const staticRanges = [];
+  let staticStart = null;
+  for (const event of events) {
+    const time = Number(event[2]);
+    if (event[1] === 'start') {
+      staticStart = time;
+    } else if (staticStart !== null && time > staticStart) {
+      staticRanges.push({ start: staticStart, end: time });
+      staticStart = null;
+    }
+  }
+  if (staticStart !== null && sourceDuration > staticStart) {
+    staticRanges.push({ start: staticStart, end: sourceDuration });
+  }
+
+  return staticRanges
+    .map((range) => ({
+      start: range.start + minimumStaticDuration,
+      end: range.end,
+    }))
+    .filter((range) => range.end - range.start >= 0.75);
+}
+
+function detectVisualChangeTimes(ffmpegCommand, inputPath) {
+  const result = spawnSync(ffmpegCommand, [
+    '-hide_banner',
+    '-nostats',
+    '-i', inputPath,
+    '-vf', "select='gt(scene,0.03)',showinfo",
+    '-an',
+    '-f', 'null',
+    process.platform === 'win32' ? 'NUL' : '/dev/null',
+  ], {
+    encoding: 'utf8',
+    windowsHide: true,
+    maxBuffer: 10 * 1024 * 1024,
+  });
+  if (result.error || result.status !== 0) {
+    console.warn('Visual-change analysis was unavailable; using duration-based scene coverage.');
+    return [];
+  }
+  return [...String(result.stderr || '').matchAll(/pts_time:([\d.]+)/g)]
+    .map((match) => Number(match[1]))
+    .filter(Number.isFinite);
+}
+
+function parseArguments() {
   const args = process.argv.slice(2);
   const options = {
     aiModel: '',
@@ -428,9 +560,10 @@ function parseArguments() {
       console.log('  node generate-ai-promo-video.js --list-voices');
       console.log('  node generate-ai-promo-video.js --preview-voices');
       console.log('');
-      console.log(
-        `Without --input, every MP4 under ${sourceVideoDirectory} except Samsung is processed.`,
-      );
+      console.log(
+        `Without --input, every MP4 under ${sourceVideoDirectory} except Samsung is processed.`,
+      );
+      console.log('Redundant static pauses are shortened automatically; distinct screens are retained.');
       process.exit(0);
     } else {
       throw new Error(`Unknown argument: ${argument}`);
@@ -667,9 +800,12 @@ function buildPromoCopyPrompt(appContext, previousError = '') {
 
 The ${sceneWindows.length} supplied images are ordered scene 1 through scene ${sceneWindows.length}. Use both those images and the sanitized project context below. Do not inspect files, run commands, or edit anything. Return only JSON matching the supplied schema.
 
-Rules:
-- Generate exactly ${sceneWindows.length} scenes in the same order as the images and timings.
-- Use only features supported by the images or project context. Never invent claims.
+Rules:
+- Generate exactly ${sceneWindows.length} scenes in the same order as the images and timings.
+- Use only features supported by the images or project context. Never invent claims.
+- Cover every distinct demonstrated feature across the retained recording; do not omit later features.
+- Do not promote incidental navigation, loading states, advertisements, permission prompts, or repeated screens as features.
+- Keep each scene specific to what is visibly demonstrated in its supplied image whenever possible.
 - The authoritative app name is ${JSON.stringify(appName)}. Mention it naturally in the final narration and final body.
 - APP_UNIQUE_ID is internal and must never appear in audience-facing copy.
 - Each kicker: 2-30 characters. Each title line: 1-22 characters. Body: 8-72 characters.
@@ -1521,17 +1657,15 @@ async function main() {
     return;
   }
 
-  await askIosStoreDetails();
-  await ensureEndCardBanner();
-
-  const ffmpegCommand = getExecutable('ffmpeg');
+  const ffmpegCommand = getExecutable('ffmpeg');
   const ffprobeCommand = getExecutable('ffprobe');
   const voice = resolveVoice(options.voice);
 
-  if (!ffmpegCommand || !ffprobeCommand) {
-    throw new Error('FFmpeg and FFprobe were not found in PATH or W:\\Tools\\ffmpeg\\bin.');
-  }
-  if (!fs.existsSync(iconPath)) throw new Error(`App icon was not found: ${iconPath}`);
+  if (!ffmpegCommand || !ffprobeCommand) {
+    throw new Error('FFmpeg and FFprobe were not found in PATH or FFMPEG_BIN.');
+  }
+  if (!fs.existsSync(iconPath)) throw new Error(`App icon was not found: ${iconPath}`);
+  await ensureEndCardBanner();
 
   const inputPaths = options.input
     ? [path.resolve(options.input)]
@@ -1557,10 +1691,17 @@ async function main() {
         : getBatchOutputPath(inputPath, target.width, target.height);
     return { crop, duration, inputPath, outputPath, processingInputPath, target };
   });
-  configurePromoTimeline(Math.min(...sourceVideos.map((source) => source.duration)));
-  const analysisSource = [...sourceVideos].sort((left, right) => (
-    (right.target.width * right.target.height) - (left.target.width * left.target.height)
-  ))[0];
+  const analysisSource = [...sourceVideos].sort((left, right) => (
+    (right.target.width * right.target.height) - (left.target.width * left.target.height)
+  ))[0];
+  const sourceDuration = Math.min(...sourceVideos.map((source) => source.duration));
+  const redundantStaticRanges = detectRedundantStaticRanges(
+    ffmpegCommand,
+    analysisSource.inputPath,
+    sourceDuration,
+  );
+  const visualChangeTimes = detectVisualChangeTimes(ffmpegCommand, analysisSource.inputPath);
+  configurePromoTimeline(sourceDuration, redundantStaticRanges, visualChangeTimes);
   const promoCopyResult = await generateOrLoadPromoCopy(
     options,
     ffmpegCommand,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeplay-common",
-  "version": "4.4.5",
+  "version": "4.4.7",
   "description": "Common build scripts and files",
   "scripts": {
 	"postinstall": "node scripts/sync-files.js",