@veolab/discoverylab 1.3.3 → 1.4.0

package/dist/chunk-QMUEC6B5.js

@@ -0,0 +1,288 @@
+import {
+  FRAMES_DIR
+} from "./chunk-XAMA3JJG.js";
+import {
+  __require
+} from "./chunk-4VNS5WPM.js";
+
+// src/core/analyze/frames.ts
+import { spawn, execSync } from "child_process";
+import { existsSync, mkdirSync, readdirSync, statSync } from "fs";
+import { join, basename } from "path";
+function getVideoInfo(videoPath) {
+  if (!existsSync(videoPath)) {
+    return null;
+  }
+  try {
+    const output = execSync(
+      `ffprobe -v quiet -print_format json -show_format -show_streams "${videoPath}"`,
+      { encoding: "utf-8" }
+    );
+    const data = JSON.parse(output);
+    const videoStream = data.streams?.find((s) => s.codec_type === "video");
+    if (!videoStream) {
+      return null;
+    }
+    let fps = 30;
+    if (videoStream.r_frame_rate) {
+      const [num, den] = videoStream.r_frame_rate.split("/");
+      fps = den ? parseInt(num, 10) / parseInt(den, 10) : parseFloat(num);
+    }
+    const duration = parseFloat(data.format?.duration || videoStream.duration || "0");
+    const frameCount = parseInt(videoStream.nb_frames, 10) || Math.round(duration * fps);
+    return {
+      duration,
+      frameCount,
+      fps,
+      width: videoStream.width,
+      height: videoStream.height,
+      codec: videoStream.codec_name
+    };
+  } catch (error) {
+    console.error("Failed to get video info:", error);
+    return null;
+  }
+}
+async function extractFrames(options) {
+  const { projectId, videoPath, outputFormat = "png" } = options;
+  if (!existsSync(videoPath)) {
+    return { success: false, error: `Video file not found: ${videoPath}` };
+  }
+  const framesDir = join(FRAMES_DIR, projectId);
+  if (!existsSync(framesDir)) {
+    mkdirSync(framesDir, { recursive: true });
+  }
+  const videoInfo = getVideoInfo(videoPath);
+  if (!videoInfo) {
+    return { success: false, error: "Failed to read video information" };
+  }
+  const args = buildFFmpegArgs(options, framesDir, videoInfo, outputFormat);
+  return new Promise((resolve) => {
+    const proc = spawn("ffmpeg", args);
+    let stderr = "";
+    proc.stderr.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code !== 0) {
+        resolve({ success: false, error: `FFmpeg failed: ${stderr.slice(-500)}` });
+        return;
+      }
+      const frames = listExtractedFrames(framesDir, videoInfo.fps, options.fps || 1);
+      resolve({
+        success: true,
+        framesDir,
+        frameCount: frames.length,
+        frames
+      });
+    });
+    proc.on("error", (err) => {
+      resolve({ success: false, error: err.message });
+    });
+  });
+}
+function buildFFmpegArgs(options, framesDir, videoInfo, outputFormat) {
+  const args = ["-y"];
+  args.push("-i", options.videoPath);
+  if (options.startTime !== void 0) {
+    args.push("-ss", options.startTime.toString());
+  }
+  if (options.endTime !== void 0) {
+    args.push("-to", options.endTime.toString());
+  }
+  if (options.keyFramesOnly) {
+    args.push("-vf", "select=eq(pict_type\\,I)");
+    args.push("-vsync", "vfr");
+  } else if (options.fps) {
+    args.push("-vf", `fps=${options.fps}`);
+  } else {
+    args.push("-vf", "fps=1");
+  }
+  if (options.maxFrames) {
+    args.push("-frames:v", options.maxFrames.toString());
+  }
+  if (outputFormat === "jpg" && options.quality) {
+    args.push("-q:v", options.quality.toString());
+  }
+  const outputPattern = join(framesDir, `frame-%04d.${outputFormat}`);
+  args.push(outputPattern);
+  return args;
+}
+function listExtractedFrames(framesDir, videoFps, extractFps) {
+  const files = readdirSync(framesDir).filter((f) => f.startsWith("frame-") && (f.endsWith(".png") || f.endsWith(".jpg"))).sort();
+  return files.map((filename, index) => {
+    const timestamp = index / extractFps;
+    const match = filename.match(/frame-(\d+)/);
+    const frameNumber = match ? parseInt(match[1], 10) : index + 1;
+    return {
+      path: join(framesDir, filename),
+      frameNumber,
+      timestamp,
+      filename
+    };
+  });
+}
+function isBlankFrame(imagePath) {
+  try {
+    const output = execSync(
+      `ffmpeg -i "${imagePath}" -vf "crop=iw*0.8:ih*0.8:iw*0.1:ih*0.1,signalstats" -f null - 2>&1`,
+      { encoding: "utf-8", timeout: 5e3 }
+    );
+    const match = output.match(/YAVG:\s*([\d.]+)/);
+    if (!match) return { isBlank: false, brightness: 128 };
+    const brightness = parseFloat(match[1]);
+    return {
+      isBlank: brightness > 240 || brightness < 15,
+      brightness
+    };
+  } catch {
+    return { isBlank: false, brightness: 128 };
+  }
+}
+function filterBlankFrames(frames) {
+  const { unlinkSync } = __require("fs");
+  return frames.filter((frame) => {
+    if (!existsSync(frame.path)) return false;
+    const { isBlank } = isBlankFrame(frame.path);
+    if (isBlank) {
+      try {
+        unlinkSync(frame.path);
+      } catch {
+      }
+      return false;
+    }
+    return true;
+  });
+}
+async function detectKeyFrames(videoPath, threshold = 0.3) {
+  if (!existsSync(videoPath)) {
+    return [];
+  }
+  try {
+    const output = execSync(
+      `ffmpeg -i "${videoPath}" -vf "select='gt(scene,${threshold})',showinfo" -f null - 2>&1`,
+      { encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
+    );
+    const keyFrames = [];
+    const lines = output.split("\n");
+    for (const line of lines) {
+      const match = line.match(/n:\s*(\d+).*pts_time:\s*([\d.]+)/);
+      if (match) {
+        const frameNumber = parseInt(match[1], 10);
+        const timestamp = parseFloat(match[2]);
+        const scoreMatch = line.match(/scene:\s*([\d.]+)/);
+        const score = scoreMatch ? parseFloat(scoreMatch[1]) : threshold;
+        keyFrames.push({
+          path: "",
+          frameNumber,
+          timestamp,
+          filename: `keyframe-${frameNumber}.png`,
+          score,
+          isSceneChange: score > threshold
+        });
+      }
+    }
+    return keyFrames;
+  } catch (error) {
+    console.error("Failed to detect key frames:", error);
+    return [];
+  }
+}
+async function extractKeyFramesOnly(projectId, videoPath, threshold = 0.3) {
+  const keyFrames = await detectKeyFrames(videoPath, threshold);
+  if (keyFrames.length === 0) {
+    return extractFrames({
+      projectId,
+      videoPath,
+      fps: 1,
+      maxFrames: 30
+    });
+  }
+  const framesDir = join(FRAMES_DIR, projectId);
+  if (!existsSync(framesDir)) {
+    mkdirSync(framesDir, { recursive: true });
+  }
+  const extractedFrames = [];
+  for (let i = 0; i < keyFrames.length; i++) {
+    const kf = keyFrames[i];
+    const outputPath = join(framesDir, `keyframe-${String(i + 1).padStart(4, "0")}.png`);
+    try {
+      execSync(
+        `ffmpeg -y -ss ${kf.timestamp} -i "${videoPath}" -frames:v 1 "${outputPath}"`,
+        { stdio: "ignore" }
+      );
+      if (existsSync(outputPath)) {
+        extractedFrames.push({
+          path: outputPath,
+          frameNumber: i + 1,
+          timestamp: kf.timestamp,
+          filename: basename(outputPath)
+        });
+      }
+    } catch {
+    }
+  }
+  return {
+    success: true,
+    framesDir,
+    frameCount: extractedFrames.length,
+    frames: extractedFrames
+  };
+}
+async function generateThumbnail(videoPath, outputPath, timestamp = 0, width = 320) {
+  if (!existsSync(videoPath)) {
+    return false;
+  }
+  try {
+    execSync(
+      `ffmpeg -y -ss ${timestamp} -i "${videoPath}" -vframes 1 -vf "scale=${width}:-1" "${outputPath}"`,
+      { stdio: "ignore" }
+    );
+    return existsSync(outputPath);
+  } catch {
+    return false;
+  }
+}
+function compareFrames(frame1, frame2) {
+  try {
+    const output = execSync(
+      `compare -metric RMSE "${frame1}" "${frame2}" null: 2>&1 || true`,
+      { encoding: "utf-8" }
+    );
+    const match = output.match(/^([\d.]+)/);
+    if (match) {
+      return parseFloat(match[1]);
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function cleanupFrames(projectId) {
+  const framesDir = join(FRAMES_DIR, projectId);
+  if (existsSync(framesDir)) {
+    const files = readdirSync(framesDir);
+    for (const file of files) {
+      try {
+        const filePath = join(framesDir, file);
+        const stat = statSync(filePath);
+        if (stat.isFile()) {
+          __require("fs").unlinkSync(filePath);
+        }
+      } catch {
+      }
+    }
+  }
+}
+
+export {
+  getVideoInfo,
+  extractFrames,
+  isBlankFrame,
+  filterBlankFrames,
+  detectKeyFrames,
+  extractKeyFramesOnly,
+  generateThumbnail,
+  compareFrames,
+  cleanupFrames
+};

package/dist/{chunk-FNUN7EPB.js → chunk-RCY26WEK.js}

@@ -5,7 +5,7 @@ import {
 import {
   DATA_DIR,
   DB_PATH
-} from "./chunk-VVIOB362.js";
+} from "./chunk-XAMA3JJG.js";
 
 // src/mcp/tools/setup.ts
 import { z } from "zod";
@@ -224,7 +224,7 @@ var setupInitTool = {
   inputSchema: z.object({}),
   handler: async () => {
     try {
-      const { getDatabase, DATA_DIR: DATA_DIR2, PROJECTS_DIR, EXPORTS_DIR, FRAMES_DIR } = await import("./db-6WLEVKUV.js");
+      const { getDatabase, DATA_DIR: DATA_DIR2, PROJECTS_DIR, EXPORTS_DIR, FRAMES_DIR } = await import("./db-745LC5YC.js");
       getDatabase();
       return createJsonResult({
         message: "DiscoveryLab initialized successfully",

package/dist/{chunk-ZLHIHMSL.js → chunk-SWZIBO2R.js}

@@ -15,7 +15,7 @@ import {
   inspectESVPSession,
   replayESVPSession,
   runESVPActions
-} from "./chunk-7EDIUVIO.js";
+} from "./chunk-EU63HPKT.js";
 import {
   redactSensitiveTestInput
 } from "./chunk-SLNJEF32.js";

package/dist/chunk-VYYAP5G5.js

@@ -0,0 +1,265 @@
+import {
+  getBundlePath,
+  getTemplate
+} from "./chunk-DKAX5RCX.js";
+import {
+  DATA_DIR,
+  EXPORTS_DIR
+} from "./chunk-XAMA3JJG.js";
+
+// src/core/templates/renderer.ts
+import { existsSync, mkdirSync } from "fs";
+import { execSync } from "child_process";
+import { join } from "path";
+var renderJobs = /* @__PURE__ */ new Map();
+var jobCounter = 0;
+function generateJobId() {
+  return `render_${Date.now()}_${++jobCounter}`;
+}
+function getOutputDir(projectId) {
+  const dir = join(EXPORTS_DIR, projectId);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getLineCount(text) {
+  return String(text || "").replace(/\r\n/g, "\n").split("\n").length;
+}
+function shouldPreserveTerminalTabContent(tab, profile) {
+  return tab.content.length <= profile.maxCharsPerTab && getLineCount(tab.content) <= profile.maxLinesPerTab;
+}
+function clampTextForTerminalRender(text, profile) {
+  const normalized = String(text || "").replace(/\r\n/g, "\n").replace(/\t/g, "  ");
+  const rawLines = normalized.split("\n").map((line) => line.replace(/\s+$/g, ""));
+  const truncatedByLines = rawLines.length > profile.maxLinesPerTab;
+  const visibleLines = truncatedByLines ? rawLines.slice(0, profile.maxLinesPerTab - 1) : rawLines.slice(0, profile.maxLinesPerTab);
+  if (truncatedByLines) {
+    const hiddenLines = Math.max(1, rawLines.length - visibleLines.length);
+    visibleLines.push(`... +${hiddenLines} more lines`);
+  }
+  let output = visibleLines.join("\n").trim();
+  if (output.length > profile.maxCharsPerTab) {
+    output = `${output.slice(0, Math.max(0, profile.maxCharsPerTab - 12)).trimEnd()}
+...`;
+  }
+  return output || "// no terminal content";
+}
+function formatCompactBytes(value) {
+  const bytes = Number(value);
+  if (!Number.isFinite(bytes) || bytes <= 0) return "";
+  if (bytes >= 1e6) return `${(bytes / 1e6).toFixed(1)}MB`;
+  if (bytes >= 1e3) return `${(bytes / 1e3).toFixed(1)}KB`;
+  return `${Math.round(bytes)}B`;
+}
+function compactTerminalJsonContent(tab, profile) {
+  try {
+    const parsed = JSON.parse(tab.content);
+    if (!Array.isArray(parsed)) return null;
+    const lines = parsed.slice(0, profile.maxJsonItemsPerTab).map((item) => {
+      if (!item || typeof item !== "object") return null;
+      const record = item;
+      const status = record.status ?? "...";
+      const duration = Number.isFinite(Number(record.durationMs)) ? `${Math.round(Number(record.durationMs))}ms` : "";
+      const size = formatCompactBytes(record.responseSize);
+      const rawUrl = typeof record.url === "string" ? record.url : "";
+      let displayUrl = rawUrl || tab.route || tab.label;
+      try {
+        const parsedUrl = new URL(rawUrl);
+        displayUrl = parsedUrl.pathname || `${parsedUrl.origin}${parsedUrl.pathname}`;
+      } catch {
+      }
+      return [status, duration, size, displayUrl].filter(Boolean).join(" ");
+    }).filter((line) => !!line);
+    if (parsed.length > lines.length) {
+      lines.push(`... +${parsed.length - lines.length} more requests`);
+    }
+    return clampTextForTerminalRender(lines.join("\n"), profile);
+  } catch {
+    return null;
+  }
+}
+function getTemplateRenderOptimizationProfile(templateId, props, realVideoDuration) {
+  const totalChars = Array.isArray(props.terminalTabs) ? props.terminalTabs.reduce((sum, tab) => sum + String(tab?.content || "").length, 0) : 0;
+  const tabCount = Array.isArray(props.terminalTabs) ? props.terminalTabs.length : 0;
+  const isLongVideo = (realVideoDuration || props.videoDuration || 0) >= 30;
+  const isHeavyTerminal = totalChars >= 1600 || tabCount >= 6;
+  const showcaseAggressive = templateId === "showcase";
+  if (isLongVideo || isHeavyTerminal || showcaseAggressive) {
+    return {
+      maxTabs: showcaseAggressive ? 4 : 5,
+      maxCharsPerTab: showcaseAggressive ? 1e3 : isLongVideo ? 1800 : 2200,
+      maxLinesPerTab: showcaseAggressive ? 22 : 40,
+      maxJsonItemsPerTab: showcaseAggressive ? 6 : 12,
+      maxTotalChars: showcaseAggressive ? 3500 : 7e3
+    };
+  }
+  return {
+    maxTabs: 6,
+    maxCharsPerTab: 2800,
+    maxLinesPerTab: 60,
+    maxJsonItemsPerTab: 16,
+    maxTotalChars: 1e4
+  };
+}
+function optimizeTemplatePropsForRender(templateId, props, realVideoDuration) {
+  if (!Array.isArray(props.terminalTabs) || props.terminalTabs.length === 0) {
+    return { ...props };
+  }
+  const profile = getTemplateRenderOptimizationProfile(templateId, props, realVideoDuration);
+  const terminalTabs = props.terminalTabs.slice(0, profile.maxTabs).map((tab) => {
+    if (shouldPreserveTerminalTabContent(tab, profile)) {
+      return { ...tab };
+    }
+    const compactJson = compactTerminalJsonContent(tab, profile);
+    return {
+      ...tab,
+      content: compactJson || clampTextForTerminalRender(tab.content, profile)
+    };
+  });
+  let totalChars = terminalTabs.reduce((sum, tab) => sum + tab.content.length, 0);
+  while (totalChars > profile.maxTotalChars && terminalTabs.length > 1) {
+    terminalTabs.pop();
+    totalChars = terminalTabs.reduce((sum, tab) => sum + tab.content.length, 0);
+  }
+  if (totalChars > profile.maxTotalChars && terminalTabs.length === 1) {
+    const [tab] = terminalTabs;
+    const compactJson = compactTerminalJsonContent(tab, profile);
+    terminalTabs[0] = {
+      ...tab,
+      content: compactJson || clampTextForTerminalRender(tab.content, profile)
+    };
+  }
+  return {
+    ...props,
+    terminalTabs,
+    hasNetworkData: terminalTabs.length > 0
+  };
+}
+async function startRender(projectId, templateId, props, onProgress) {
+  const bundlePath = getBundlePath();
+  if (!bundlePath) {
+    throw new Error("Templates not installed. Bundle not found at ~/.discoverylab/templates/bundle/");
+  }
+  const template = getTemplate(templateId);
+  if (!template) {
+    throw new Error(`Template "${templateId}" not found in manifest`);
+  }
+  const jobId = generateJobId();
+  const outputDir = getOutputDir(projectId);
+  const outputPath = join(outputDir, `template-${templateId}.mp4`);
+  const job = {
+    id: jobId,
+    projectId,
+    templateId,
+    status: "queued",
+    progress: 0,
+    outputPath,
+    startedAt: Date.now()
+  };
+  renderJobs.set(jobId, job);
+  renderAsync(job, bundlePath, templateId, template.compositionId, props, onProgress).catch((err) => {
+    job.status = "error";
+    job.error = err.message;
+    job.completedAt = Date.now();
+  });
+  return job;
+}
+async function renderAsync(job, bundlePath, templateId, compositionId, props, onProgress) {
+  job.status = "rendering";
+  const originalCwd = process.cwd();
+  try {
+    process.chdir(DATA_DIR);
+    const { selectComposition, renderMedia } = await import("@remotion/renderer");
+    const realVideoDuration = getVideoDuration(props.videoUrl);
+    const optimizedProps = optimizeTemplatePropsForRender(templateId, props, realVideoDuration);
+    if (realVideoDuration && realVideoDuration > 0) {
+      optimizedProps.videoDuration = realVideoDuration;
+    }
+    const composition = await selectComposition({
+      serveUrl: bundlePath,
+      id: compositionId,
+      inputProps: optimizedProps
+    });
+    const fps = composition.fps || 30;
+    let durationOverride;
+    if (realVideoDuration && realVideoDuration > 0) {
+      const videoFrames = Math.ceil(realVideoDuration * fps);
+      if (videoFrames > composition.durationInFrames) {
+        durationOverride = videoFrames;
+      }
+    }
+    await renderMedia({
+      composition: durationOverride ? { ...composition, durationInFrames: durationOverride } : composition,
+      serveUrl: bundlePath,
+      codec: "h264",
+      outputLocation: job.outputPath,
+      inputProps: optimizedProps,
+      onProgress: ({ progress }) => {
+        job.progress = progress;
+        onProgress?.(progress);
+      }
+    });
+    job.status = "done";
+    job.progress = 1;
+    job.completedAt = Date.now();
+  } catch (err) {
+    job.status = "error";
+    job.error = err.message;
+    job.completedAt = Date.now();
+    throw err;
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+function getVideoDuration(videoUrl) {
+  try {
+    let filePath = videoUrl;
+    if (videoUrl.startsWith("http")) {
+      const url = new URL(videoUrl);
+      const pathParam = url.searchParams.get("path");
+      if (pathParam) {
+        filePath = decodeURIComponent(pathParam);
+      } else {
+        return null;
+      }
+    }
+    if (!existsSync(filePath)) return null;
+    const output = execSync(
+      `ffprobe -v quiet -print_format json -show_format "${filePath}"`,
+      { encoding: "utf-8", timeout: 1e4 }
+    );
+    const data = JSON.parse(output);
+    const duration = parseFloat(data.format?.duration || "0");
+    return duration > 0 ? duration : null;
+  } catch {
+    return null;
+  }
+}
+function getRenderJob(jobId) {
+  return renderJobs.get(jobId) ?? null;
+}
+function getProjectRenderJobs(projectId) {
+  return Array.from(renderJobs.values()).filter((j) => j.projectId === projectId);
+}
+function getCachedRender(projectId, templateId) {
+  const outputPath = join(EXPORTS_DIR, projectId, `template-${templateId}.mp4`);
+  if (existsSync(outputPath)) return outputPath;
+  return null;
+}
+function cleanupRenderJobs(maxAge = 36e5) {
+  const now = Date.now();
+  for (const [id, job] of renderJobs) {
+    if (job.completedAt && now - job.completedAt > maxAge) {
+      renderJobs.delete(id);
+    }
+  }
+}
+
+export {
+  startRender,
+  getRenderJob,
+  getProjectRenderJobs,
+  getCachedRender,
+  cleanupRenderJobs
+};

package/dist/{chunk-VVIOB362.js → chunk-XAMA3JJG.js}

@@ -1,6 +1,6 @@
 import {
   __export
-} from "./chunk-MLKGABMK.js";
+} from "./chunk-4VNS5WPM.js";
 
 // src/db/index.ts
 import Database from "better-sqlite3";
@@ -58,6 +58,11 @@ var projects = sqliteTable("projects", {
   // AI-generated requirements from linked content
   taskTestMap: text("task_test_map"),
   // AI-generated test map from linked content
+  // Marketing / Export
+  marketingTitle: text("marketing_title"),
+  // Cleaned title without device names
+  marketingDescription: text("marketing_description"),
+  // AI-generated marketing-quality description
   // Status
   status: text("status").default("draft"),
   // 'draft' | 'analyzed' | 'exported' | 'archived'
@@ -232,6 +237,18 @@ function createTables(sqlite) {
     sqlite.exec(`ALTER TABLE projects ADD COLUMN ocr_confidence REAL`);
   } catch (e) {
   }
+  try {
+    sqlite.exec(`ALTER TABLE projects ADD COLUMN marketing_title TEXT`);
+  } catch (e) {
+  }
+  try {
+    sqlite.exec(`ALTER TABLE projects ADD COLUMN marketing_description TEXT`);
+  } catch (e) {
+  }
+  try {
+    sqlite.exec(`UPDATE projects SET marketing_title = name WHERE marketing_title IS NULL`);
+  } catch (e) {
+  }
   sqlite.exec(`
     CREATE TABLE IF NOT EXISTS project_exports (
       id TEXT PRIMARY KEY,