@ohos-ports/slides-grab 1.5.0-beta.0

package/scripts/figma-export.js

@@ -0,0 +1,169 @@
+#!/usr/bin/env node
+
+import { existsSync, readdirSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { resolve } from 'node:path';
+
+import PptxGenJS from 'pptxgenjs';
+
+import {
+  configureFigmaExportPresentation,
+  ensureOutputDirectory,
+  getFigmaImportCaveats,
+  normalizeFigmaOutput,
+  SLIDE_FILE_PATTERN,
+  sortFigmaSlideFiles,
+} from '../src/figma.js';
+
+const require = createRequire(import.meta.url);
+const html2pptx = require('../src/html2pptx.cjs');
+const { launchBrowser } = html2pptx;
+const { DEFAULT_SLIDE_MODE, getSlideModeChoices, normalizeSlideMode } = require('../src/slide-mode.cjs');
+
+const DEFAULT_SLIDES_DIR = 'slides';
+
+function printUsage() {
+  process.stdout.write(
+    [
+      'Usage: slides-grab figma [options]',
+      '',
+      'Options:',
+      `  --slides-dir <path>  Slide directory (default: ${DEFAULT_SLIDES_DIR})`,
+      '  --output <path>      Output PPTX file (default: <slides-dir>-figma.pptx)',
+      `  --mode <mode>        Slide mode: ${getSlideModeChoices().join('|')} (default: ${DEFAULT_SLIDE_MODE})`,
+      '  -h, --help           Show this help message',
+      '',
+      'Exports an experimental / unstable Figma Slides importable PPTX using the existing html2pptx pipeline.',
+      'Treat both PPTX and Figma export as best-effort only.',
+    ].join('\n'),
+  );
+  process.stdout.write('\n');
+}
+
+function readOptionValue(args, index, optionName) {
+  const next = args[index + 1];
+  if (!next || next.startsWith('-')) {
+    throw new Error(`Missing value for ${optionName}.`);
+  }
+  return next;
+}
+
+function parseArgs(args) {
+  const options = {
+    slidesDir: DEFAULT_SLIDES_DIR,
+    output: '',
+    mode: DEFAULT_SLIDE_MODE,
+    help: false,
+  };
+
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '-h' || arg === '--help') {
+      options.help = true;
+      continue;
+    }
+
+    if (arg === '--slides-dir') {
+      options.slidesDir = readOptionValue(args, i, '--slides-dir');
+      i += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--slides-dir=')) {
+      options.slidesDir = arg.slice('--slides-dir='.length);
+      continue;
+    }
+
+    if (arg === '--output') {
+      options.output = readOptionValue(args, i, '--output');
+      i += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--output=')) {
+      options.output = arg.slice('--output='.length);
+      continue;
+    }
+
+    if (arg === '--mode') {
+      options.mode = normalizeSlideMode(readOptionValue(args, i, '--mode'));
+      i += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--mode=')) {
+      options.mode = normalizeSlideMode(arg.slice('--mode='.length));
+      continue;
+    }
+
+    throw new Error(`Unknown option: ${arg}`);
+  }
+
+  if (typeof options.slidesDir !== 'string' || options.slidesDir.trim() === '') {
+    throw new Error('--slides-dir must be a non-empty string.');
+  }
+
+  options.slidesDir = options.slidesDir.trim();
+  options.mode = normalizeSlideMode(options.mode);
+  options.output = normalizeFigmaOutput(options.slidesDir, options.output);
+  return options;
+}
+
+function getHtmlSlides(slidesDir) {
+  if (!existsSync(slidesDir)) {
+    throw new Error(`Slides directory not found: ${slidesDir}`);
+  }
+
+  const files = readdirSync(slidesDir)
+    .filter((fileName) => SLIDE_FILE_PATTERN.test(fileName))
+    .sort(sortFigmaSlideFiles);
+
+  if (files.length === 0) {
+    throw new Error(`No slide-*.html files found in ${slidesDir}`);
+  }
+
+  return files;
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) {
+    printUsage();
+    return;
+  }
+
+  const slidesDir = resolve(process.cwd(), options.slidesDir);
+  const outputFile = resolve(process.cwd(), options.output);
+  const files = getHtmlSlides(slidesDir);
+
+  const pres = new PptxGenJS();
+  configureFigmaExportPresentation(pres, options.mode);
+
+  console.log(`Exporting ${files.length} slide(s) for Figma from ${slidesDir}`);
+
+  const browser = await launchBrowser(process.env.TMPDIR || '/tmp');
+  try {
+    for (const file of files) {
+      const filePath = resolve(slidesDir, file);
+      console.log(`  Processing: ${file}`);
+      await html2pptx(filePath, pres, { browser });
+    }
+  } finally {
+    await browser.close();
+  }
+
+  await ensureOutputDirectory(outputFile);
+  await pres.writeFile({ fileName: outputFile });
+
+  console.log(`\nSaved Figma-importable PPTX: ${outputFile}`);
+  console.log('\nFigma import caveats:');
+  for (const caveat of getFigmaImportCaveats()) {
+    console.log(`- ${caveat}`);
+  }
+  console.log('\nManual import: Figma Slides -> Import -> select the generated .pptx file.');
+}
+
+main().catch((error) => {
+  console.error(`[slides-grab] ${error.message}`);
+  process.exit(1);
+});

package/scripts/generate-image.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import {
+  DEFAULT_OPENAI_IMAGE_MODEL,
+  DEFAULT_OPENAI_IMAGE_BASE_URL,
+  DEFAULT_OPENAI_IMAGE_SIZE,
+  DEFAULT_CODEX_MODEL,
+  DEFAULT_IMAGE_PROVIDER,
+  DEFAULT_NANO_BANANA_ASPECT_RATIO,
+  DEFAULT_NANO_BANANA_IMAGE_SIZE,
+  DEFAULT_NANO_BANANA_MODEL,
+  IMAGE_PROVIDER_OPENAI,
+  IMAGE_PROVIDER_CODEX,
+  IMAGE_PROVIDER_NANO_BANANA,
+  buildOpenaiImageApiRequest,
+  buildOpenaiImageEndpoint,
+  buildNanoBananaApiRequest,
+  extractOpenaiGeneratedImage,
+  extractGeneratedImage,
+  generateOpenaiImage,
+  generateNanoBananaImage,
+  getOpenaiFallbackMessage,
+  getNanoBananaFallbackMessage,
+  getNanoBananaUsage,
+  normalizeImageProvider,
+  parseNanoBananaCliArgs,
+  resolveOpenaiApiKey,
+  resolveOpenaiBaseUrl,
+  resolveNanoBananaApiKey,
+  resolveNanoBananaOutputPath,
+  runNanoBananaCli,
+  saveNanoBananaImage,
+} from '../src/nano-banana.js';
+import {
+  CODEX_DEFAULT_MODEL,
+  CODEX_PROVIDER_AUTO,
+  CODEX_PROVIDER_CODEX_CLI,
+  CODEX_PROVIDER_PRIVATE_CODEX,
+  generateCodexImage,
+  getCodexFallbackMessage,
+  injectAspectRatioHint,
+  resolveCodexConfig,
+} from '../src/codex-imagen.js';
+import { writeImageNativeSlideWrapper } from '../src/image-native.js';
+
+export {
+  DEFAULT_OPENAI_IMAGE_BASE_URL,
+  DEFAULT_OPENAI_IMAGE_MODEL,
+  DEFAULT_OPENAI_IMAGE_SIZE,
+  DEFAULT_CODEX_MODEL,
+  DEFAULT_IMAGE_PROVIDER,
+  DEFAULT_NANO_BANANA_ASPECT_RATIO,
+  DEFAULT_NANO_BANANA_IMAGE_SIZE,
+  DEFAULT_NANO_BANANA_MODEL,
+  CODEX_DEFAULT_MODEL,
+  CODEX_PROVIDER_AUTO,
+  CODEX_PROVIDER_CODEX_CLI,
+  CODEX_PROVIDER_PRIVATE_CODEX,
+  IMAGE_PROVIDER_OPENAI,
+  IMAGE_PROVIDER_CODEX,
+  IMAGE_PROVIDER_NANO_BANANA,
+  buildOpenaiImageApiRequest,
+  buildOpenaiImageEndpoint,
+  buildNanoBananaApiRequest,
+  extractOpenaiGeneratedImage,
+  extractGeneratedImage,
+  generateOpenaiImage,
+  generateCodexImage,
+  generateNanoBananaImage,
+  getOpenaiFallbackMessage,
+  getCodexFallbackMessage,
+  getNanoBananaFallbackMessage,
+  getNanoBananaUsage,
+  injectAspectRatioHint,
+  normalizeImageProvider,
+  parseNanoBananaCliArgs,
+  resolveOpenaiApiKey,
+  resolveCodexConfig,
+  resolveOpenaiBaseUrl,
+  resolveNanoBananaApiKey,
+  resolveNanoBananaOutputPath,
+  runNanoBananaCli,
+  saveNanoBananaImage,
+};
+
+export async function main(argv = process.argv.slice(2), options = {}) {
+  const imageNative = argv.includes('--image-native');
+  const forwardedArgs = argv.filter((arg) => arg !== '--image-native');
+  const parsed = parseNanoBananaCliArgs(forwardedArgs);
+  const target = await runNanoBananaCli(forwardedArgs, options);
+  if (!imageNative || parsed.help || !target) return target;
+
+  const wrapper = await writeImageNativeSlideWrapper({
+    slidesDir: parsed.slidesDir,
+    slideName: parsed.name,
+    assetRef: target.relativeRef,
+    prompt: parsed.prompt,
+    provider: target.provider,
+    model: target.model,
+    title: parsed.name,
+  });
+  (options.stdout || process.stdout).write(`Created image-native slide wrapper: ${wrapper.slideFile}\n`);
+  return { ...target, imageNative: wrapper };
+}
+
+const isMain = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+
+if (isMain) {
+  main().catch((error) => {
+    console.error(`[slides-grab] ${error.message}`);
+    process.exit(1);
+  });
+}

package/scripts/generate-images.js

@@ -0,0 +1,164 @@
+#!/usr/bin/env node
+
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+import {
+  buildImageNativePrompt,
+  generateImageNativeSlides,
+  parseImageNativeOutline,
+} from '../src/image-native.js';
+import { IMAGE_PROVIDER_CODEX } from '../src/nano-banana.js';
+
+export {
+  buildImageNativePrompt,
+  generateImageNativeSlides,
+  parseImageNativeOutline,
+};
+
+function readOptionValue(argv, index, option) {
+  const value = argv[index + 1];
+  if (!value || value.startsWith('--')) throw new Error(`${option} is missing a value.`);
+  return value;
+}
+
+export function parseGenerateImagesCliArgs(argv) {
+  const parsed = {
+    outline: '',
+    slidesDir: 'slides',
+    templatePack: '',
+    provider: IMAGE_PROVIDER_CODEX,
+    model: '',
+    baseUrl: '',
+    help: false,
+  };
+
+  const args = Array.isArray(argv) ? [...argv] : [];
+  for (let i = 0; i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === '--help' || arg === '-h') {
+      parsed.help = true;
+      continue;
+    }
+    if (arg === '--outline') {
+      parsed.outline = readOptionValue(args, i, '--outline');
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--outline=')) {
+      parsed.outline = arg.slice('--outline='.length);
+      continue;
+    }
+    if (arg === '--slides-dir') {
+      parsed.slidesDir = readOptionValue(args, i, '--slides-dir');
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--slides-dir=')) {
+      parsed.slidesDir = arg.slice('--slides-dir='.length);
+      continue;
+    }
+    if (arg === '--template-pack') {
+      parsed.templatePack = readOptionValue(args, i, '--template-pack');
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--template-pack=')) {
+      parsed.templatePack = arg.slice('--template-pack='.length);
+      continue;
+    }
+    if (arg === '--provider') {
+      parsed.provider = readOptionValue(args, i, '--provider');
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--provider=')) {
+      parsed.provider = arg.slice('--provider='.length);
+      continue;
+    }
+    if (arg === '--model') {
+      parsed.model = readOptionValue(args, i, '--model');
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--model=')) {
+      parsed.model = arg.slice('--model='.length);
+      continue;
+    }
+    if (arg === '--base-url') {
+      parsed.baseUrl = readOptionValue(args, i, '--base-url');
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--base-url=')) {
+      parsed.baseUrl = arg.slice('--base-url='.length);
+      continue;
+    }
+    throw new Error(`Unknown option: ${arg}`);
+  }
+
+  if (parsed.help) return parsed;
+  for (const key of ['outline', 'slidesDir', 'provider']) {
+    if (typeof parsed[key] !== 'string' || parsed[key].trim() === '') {
+      throw new Error(`--${key.replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`)} must be a non-empty string.`);
+    }
+    parsed[key] = parsed[key].trim();
+  }
+  parsed.templatePack = parsed.templatePack.trim();
+  parsed.model = parsed.model.trim();
+  parsed.baseUrl = parsed.baseUrl.trim();
+  return parsed;
+}
+
+export function getGenerateImagesUsage() {
+  return [
+    'Usage: slides-grab generate-images --outline <path> [options]',
+    '',
+    'Generate image-native wrapper slides from a slide outline and optional template pack context.',
+    '',
+    'Options:',
+    '  --outline <path>        Markdown slide outline to convert',
+    '  --slides-dir <path>     Slide directory (default: slides)',
+    '  --template-pack <path>  Optional template-pack.json path; defaults to <slides-dir>/.slides-grab/template-pack.json when present',
+    '  --provider <name>       codex (default), openai, or nano-banana',
+    '  --model <id>            Optional provider model override',
+    '  --base-url <url>        OpenAI-compatible base URL for provider=openai',
+    '  -h, --help              Show this help text',
+    '',
+    'Default provider: codex (uses your local Codex ChatGPT login — no API key required).',
+  ].join('\n');
+}
+
+export async function main(argv = process.argv.slice(2), options = {}) {
+  const parsed = parseGenerateImagesCliArgs(argv);
+  const stdout = options.stdout || process.stdout;
+  if (parsed.help) {
+    stdout.write(`${getGenerateImagesUsage()}\n`);
+    return null;
+  }
+  const result = await generateImageNativeSlides({
+    outlinePath: parsed.outline,
+    slidesDir: parsed.slidesDir,
+    templatePackPath: parsed.templatePack,
+    provider: parsed.provider,
+    model: parsed.model,
+    baseUrl: parsed.baseUrl,
+    env: options.env || process.env,
+    fetchImpl: options.fetchImpl || globalThis.fetch,
+    generateImageImpl: options.generateImageImpl,
+  });
+  stdout.write(`Generated image-native slides: ${result.slides.length}\n`);
+  for (const slide of result.slides) {
+    stdout.write(`- ${slide.slideFile} -> ${slide.assetRef} (${slide.provider})\n`);
+  }
+  return result;
+}
+
+const isMain = process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+
+if (isMain) {
+  main().catch((error) => {
+    console.error(`[slides-grab] ${error.message}`);
+    process.exit(1);
+  });
+}