@veolab/discoverylab 0.1.0

package/dist/cli.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk from "chalk";
+import open from "open";
+var program = new Command();
+program.name("discoverylab").description("AI-powered app testing & evidence generator - Claude Code Plugin").version("0.1.0");
+program.command("serve").description("Start the DiscoveryLab web UI server").option("-p, --port <number>", "Port to listen on", "3847").option("-o, --open", "Open browser automatically", false).action(async (options) => {
+  const port = parseInt(options.port, 10);
+  console.log(chalk.cyan("\n  DiscoveryLab"));
+  console.log(chalk.gray("  AI-powered app testing & evidence generator\n"));
+  try {
+    const { startServer } = await import("./server-NM5CKDUU.js");
+    await startServer(port);
+    console.log(chalk.green(`  Server running at http://localhost:${port}`));
+    console.log(chalk.gray("  Press Ctrl+C to stop\n"));
+    if (options.open) {
+      await open(`http://localhost:${port}`);
+    }
+  } catch (error) {
+    console.error(chalk.red(`  Failed to start server: ${error}`));
+    process.exit(1);
+  }
+});
+program.command("setup").description("Check and configure DiscoveryLab dependencies").action(async () => {
+  console.log(chalk.cyan("\n  DiscoveryLab Setup\n"));
+  try {
+    const { setupStatusTool } = await import("./setup-27CQAX6K.js");
+    const result = await setupStatusTool.handler({});
+    if (result.isError) {
+      console.error(chalk.red("  Setup check failed"));
+      return;
+    }
+    const data = JSON.parse(result.content[0].text);
+    console.log(chalk.gray(`  Platform: ${data.platform}`));
+    console.log(chalk.gray(`  Data directory: ${data.dataDirectory.path}`));
+    console.log();
+    console.log(chalk.white("  Dependencies:"));
+    for (const dep of data.dependencies) {
+      const status = dep.installed ? chalk.green(`  ${dep.name} ${dep.version}`) : chalk.red(`  ${dep.name} (not installed)`);
+      const required = dep.required ? chalk.yellow(" [required]") : chalk.gray(" [optional]");
+      console.log(`${status}${required}`);
+      if (!dep.installed && dep.installHint) {
+        console.log(chalk.gray(`     Install: ${dep.installHint}`));
+      }
+    }
+    console.log();
+    if (data.ready) {
+      console.log(chalk.green("  Ready to use!"));
+      console.log(chalk.gray("  Run: discoverylab serve"));
+    } else {
+      console.log(chalk.yellow("  Some required dependencies are missing."));
+      console.log(chalk.gray("  Install them and run setup again."));
+    }
+    console.log();
+  } catch (error) {
+    console.error(chalk.red(`  Setup failed: ${error}`));
+    process.exit(1);
+  }
+});
+program.command("init").description("Initialize DiscoveryLab data directories").action(async () => {
+  console.log(chalk.cyan("\n  Initializing DiscoveryLab...\n"));
+  try {
+    const { getDatabase, DATA_DIR, PROJECTS_DIR, EXPORTS_DIR } = await import("./db-IWIL65EX.js");
+    getDatabase();
+    console.log(chalk.green("  Created directories:"));
+    console.log(chalk.gray(`    ${DATA_DIR}`));
+    console.log(chalk.gray(`    ${PROJECTS_DIR}`));
+    console.log(chalk.gray(`    ${EXPORTS_DIR}`));
+    console.log();
+    console.log(chalk.green("  Database initialized successfully!"));
+    console.log();
+  } catch (error) {
+    console.error(chalk.red(`  Initialization failed: ${error}`));
+    process.exit(1);
+  }
+});
+program.command("mcp").description("Run as MCP server (for Claude Code integration)").action(async () => {
+  try {
+    const { getDatabase } = await import("./db-IWIL65EX.js");
+    getDatabase();
+    const { mcpServer } = await import("./server-3FBHBA7L.js");
+    const { uiTools, projectTools, setupTools, captureTools, analyzeTools, canvasTools, exportTools, testingTools, integrationTools } = await import("./tools-75BAPCUM.js");
+    mcpServer.registerTools([
+      ...uiTools,
+      ...projectTools,
+      ...setupTools,
+      ...captureTools,
+      ...analyzeTools,
+      ...canvasTools,
+      ...exportTools,
+      ...testingTools,
+      ...integrationTools
+    ]);
+    await mcpServer.runStdio();
+  } catch (error) {
+    console.error(`MCP server error: ${error}`);
+    process.exit(1);
+  }
+});
+program.command("info").description("Show version and configuration info").action(async () => {
+  console.log(chalk.cyan("\n  DiscoveryLab v0.1.0\n"));
+  console.log(chalk.gray("  AI-powered app testing & evidence generator"));
+  console.log(chalk.gray("  Claude Code Plugin\n"));
+  try {
+    const { DATA_DIR, DB_PATH } = await import("./db-IWIL65EX.js");
+    console.log(chalk.white("  Paths:"));
+    console.log(chalk.gray(`    Data: ${DATA_DIR}`));
+    console.log(chalk.gray(`    Database: ${DB_PATH}`));
+    console.log();
+  } catch {
+    console.log(chalk.gray("  (Database not initialized)"));
+    console.log();
+  }
+});
+program.parse();
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/dist/db-IWIL65EX.js

@@ -0,0 +1,33 @@
+import {
+  DATA_DIR,
+  DB_PATH,
+  EXPORTS_DIR,
+  FRAMES_DIR,
+  PROJECTS_DIR,
+  closeDatabase,
+  exportDestinations,
+  exportRules,
+  frames,
+  getDatabase,
+  getSqlite,
+  projectExports,
+  projects,
+  settings
+} from "./chunk-VY3BLXBW.js";
+import "./chunk-MLKGABMK.js";
+export {
+  DATA_DIR,
+  DB_PATH,
+  EXPORTS_DIR,
+  FRAMES_DIR,
+  PROJECTS_DIR,
+  closeDatabase,
+  exportDestinations,
+  exportRules,
+  frames,
+  getDatabase,
+  getSqlite,
+  projectExports,
+  projects,
+  settings
+};

package/dist/gridCompositor-ENKLFPWR.js

@@ -0,0 +1,409 @@
+import "./chunk-MLKGABMK.js";
+
+// src/core/canvas/gridCompositor.ts
+import { createCanvas, loadImage } from "canvas";
+import { existsSync, writeFileSync, mkdirSync, readdirSync } from "fs";
+import { join } from "path";
+var ASPECT_RATIOS = {
+  "9:16": { width: 1080, height: 1920 },
+  "1:1": { width: 1080, height: 1080 },
+  "16:9": { width: 1920, height: 1080 }
+};
+var DEFAULT_CONFIG = {
+  aspectRatio: "9:16",
+  layout: "quad",
+  background: {
+    type: "gradient",
+    gradientStart: "#1a1a2e",
+    gradientEnd: "#16213e",
+    gradientAngle: 135
+  },
+  padding: 40,
+  cellPadding: 16,
+  cornerRadius: 16,
+  shadowEnabled: true,
+  shadowBlur: 20,
+  outputWidth: 1080,
+  imageFit: "cover"
+};
+function calculateCells(layout, canvasWidth, canvasHeight, padding, cellPadding, imageCount) {
+  const contentWidth = canvasWidth - padding * 2;
+  const contentHeight = canvasHeight - padding * 2;
+  const cells = [];
+  switch (layout) {
+    case "single": {
+      cells.push({
+        x: padding,
+        y: padding,
+        width: contentWidth,
+        height: contentHeight
+      });
+      break;
+    }
+    case "duo-h": {
+      const cellWidth = (contentWidth - cellPadding) / 2;
+      cells.push(
+        { x: padding, y: padding, width: cellWidth, height: contentHeight },
+        { x: padding + cellWidth + cellPadding, y: padding, width: cellWidth, height: contentHeight }
+      );
+      break;
+    }
+    case "duo-v": {
+      const cellHeight = (contentHeight - cellPadding) / 2;
+      cells.push(
+        { x: padding, y: padding, width: contentWidth, height: cellHeight },
+        { x: padding, y: padding + cellHeight + cellPadding, width: contentWidth, height: cellHeight }
+      );
+      break;
+    }
+    case "trio-h": {
+      const cellWidth = (contentWidth - cellPadding * 2) / 3;
+      for (let i = 0; i < 3; i++) {
+        cells.push({
+          x: padding + i * (cellWidth + cellPadding),
+          y: padding,
+          width: cellWidth,
+          height: contentHeight
+        });
+      }
+      break;
+    }
+    case "trio-v": {
+      const cellHeight = (contentHeight - cellPadding * 2) / 3;
+      for (let i = 0; i < 3; i++) {
+        cells.push({
+          x: padding,
+          y: padding + i * (cellHeight + cellPadding),
+          width: contentWidth,
+          height: cellHeight
+        });
+      }
+      break;
+    }
+    case "quad": {
+      const cellWidth = (contentWidth - cellPadding) / 2;
+      const cellHeight = (contentHeight - cellPadding) / 2;
+      for (let row = 0; row < 2; row++) {
+        for (let col = 0; col < 2; col++) {
+          cells.push({
+            x: padding + col * (cellWidth + cellPadding),
+            y: padding + row * (cellHeight + cellPadding),
+            width: cellWidth,
+            height: cellHeight
+          });
+        }
+      }
+      break;
+    }
+    case "featured": {
+      const leftWidth = contentWidth * 0.6 - cellPadding / 2;
+      const rightWidth = contentWidth * 0.4 - cellPadding / 2;
+      const rightHeight = (contentHeight - cellPadding) / 2;
+      cells.push(
+        { x: padding, y: padding, width: leftWidth, height: contentHeight },
+        { x: padding + leftWidth + cellPadding, y: padding, width: rightWidth, height: rightHeight },
+        { x: padding + leftWidth + cellPadding, y: padding + rightHeight + cellPadding, width: rightWidth, height: rightHeight }
+      );
+      break;
+    }
+    case "masonry": {
+      const colWidth = (contentWidth - cellPadding * 2) / 3;
+      const heights = [0, 0, 0];
+      const count = Math.min(imageCount, 6);
+      for (let i = 0; i < count; i++) {
+        const col = i % 3;
+        const cellHeight = i < 3 ? contentHeight * 0.55 : contentHeight * 0.45 - cellPadding;
+        cells.push({
+          x: padding + col * (colWidth + cellPadding),
+          y: padding + heights[col],
+          width: colWidth,
+          height: cellHeight
+        });
+        heights[col] += cellHeight + cellPadding;
+      }
+      break;
+    }
+    case "carousel": {
+      const cardWidth = contentWidth * 0.7;
+      const cardHeight = contentHeight * 0.85;
+      const overlap = cardWidth * 0.3;
+      const count = Math.min(imageCount, 3);
+      for (let i = 0; i < count; i++) {
+        const scale = 1 - i * 0.05;
+        const w = cardWidth * scale;
+        const h = cardHeight * scale;
+        cells.push({
+          x: padding + (contentWidth - w) / 2 + (i - 1) * overlap,
+          y: padding + (contentHeight - h) / 2 + i * 10,
+          width: w,
+          height: h
+        });
+      }
+      break;
+    }
+    case "stacked": {
+      const cardWidth = contentWidth * 0.8;
+      const cardHeight = contentHeight * 0.7;
+      const count = Math.min(imageCount, 4);
+      const offsetY = 30;
+      const offsetX = 15;
+      for (let i = count - 1; i >= 0; i--) {
+        cells.push({
+          x: padding + (contentWidth - cardWidth) / 2 + i * offsetX,
+          y: padding + (contentHeight - cardHeight) / 2 - i * offsetY,
+          width: cardWidth,
+          height: cardHeight
+        });
+      }
+      break;
+    }
+    default:
+      cells.push({
+        x: padding,
+        y: padding,
+        width: contentWidth,
+        height: contentHeight
+      });
+  }
+  return cells;
+}
+function drawRoundedRect(ctx, x, y, width, height, radius) {
+  ctx.beginPath();
+  ctx.moveTo(x + radius, y);
+  ctx.lineTo(x + width - radius, y);
+  ctx.quadraticCurveTo(x + width, y, x + width, y + radius);
+  ctx.lineTo(x + width, y + height - radius);
+  ctx.quadraticCurveTo(x + width, y + height, x + width - radius, y + height);
+  ctx.lineTo(x + radius, y + height);
+  ctx.quadraticCurveTo(x, y + height, x, y + height - radius);
+  ctx.lineTo(x, y + radius);
+  ctx.quadraticCurveTo(x, y, x + radius, y);
+  ctx.closePath();
+}
+function drawBackground(ctx, width, height, config, bgImage) {
+  if (config.type === "image" && bgImage) {
+    const scale = Math.max(width / bgImage.width, height / bgImage.height);
+    const scaledWidth = bgImage.width * scale;
+    const scaledHeight = bgImage.height * scale;
+    const offsetX = (width - scaledWidth) / 2;
+    const offsetY = (height - scaledHeight) / 2;
+    ctx.drawImage(bgImage, offsetX, offsetY, scaledWidth, scaledHeight);
+  } else if (config.type === "gradient") {
+    const angle = (config.gradientAngle || 135) * Math.PI / 180;
+    const length = Math.sqrt(width * width + height * height);
+    const x1 = width / 2 - Math.cos(angle) * length / 2;
+    const y1 = height / 2 - Math.sin(angle) * length / 2;
+    const x2 = width / 2 + Math.cos(angle) * length / 2;
+    const y2 = height / 2 + Math.sin(angle) * length / 2;
+    const gradient = ctx.createLinearGradient(x1, y1, x2, y2);
+    gradient.addColorStop(0, config.gradientStart || "#1a1a2e");
+    gradient.addColorStop(1, config.gradientEnd || "#16213e");
+    ctx.fillStyle = gradient;
+    ctx.fillRect(0, 0, width, height);
+  } else {
+    ctx.fillStyle = config.color || "#1a1a2e";
+    ctx.fillRect(0, 0, width, height);
+  }
+}
+function drawShadow(ctx, x, y, width, height, radius, blur) {
+  ctx.save();
+  ctx.shadowColor = "rgba(0, 0, 0, 0.4)";
+  ctx.shadowBlur = blur;
+  ctx.shadowOffsetX = 0;
+  ctx.shadowOffsetY = blur / 3;
+  ctx.fillStyle = "white";
+  drawRoundedRect(ctx, x, y, width, height, radius);
+  ctx.fill();
+  ctx.restore();
+}
+function calculateImageBounds(image, cell, imageFit) {
+  const imageAspect = image.width / image.height;
+  const cellAspect = cell.width / cell.height;
+  let drawWidth;
+  let drawHeight;
+  let offsetX;
+  let offsetY;
+  if (imageFit === "cover") {
+    if (imageAspect > cellAspect) {
+      drawHeight = cell.height;
+      drawWidth = cell.height * imageAspect;
+      offsetX = (cell.width - drawWidth) / 2;
+      offsetY = 0;
+    } else {
+      drawWidth = cell.width;
+      drawHeight = cell.width / imageAspect;
+      offsetX = 0;
+      offsetY = (cell.height - drawHeight) / 2;
+    }
+    return {
+      x: cell.x,
+      y: cell.y,
+      width: cell.width,
+      height: cell.height,
+      drawWidth,
+      drawHeight,
+      offsetX,
+      offsetY
+    };
+  } else {
+    if (imageAspect > cellAspect) {
+      drawWidth = cell.width;
+      drawHeight = cell.width / imageAspect;
+      offsetX = 0;
+      offsetY = (cell.height - drawHeight) / 2;
+    } else {
+      drawHeight = cell.height;
+      drawWidth = cell.height * imageAspect;
+      offsetX = (cell.width - drawWidth) / 2;
+      offsetY = 0;
+    }
+    return {
+      x: cell.x + offsetX,
+      y: cell.y + offsetY,
+      width: drawWidth,
+      height: drawHeight,
+      drawWidth,
+      drawHeight,
+      offsetX,
+      offsetY
+    };
+  }
+}
+function drawImageInCell(ctx, image, cell, cornerRadius, imageFit = "cover", shadowEnabled = false, shadowBlur = 20) {
+  const bounds = calculateImageBounds(image, cell, imageFit);
+  if (shadowEnabled && imageFit === "contain") {
+    drawShadow(ctx, bounds.x, bounds.y, bounds.width, bounds.height, cornerRadius, shadowBlur);
+  }
+  ctx.save();
+  if (imageFit === "cover") {
+    drawRoundedRect(ctx, cell.x, cell.y, cell.width, cell.height, cornerRadius);
+  } else {
+    drawRoundedRect(ctx, bounds.x, bounds.y, bounds.width, bounds.height, cornerRadius);
+  }
+  ctx.clip();
+  ctx.drawImage(
+    image,
+    cell.x + bounds.offsetX,
+    cell.y + bounds.offsetY,
+    bounds.drawWidth,
+    bounds.drawHeight
+  );
+  ctx.restore();
+}
+async function composeGrid(images, config = {}, outputPath) {
+  try {
+    const cfg = { ...DEFAULT_CONFIG, ...config };
+    const aspectDef = ASPECT_RATIOS[cfg.aspectRatio];
+    const scale = cfg.outputWidth / aspectDef.width;
+    const canvasWidth = Math.round(aspectDef.width * scale);
+    const canvasHeight = Math.round(aspectDef.height * scale);
+    const canvas = createCanvas(canvasWidth, canvasHeight);
+    const ctx = canvas.getContext("2d");
+    let bgImage;
+    if (cfg.background.type === "image" && cfg.background.imagePath && existsSync(cfg.background.imagePath)) {
+      bgImage = await loadImage(cfg.background.imagePath);
+    }
+    drawBackground(ctx, canvasWidth, canvasHeight, cfg.background, bgImage);
+    const cells = calculateCells(
+      cfg.layout,
+      canvasWidth,
+      canvasHeight,
+      cfg.padding,
+      cfg.cellPadding,
+      images.length
+    );
+    for (let i = 0; i < Math.min(images.length, cells.length); i++) {
+      const cell = cells[i];
+      const imageCell = images[i];
+      if (!existsSync(imageCell.imagePath)) {
+        continue;
+      }
+      const image = await loadImage(imageCell.imagePath);
+      if (cfg.shadowEnabled && cfg.imageFit === "cover") {
+        drawShadow(ctx, cell.x, cell.y, cell.width, cell.height, cfg.cornerRadius, cfg.shadowBlur);
+      }
+      drawImageInCell(ctx, image, cell, cfg.cornerRadius, cfg.imageFit, cfg.shadowEnabled, cfg.shadowBlur);
+    }
+    const buffer = canvas.toBuffer("image/png");
+    const outputDir = outputPath.substring(0, outputPath.lastIndexOf("/"));
+    if (outputDir && !existsSync(outputDir)) {
+      mkdirSync(outputDir, { recursive: true });
+    }
+    writeFileSync(outputPath, buffer);
+    return {
+      success: true,
+      outputPath,
+      width: canvasWidth,
+      height: canvasHeight
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Grid composition failed";
+    return {
+      success: false,
+      error: message
+    };
+  }
+}
+function recommendLayout(imageCount, aspectRatio) {
+  if (imageCount === 1) return "single";
+  if (imageCount === 2) return aspectRatio === "16:9" ? "duo-h" : "duo-v";
+  if (imageCount === 3) return aspectRatio === "9:16" ? "trio-v" : "featured";
+  if (imageCount === 4) return "quad";
+  if (imageCount >= 5) return "masonry";
+  return "quad";
+}
+function getLayoutInfo(layout) {
+  const layouts = {
+    "single": { name: "Single", maxImages: 1, description: "One large image" },
+    "duo-h": { name: "Side by Side", maxImages: 2, description: "Two images horizontally" },
+    "duo-v": { name: "Stacked", maxImages: 2, description: "Two images vertically" },
+    "trio-h": { name: "3 Across", maxImages: 3, description: "Three images in a row" },
+    "trio-v": { name: "3 Down", maxImages: 3, description: "Three images in a column" },
+    "quad": { name: "Grid 2x2", maxImages: 4, description: "Four images in a grid" },
+    "featured": { name: "Featured", maxImages: 3, description: "One large + two small" },
+    "masonry": { name: "Masonry", maxImages: 6, description: "Pinterest-style columns" },
+    "carousel": { name: "Carousel", maxImages: 3, description: "Overlapping cards" },
+    "stacked": { name: "3D Stack", maxImages: 4, description: "Perspective stack effect" }
+  };
+  return layouts[layout];
+}
+function getAllLayouts() {
+  return ["single", "duo-h", "duo-v", "trio-h", "trio-v", "quad", "featured", "masonry", "carousel", "stacked"];
+}
+function getAvailableBackgrounds(backgroundsDir) {
+  if (!existsSync(backgroundsDir)) {
+    return [];
+  }
+  const files = readdirSync(backgroundsDir).filter((f) => /\.(jpg|jpeg|png|webp)$/i.test(f));
+  return files.map((f) => ({
+    id: f.replace(/\.[^.]+$/, ""),
+    name: f.replace(/[-_]/g, " ").replace(/\.[^.]+$/, ""),
+    path: join(backgroundsDir, f)
+  }));
+}
+var PRESET_GRADIENTS = [
+  { id: "dark-blue", name: "Dark Blue", start: "#1a1a2e", end: "#16213e" },
+  { id: "midnight", name: "Midnight", start: "#0f0c29", end: "#302b63" },
+  { id: "ocean", name: "Ocean", start: "#2193b0", end: "#6dd5ed" },
+  { id: "sunset", name: "Sunset", start: "#ff7e5f", end: "#feb47b" },
+  { id: "aurora", name: "Aurora", start: "#00c6ff", end: "#0072ff" },
+  { id: "forest", name: "Forest", start: "#134e5e", end: "#71b280" },
+  { id: "berry", name: "Berry", start: "#8e2de2", end: "#4a00e0" },
+  { id: "noir", name: "Noir", start: "#0a0a0a", end: "#1a1a1a" }
+];
+var PRESET_SOLID_COLORS = [
+  { id: "black", name: "Black", color: "#000000" },
+  { id: "dark-gray", name: "Dark Gray", color: "#1a1a1a" },
+  { id: "navy", name: "Navy", color: "#0a1628" },
+  { id: "charcoal", name: "Charcoal", color: "#2d2d2d" },
+  { id: "white", name: "White", color: "#ffffff" }
+];
+export {
+  PRESET_GRADIENTS,
+  PRESET_SOLID_COLORS,
+  composeGrid,
+  getAllLayouts,
+  getAvailableBackgrounds,
+  getLayoutInfo,
+  recommendLayout
+};