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

package/scripts/html2png.js

@@ -0,0 +1,246 @@
+#!/usr/bin/env node
+
+import { mkdir, readdir } from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import { join, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { chromium } from 'playwright';
+
+import { ensureSlidesPassValidation } from './validate-slides.js';
+
+const require = createRequire(import.meta.url);
+const {
+  getResolutionChoices,
+  getResolutionSize,
+  normalizeResolutionPreset,
+} = require('../src/export-resolution.cjs');
+const {
+  DEFAULT_SLIDE_MODE,
+  getSlideModeChoices,
+  getSlideModeConfig,
+  normalizeSlideMode,
+} = require('../src/slide-mode.cjs');
+
+const DEFAULT_SLIDES_DIR = 'slides';
+const DEFAULT_RESOLUTION = '2160p';
+const DEFAULT_CAPTURE_DEVICE_SCALE_FACTOR = 2;
+const SLIDE_FILE_PATTERN = /^slide-.*\.html$/i;
+const RENDER_SETTLE_MS = 120;
+
+function printUsage() {
+  process.stdout.write(
+    [
+      'Usage: node scripts/html2png.js [options]',
+      '',
+      'Options:',
+      `  --slides-dir <path>   Slide directory (default: ${DEFAULT_SLIDES_DIR})`,
+      '  --output-dir <path>   Output directory for PNG files (default: <slides-dir>/out-png)',
+      `  --slide-mode <mode>   Slide mode: ${getSlideModeChoices().join('|')} (default: ${DEFAULT_SLIDE_MODE})`,
+      `  --resolution <preset> Raster size preset: ${getResolutionChoices().join('|')}|4k (default: ${DEFAULT_RESOLUTION})`,
+      '  -h, --help            Show this help message',
+      '',
+      'Examples:',
+      '  node scripts/html2png.js --slides-dir slides',
+      '  node scripts/html2png.js --slides-dir cards --slide-mode card-news',
+      '  node scripts/html2png.js --slides-dir slides --resolution 1440p',
+    ].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 toSlideOrder(fileName) {
+  const match = fileName.match(/\d+/);
+  return match ? Number.parseInt(match[0], 10) : Number.POSITIVE_INFINITY;
+}
+
+function sortSlideFiles(a, b) {
+  const orderA = toSlideOrder(a);
+  const orderB = toSlideOrder(b);
+  if (orderA !== orderB) return orderA - orderB;
+  return a.localeCompare(b);
+}
+
+function parseCliArgs(args) {
+  const options = {
+    slidesDir: DEFAULT_SLIDES_DIR,
+    outputDir: '',
+    slideMode: DEFAULT_SLIDE_MODE,
+    resolution: DEFAULT_RESOLUTION,
+    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-dir') {
+      options.outputDir = readOptionValue(args, i, '--output-dir');
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--output-dir=')) {
+      options.outputDir = arg.slice('--output-dir='.length);
+      continue;
+    }
+
+    if (arg === '--slide-mode') {
+      options.slideMode = normalizeSlideMode(
+        readOptionValue(args, i, '--slide-mode'),
+        { optionName: '--slide-mode' },
+      );
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--slide-mode=')) {
+      options.slideMode = normalizeSlideMode(
+        arg.slice('--slide-mode='.length),
+        { optionName: '--slide-mode' },
+      );
+      continue;
+    }
+
+    if (arg === '--resolution') {
+      options.resolution = normalizeResolutionPreset(
+        readOptionValue(args, i, '--resolution'),
+        { allowEmpty: false },
+      );
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('--resolution=')) {
+      options.resolution = normalizeResolutionPreset(
+        arg.slice('--resolution='.length),
+        { allowEmpty: false },
+      );
+      continue;
+    }
+
+    throw new Error(`Unknown option: ${arg}`);
+  }
+
+  return options;
+}
+
+function computeDeviceScaleFactor(resolution, slideMode) {
+  const { framePx } = getSlideModeConfig(slideMode);
+  const target = getResolutionSize(resolution, slideMode);
+  if (!target) return DEFAULT_CAPTURE_DEVICE_SCALE_FACTOR;
+  return target.height / framePx.height;
+}
+
+async function discoverSlideFiles(slidesDir) {
+  const entries = await readdir(slidesDir);
+  return entries
+    .filter((name) => SLIDE_FILE_PATTERN.test(name))
+    .sort(sortSlideFiles);
+}
+
+async function renderSlideToPng(page, slidesDir, slideFile, outputPath) {
+  const url = pathToFileURL(join(slidesDir, slideFile)).href;
+  await page.goto(url, { waitUntil: 'load' });
+  await page.evaluate(async () => {
+    if (document.fonts?.ready) {
+      await document.fonts.ready;
+    }
+  });
+  await page.waitForTimeout(RENDER_SETTLE_MS);
+  await page.screenshot({ path: outputPath, fullPage: false });
+}
+
+async function main() {
+  let options;
+  try {
+    options = parseCliArgs(process.argv.slice(2));
+  } catch (error) {
+    process.stderr.write(`${error.message}\n`);
+    printUsage();
+    process.exit(2);
+  }
+
+  if (options.help) {
+    printUsage();
+    return;
+  }
+
+  const slidesDir = resolve(process.cwd(), options.slidesDir);
+  const outputDir = resolve(
+    process.cwd(),
+    options.outputDir || join(options.slidesDir, 'out-png'),
+  );
+
+  await ensureSlidesPassValidation(slidesDir, {
+    exportLabel: 'PNG export',
+    slideMode: options.slideMode,
+  });
+
+  const slideFiles = await discoverSlideFiles(slidesDir);
+  if (slideFiles.length === 0) {
+    process.stderr.write(`No slide-*.html files found in ${slidesDir}\n`);
+    process.exit(1);
+  }
+
+  await mkdir(outputDir, { recursive: true });
+
+  const { framePx } = getSlideModeConfig(options.slideMode);
+  const deviceScaleFactor = computeDeviceScaleFactor(
+    options.resolution,
+    options.slideMode,
+  );
+  const outputSize = getResolutionSize(options.resolution, options.slideMode) || {
+    width: framePx.width * deviceScaleFactor,
+    height: framePx.height * deviceScaleFactor,
+  };
+
+  process.stdout.write(
+    `Rendering ${slideFiles.length} slide(s) at ${outputSize.width}x${outputSize.height} (${options.slideMode})\n`,
+  );
+
+  const browser = await chromium.launch({ headless: true });
+  try {
+    const context = await browser.newContext({
+      viewport: { width: framePx.width, height: framePx.height },
+      deviceScaleFactor,
+    });
+    const page = await context.newPage();
+
+    for (const slideFile of slideFiles) {
+      const outputName = slideFile.replace(/\.html$/i, '.png');
+      const outputPath = join(outputDir, outputName);
+      await renderSlideToPng(page, slidesDir, slideFile, outputPath);
+      process.stdout.write(`  ${outputName}\n`);
+    }
+
+    await context.close();
+  } finally {
+    await browser.close();
+  }
+
+  process.stdout.write(`PNG export complete: ${outputDir}\n`);
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error?.stack || error?.message || error}\n`);
+  process.exit(1);
+});

package/scripts/html2pptx.js

@@ -0,0 +1,162 @@
+#!/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 { ensureOutputDirectory, 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, getSlideModeConfig, normalizeSlideMode } = require('../src/slide-mode.cjs');
+
+const DEFAULT_SLIDES_DIR = 'slides';
+const DEFAULT_OUTPUT = 'output.pptx';
+
+function printUsage() {
+  process.stdout.write(
+    [
+      'Usage: node scripts/html2pptx.js [options]',
+      '',
+      'Options:',
+      `  --slides-dir <path>  Slide directory (default: ${DEFAULT_SLIDES_DIR})`,
+      `  --output <path>      Output PPTX file (default: ${DEFAULT_OUTPUT})`,
+      `  --mode <mode>        Slide mode: ${getSlideModeChoices().join('|')} (default: ${DEFAULT_SLIDE_MODE})`,
+      '  -h, --help           Show this help message',
+      '',
+      'Experimental / unstable PPTX export. Treat output 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: DEFAULT_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.');
+  }
+
+  if (typeof options.output !== 'string' || options.output.trim() === '') {
+    throw new Error('--output must be a non-empty string.');
+  }
+
+  options.slidesDir = options.slidesDir.trim();
+  options.output = options.output.trim();
+  options.mode = normalizeSlideMode(options.mode);
+  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();
+  const { pptxSizeIn } = getSlideModeConfig(options.mode);
+  pres.defineLayout({
+    name: 'SLIDES_GRAB_HTML2PPTX',
+    width: pptxSizeIn.width,
+    height: pptxSizeIn.height,
+  });
+  pres.layout = 'SLIDES_GRAB_HTML2PPTX';
+
+  const browser = await launchBrowser(process.env.TMPDIR || '/tmp');
+  try {
+    for (const file of files) {
+      await html2pptx(resolve(slidesDir, file), pres, { browser, fitToLayout: true });
+    }
+  } finally {
+    await browser.close();
+  }
+
+  await ensureOutputDirectory(outputFile);
+  await pres.writeFile({ fileName: outputFile });
+  process.stdout.write(`Generated PPTX: ${outputFile}\n`);
+}
+
+main().catch((error) => {
+  console.error(`[slides-grab] ${error.message}`);
+  process.exit(1);
+});

package/scripts/import-template.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+import { resolve } from 'node:path';
+
+import {
+  TemplateImportError,
+  importTemplatePack,
+  parseImportTemplateArgs,
+} from '../src/template-import.js';
+
+function printUsage() {
+  process.stdout.write(
+    [
+      'Usage: node scripts/import-template.js [options]',
+      '',
+      'Import one or more template/reference source files into a local template pack',
+      'under <slides-dir>/.slides-grab/. HTML and image sources are analyzed locally',
+      '(no network, no LLM). PPTX/PDF are accepted as metadata/visual-reference',
+      'dispatch only; local rendering is not available and a warning is recorded.',
+      '',
+      'Options:',
+      '  --input <path>      Template source file (repeatable; .pptx, .pdf, .html, .htm,',
+      '                      or common image extensions).',
+      '  --slides-dir <path> Target slides directory (default: slides).',
+      '  --name <name>       Optional template pack display name.',
+      '  -h, --help          Show this help message.',
+      '',
+      'Examples:',
+      '  node scripts/import-template.js --input brand.html --input logo.png --slides-dir slides --name "Brand Pack"',
+    ].join('\n'),
+  );
+  process.stdout.write('\n');
+}
+
+async function main() {
+  const argv = process.argv.slice(2);
+  if (argv.includes('-h') || argv.includes('--help')) {
+    printUsage();
+    return;
+  }
+
+  let parsed;
+  try {
+    parsed = parseImportTemplateArgs(argv);
+  } catch (error) {
+    if (error instanceof TemplateImportError) {
+      console.error(`[slides-grab] ${error.message}`);
+      process.exitCode = 1;
+      return;
+    }
+    throw error;
+  }
+
+  if (parsed.inputs.length === 0) {
+    console.error('[slides-grab] At least one --input source is required.');
+    process.exitCode = 1;
+    return;
+  }
+  if (!parsed.slidesDir) {
+    console.error('[slides-grab] A --slides-dir is required.');
+    process.exitCode = 1;
+    return;
+  }
+
+  const result = await importTemplatePack({
+    inputs: parsed.inputs,
+    slidesDir: resolve(parsed.slidesDir),
+    name: parsed.name,
+  });
+
+  console.log(`Saved template pack: ${result.packPath}`);
+  console.log(`Wrote ${result.previewPaths.length} preview(s) under ${resolve(result.previewPaths[0] ?? '', '..').replace(/\/$/, '') || '<slides-dir>/.slides-grab/template-previews'}`);
+  for (const previewPath of result.previewPaths) {
+    console.log(`  - ${previewPath}`);
+  }
+}
+
+main().catch((error) => {
+  if (error instanceof TemplateImportError) {
+    console.error(`[slides-grab] ${error.message}`);
+    process.exitCode = 1;
+    return;
+  }
+  console.error(`[slides-grab] ${error.stack || error.message}`);
+  process.exitCode = 1;
+});

package/scripts/install-runtime.js

@@ -0,0 +1,216 @@
+#!/usr/bin/env node
+
+import { cp, mkdir, readdir, rm } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const packageRoot = resolve(__dirname, '..');
+const VALID_TARGETS = new Set(['all', 'codex', 'claude-code']);
+const VALID_SCOPES = new Set(['project', 'user']);
+const SKILL_NAMES = [
+  'slides-grab',
+  'slides-grab-plan',
+  'slides-grab-design',
+  'slides-grab-export',
+  'slides-grab-card-news',
+];
+
+function printUsage() {
+  process.stdout.write(
+    [
+      'Usage: slides-grab install-skills [options]',
+      '',
+      'Options:',
+      '  --target <target>       Runtime target: all|codex|claude-code (default: all)',
+      '  --runtime <target>      Alias for --target',
+      '  --scope <scope>         Install scope: project|user (default: project)',
+      '  --project-dir <path>    Project directory for project scope (default: cwd)',
+      '  --target-root <path>    Root directory for user-style installs',
+      '  --dry-run              Print planned writes without copying',
+      '  --json                 Print JSON result',
+      '  -h, --help             Show this help message',
+    ].join('\n'),
+  );
+  process.stdout.write('\n');
+}
+
+function parseArgs(args) {
+  const options = {
+    target: 'all',
+    scope: 'project',
+    projectDir: process.cwd(),
+    targetRoot: '',
+    dryRun: false,
+    json: false,
+    help: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === '-h' || arg === '--help') {
+      options.help = true;
+      continue;
+    }
+    if (arg === '--dry-run') {
+      options.dryRun = true;
+      continue;
+    }
+    if (arg === '--json') {
+      options.json = true;
+      continue;
+    }
+    if (OPTION_FIELDS.has(arg)) {
+      options[OPTION_FIELDS.get(arg)] = readOptionValue(args, index, arg);
+      index += 1;
+      continue;
+    }
+    const equalSignIndex = arg.indexOf('=');
+    if (equalSignIndex > -1) {
+      const name = arg.slice(0, equalSignIndex);
+      if (OPTION_FIELDS.has(name)) {
+        options[OPTION_FIELDS.get(name)] = arg.slice(equalSignIndex + 1);
+        continue;
+      }
+    }
+    throw new Error(`Unknown option: ${arg}`);
+  }
+
+  if (options.help) return options;
+
+  options.target = normalizeTarget(options.target);
+  options.scope = normalizeScope(options.scope);
+  options.projectDir = resolve(process.cwd(), options.projectDir);
+  options.targetRoot = options.targetRoot ? resolve(process.cwd(), options.targetRoot) : '';
+  return options;
+}
+
+const OPTION_FIELDS = new Map([
+  ['--target', 'target'],
+  ['--runtime', 'target'],
+  ['--scope', 'scope'],
+  ['--project-dir', 'projectDir'],
+  ['--target-root', 'targetRoot'],
+]);
+
+function readOptionValue(args, index, optionName) {
+  const value = args[index + 1];
+  if (!value || value.startsWith('-')) {
+    throw new Error(`Missing value for ${optionName}.`);
+  }
+  return value;
+}
+
+function normalizeTarget(value) {
+  const target = String(value || '').trim().toLowerCase();
+  if (!VALID_TARGETS.has(target)) {
+    throw new Error(`Unknown runtime target "${value}". Expected: all, codex, or claude-code.`);
+  }
+  return target;
+}
+
+function normalizeScope(value) {
+  const scope = String(value || '').trim().toLowerCase();
+  if (!VALID_SCOPES.has(scope)) {
+    throw new Error(`Unknown install scope "${value}". Expected: project or user.`);
+  }
+  return scope;
+}
+
+function selectedTargets(target) {
+  return target === 'all' ? ['codex', 'claude-code'] : [target];
+}
+
+function runtimeRoots(options, target) {
+  if (options.scope === 'project') {
+    return {
+      codex: {
+        skillsDir: join(options.projectDir, '.agents', 'skills'),
+        agentsDir: join(options.projectDir, '.codex', 'agents'),
+      },
+      'claude-code': {
+        skillsDir: join(options.projectDir, '.claude', 'skills'),
+        agentsDir: join(options.projectDir, '.claude', 'agents'),
+      },
+    }[target];
+  }
+
+  const root = options.targetRoot || homedir();
+  return {
+    codex: {
+      skillsDir: join(root, '.agents', 'skills'),
+      agentsDir: join(root, '.codex', 'agents'),
+    },
+    'claude-code': {
+      skillsDir: join(root, '.claude', 'skills'),
+      agentsDir: join(root, '.claude', 'agents'),
+    },
+  }[target];
+}
+
+async function copyDirectory(source, destination, dryRun) {
+  if (dryRun) return;
+  await rm(destination, { recursive: true, force: true });
+  await mkdir(dirname(destination), { recursive: true });
+  await cp(source, destination, { recursive: true });
+}
+
+async function installTarget(options, target) {
+  const roots = runtimeRoots(options, target);
+  const writes = [];
+  if (!options.dryRun) {
+    await mkdir(roots.skillsDir, { recursive: true });
+    await mkdir(roots.agentsDir, { recursive: true });
+  }
+
+  for (const skillName of SKILL_NAMES) {
+    const source = join(packageRoot, 'skills', skillName);
+    const destination = join(roots.skillsDir, skillName);
+    await copyDirectory(source, destination, options.dryRun);
+    writes.push(destination);
+  }
+
+  const adapterSourceDir = join(packageRoot, 'runtimes', target, 'agents');
+  const adapterFiles = await readdir(adapterSourceDir);
+  for (const adapterFile of adapterFiles) {
+    const source = join(adapterSourceDir, adapterFile);
+    const destination = join(roots.agentsDir, adapterFile);
+    await copyDirectory(source, destination, options.dryRun);
+    writes.push(destination);
+  }
+
+  return { target, skillsDir: roots.skillsDir, agentsDir: roots.agentsDir, writes };
+}
+
+export async function main(argv = process.argv.slice(2)) {
+  const options = parseArgs(argv);
+  if (options.help) {
+    printUsage();
+    return;
+  }
+
+  const installs = [];
+  for (const target of selectedTargets(options.target)) {
+    installs.push(await installTarget(options, target));
+  }
+
+  if (options.json) {
+    process.stdout.write(`${JSON.stringify({ installs, dryRun: options.dryRun }, null, 2)}\n`);
+    return;
+  }
+
+  for (const install of installs) {
+    const label = install.target === 'claude-code' ? 'Claude Code' : 'Codex';
+    process.stdout.write(`Installed slides-grab skills for ${label}\n`);
+    process.stdout.write(`  Skills: ${install.skillsDir}\n`);
+    process.stdout.write(`  Agents: ${install.agentsDir}\n`);
+  }
+}
+
+if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main().catch((error) => {
+    process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+    process.exit(1);
+  });
+}