takomi 2.1.37 → 2.1.39

package/plugins/takomi-flow/scripts/lib/report.mjs

@@ -0,0 +1,141 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { defaultRunsDir, ensureDir, resolvePath } from './paths.mjs';
+import { inspectRun, listRuns, resolveRun } from './inspect.mjs';
+
+export function createReport(args = {}) {
+  if (args.run) return createRunReport(args);
+  return createHistoryReport(args);
+}
+
+function createRunReport(args) {
+  const run = resolveRun(args.run);
+  const summary = inspectRun(args.run);
+  const catalog = readOptionalJson(path.join(run.runDir, 'assets.json'));
+  const markdown = renderRunReport(summary, run.runDir, catalog);
+  const reportPath = resolvePath(args.reportPath, path.join(run.runDir, 'report.md'));
+  writeText(reportPath, markdown);
+  return {
+    schemaVersion: 1,
+    status: 'ok',
+    mode: 'run',
+    runId: summary.runId,
+    reportPath,
+    markdown,
+  };
+}
+
+function createHistoryReport(args) {
+  const outputDir = resolvePath(args.outputDir, defaultRunsDir());
+  const history = listRuns(outputDir, args.limit || 10);
+  const markdown = renderHistoryReport(history);
+  const reportPath = resolvePath(args.reportPath, path.join(outputDir, 'takomi-flow-report.md'));
+  writeText(reportPath, markdown);
+  return {
+    schemaVersion: 1,
+    status: 'ok',
+    mode: 'history',
+    outputDir,
+    reportPath,
+    runCount: history.runs.length,
+    markdown,
+  };
+}
+
+function renderRunReport(summary, runDir, catalog) {
+  const lines = [
+    '# TakomiFlow Run Report',
+    '',
+    `Generated: ${new Date().toISOString()}`,
+    `Run: ${summary.runId || 'unknown'}`,
+    `Status: ${summary.status || 'unknown'}`,
+    `Command: ${summary.command || 'unknown'}`,
+    `Kind: ${summary.kind || 'unknown'}`,
+    `Project URL: ${summary.projectUrl || 'unknown'}`,
+    `Run directory: ${runDir}`,
+    `Metadata: ${summary.metadataPath || 'unknown'}`,
+    '',
+  ];
+  pushList(lines, 'Manual Actions', summary.manualActions);
+  pushList(lines, 'Errors', summary.errors);
+  pushList(lines, 'Screenshots', summary.screenshots);
+  pushList(lines, 'Assets', summary.assets);
+  if (catalog) pushCatalog(lines, catalog);
+  return `${lines.join('\n')}\n`;
+}
+
+function renderHistoryReport(history) {
+  const lines = [
+    '# TakomiFlow Run History',
+    '',
+    `Generated: ${new Date().toISOString()}`,
+    `Output directory: ${history.outputDir}`,
+    `Runs: ${history.runs.length}`,
+    '',
+  ];
+  if (!history.runs.length) {
+    lines.push('No TakomiFlow runs were found.', '');
+    return `${lines.join('\n')}\n`;
+  }
+  lines.push('| Run | Status | Command | Kind | Assets | Manual Actions | Errors |');
+  lines.push('| --- | --- | --- | --- | ---: | ---: | ---: |');
+  for (const run of history.runs) {
+    lines.push([
+      cell(run.runId),
+      cell(run.status),
+      cell(run.command),
+      cell(run.kind),
+      run.assets?.length || 0,
+      run.manualActions?.length || 0,
+      run.errors?.length || 0,
+    ].join(' | ').replace(/^/, '| ').replace(/$/, ' |'));
+  }
+  lines.push('');
+  lines.push('## Latest Details', '');
+  for (const run of history.runs.slice(0, 5)) {
+    lines.push(`### ${run.runId || 'unknown run'}`, '');
+    lines.push(`- Status: ${run.status || 'unknown'}`);
+    if (run.projectUrl) lines.push(`- Project URL: ${run.projectUrl}`);
+    lines.push(`- Metadata: ${run.metadataPath || 'unknown'}`);
+    if (run.errors?.length) lines.push(`- Errors: ${run.errors.join('; ')}`);
+    if (run.manualActions?.length) lines.push(`- Manual actions: ${run.manualActions.join('; ')}`);
+    lines.push('');
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+function pushList(lines, title, values = []) {
+  lines.push(`## ${title}`, '');
+  if (!values.length) {
+    lines.push('None.', '');
+    return;
+  }
+  for (const value of values) lines.push(`- ${value}`);
+  lines.push('');
+}
+
+function pushCatalog(lines, catalog) {
+  lines.push('## Asset Catalog', '');
+  lines.push(`Catalog: ${catalog.assetCatalogPath || catalog.catalogPath || 'unknown'}`);
+  lines.push(`Assets cataloged: ${catalog.assets?.length || 0}`);
+  const frames = (catalog.assets || []).flatMap(asset => asset.frames || []);
+  if (frames.length) {
+    lines.push('', '### Review Frames', '');
+    for (const frame of frames) lines.push(`- ${frame}`);
+  }
+  lines.push('');
+}
+
+function readOptionalJson(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  return { catalogPath: filePath, ...JSON.parse(fs.readFileSync(filePath, 'utf8')) };
+}
+
+function writeText(filePath, text) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, text);
+}
+
+function cell(value) {
+  return String(value || '').replace(/\|/g, '\\|');
+}

package/plugins/takomi-flow/scripts/lib/request-validator.mjs

@@ -0,0 +1,58 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { loadCapabilities } from './capabilities.mjs';
+import { normalizeRequest } from './request.mjs';
+
+export function validateRequestFile(requestPath) {
+  if (!requestPath) throw new Error('validate requires --request <path>');
+  const absolutePath = path.resolve(requestPath);
+  const raw = JSON.parse(fs.readFileSync(absolutePath, 'utf8'));
+  return validateRequest(raw, absolutePath);
+}
+
+export function validateRequest(raw, requestPath = undefined) {
+  const capabilities = loadCapabilities();
+  const errors = [];
+  const warnings = [];
+  let normalized;
+  try {
+    normalized = normalizeRequest(raw);
+  } catch (error) {
+    return {
+      schemaVersion: 1,
+      status: 'failed',
+      requestPath,
+      errors: [error.message],
+      warnings,
+    };
+  }
+  if (!capabilities.kinds.includes(normalized.kind)) {
+    errors.push(`Unsupported kind: ${normalized.kind}`);
+  }
+  const allowedModes = capabilities.modes[normalized.kind] || [];
+  if (normalized.mode && !allowedModes.includes(normalized.mode)) {
+    warnings.push(`Mode "${normalized.mode}" is not listed for kind "${normalized.kind}".`);
+  }
+  if (normalized.variations > capabilities.variations.max) {
+    warnings.push(`Variations ${normalized.variations} exceeds listed max ${capabilities.variations.max}.`);
+  }
+  if (normalized.aspectRatio && !capabilities.aspectRatios.includes(normalized.aspectRatio)) {
+    warnings.push(`Aspect ratio "${normalized.aspectRatio}" is not in listed options.`);
+  }
+  for (const asset of normalized.sourceAssets) {
+    if (!fs.existsSync(path.resolve(asset))) {
+      errors.push(`Source asset does not exist: ${asset}`);
+    }
+  }
+  if (!normalized.allowSpend) {
+    warnings.push('Spend guard is off. Generation will not submit until allowSpend=true or TAKOMI_FLOW_ALLOW_SPEND=true.');
+  }
+  return {
+    schemaVersion: 1,
+    status: errors.length ? 'failed' : 'ok',
+    requestPath,
+    normalized,
+    errors,
+    warnings,
+  };
+}

package/plugins/takomi-flow/scripts/lib/request.mjs

@@ -0,0 +1,55 @@
+import path from 'node:path';
+import { defaultRunsDir, ensureDir, timestampId, writeJson } from './paths.mjs';
+
+const VALID_KINDS = new Set(['video', 'image']);
+
+export function normalizeRequest(input) {
+  const kind = String(input.kind || 'video').toLowerCase();
+  if (!VALID_KINDS.has(kind)) {
+    throw new Error(`Invalid kind "${kind}". Expected video or image.`);
+  }
+  const prompt = String(input.prompt || '').trim();
+  if (!prompt) {
+    throw new Error('A non-empty prompt is required.');
+  }
+  const variations = Math.max(1, Number.parseInt(input.variations || '1', 10) || 1);
+  return {
+    schemaVersion: 1,
+    kind,
+    prompt,
+    variations,
+    aspectRatio: input.aspectRatio || input['aspect-ratio'] || undefined,
+    durationSeconds: toOptionalNumber(input.durationSeconds || input.duration),
+    mode: input.mode || (kind === 'video' ? 'text-to-video' : 'text-to-image'),
+    modelHint: input.modelHint || input.model || 'best-available',
+    outputDir: path.resolve(input.outputDir || input['output-dir'] || defaultRunsDir()),
+    allowSpend: Boolean(input.allowSpend || input['allow-spend'] || false),
+    extractFrames: Math.max(0, Number.parseInt(input.extractFrames || input['extract-frames'] || '0', 10) || 0),
+    sourceAssets: normalizeList(input.sourceAssets || input.assets),
+    notes: input.notes || undefined,
+  };
+}
+
+export function createPreparedRequest(args) {
+  const request = normalizeRequest(args);
+  const requestDir = ensureDir(path.join(request.outputDir, 'requests'));
+  const requestPath = path.join(requestDir, `${timestampId('request')}.json`);
+  writeJson(requestPath, { ...request, status: 'prepared', requestPath });
+  return { request, requestPath };
+}
+
+export function canSpend(request) {
+  return request.allowSpend === true || process.env.TAKOMI_FLOW_ALLOW_SPEND === 'true';
+}
+
+function toOptionalNumber(value) {
+  if (value === undefined || value === null || value === '') return undefined;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : undefined;
+}
+
+function normalizeList(value) {
+  if (!value) return [];
+  if (Array.isArray(value)) return value;
+  return String(value).split(',').map(item => item.trim()).filter(Boolean);
+}

package/plugins/takomi-flow/scripts/lib/resource-files.mjs

@@ -0,0 +1,69 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const PLUGIN_ROOT = path.resolve(MODULE_DIR, '..', '..');
+
+export const RESOURCES = [
+  {
+    name: 'takomi-flow-contract',
+    uri: 'takomi-flow://contract',
+    file: path.join(PLUGIN_ROOT, 'references', 'flow-provider-contract.md'),
+    mimeType: 'text/markdown',
+    description: 'TakomiFlow provider contract and agent workflow.',
+  },
+  {
+    name: 'takomi-flow-capabilities',
+    uri: 'takomi-flow://capabilities',
+    file: path.join(PLUGIN_ROOT, 'assets', 'capabilities.json'),
+    mimeType: 'application/json',
+    description: 'Machine-readable TakomiFlow capabilities.',
+  },
+  {
+    name: 'takomi-flow-examples',
+    uri: 'takomi-flow://examples',
+    file: path.join(PLUGIN_ROOT, 'assets', 'examples.json'),
+    mimeType: 'application/json',
+    description: 'Machine-readable TakomiFlow request and handoff examples.',
+  },
+  {
+    name: 'takomi-flow-request-schema',
+    uri: 'takomi-flow://schemas/request',
+    file: path.join(PLUGIN_ROOT, 'assets', 'request.schema.json'),
+    mimeType: 'application/schema+json',
+    description: 'JSON Schema for TakomiFlow request files.',
+  },
+  {
+    name: 'takomi-flow-result-schema',
+    uri: 'takomi-flow://schemas/result',
+    file: path.join(PLUGIN_ROOT, 'assets', 'result.schema.json'),
+    mimeType: 'application/schema+json',
+    description: 'JSON Schema for TakomiFlow run result metadata.',
+  },
+  {
+    name: 'takomi-flow-collection-schema',
+    uri: 'takomi-flow://schemas/collection',
+    file: path.join(PLUGIN_ROOT, 'assets', 'collection.schema.json'),
+    mimeType: 'application/schema+json',
+    description: 'JSON Schema for TakomiFlow collection manifests.',
+  },
+  {
+    name: 'takomi-flow-video-template',
+    uri: 'takomi-flow://templates/video',
+    file: path.join(PLUGIN_ROOT, 'assets', 'templates', 'video-request.json'),
+    mimeType: 'application/json',
+    description: 'Video request template.',
+  },
+  {
+    name: 'takomi-flow-image-template',
+    uri: 'takomi-flow://templates/image',
+    file: path.join(PLUGIN_ROOT, 'assets', 'templates', 'image-request.json'),
+    mimeType: 'application/json',
+    description: 'Image request template.',
+  },
+];
+
+export function readResourceFile(filePath) {
+  return fs.readFileSync(filePath, 'utf8');
+}

package/plugins/takomi-flow/scripts/lib/result.mjs

@@ -0,0 +1,31 @@
+import path from 'node:path';
+import { ensureDir, timestampId, writeJson } from './paths.mjs';
+
+export function createRun(requestOrArgs, label = 'flow') {
+  const outputDir = path.resolve(requestOrArgs.outputDir || requestOrArgs['output-dir']);
+  const runId = timestampId(label);
+  const runDir = ensureDir(path.join(outputDir, runId));
+  const downloadsDir = ensureDir(path.join(runDir, 'downloads'));
+  const screenshotsDir = ensureDir(path.join(runDir, 'screenshots'));
+  return { runId, runDir, downloadsDir, screenshotsDir };
+}
+
+export function baseResult(status, run, data = {}) {
+  return {
+    schemaVersion: 1,
+    status,
+    runId: run.runId,
+    assets: [],
+    screenshots: [],
+    errors: [],
+    manualActions: [],
+    ...data,
+    metadataPath: path.join(run.runDir, 'run.json'),
+  };
+}
+
+export function saveResult(run, result) {
+  const finalResult = { ...result, metadataPath: path.join(run.runDir, 'run.json') };
+  writeJson(finalResult.metadataPath, finalResult);
+  return finalResult;
+}

package/plugins/takomi-flow/scripts/lib/review.mjs

@@ -0,0 +1,44 @@
+import { inspectRun, resolveRun } from './inspect.mjs';
+import { catalogAssets } from './media.mjs';
+import { createReport } from './report.mjs';
+
+export async function reviewRun(args = {}) {
+  if (!args.run) throw new Error('review requires --run <run.json|run-dir>');
+  const summary = inspectRun(args.run);
+  const run = resolveRun(args.run);
+  const catalog = await catalogAssets(run, run.data.assets || [], {
+    frames: args.frames || 0,
+  });
+  const report = createReport({
+    run: args.run,
+    reportPath: args.reportPath,
+  });
+  return {
+    schemaVersion: 1,
+    status: reviewStatus(summary, catalog),
+    runId: summary.runId,
+    runDir: run.runDir,
+    summary,
+    catalog,
+    reportPath: report.reportPath,
+    nextActions: nextActions(summary, catalog),
+  };
+}
+
+function reviewStatus(summary, catalog) {
+  if (summary.errors?.length) return 'attention_required';
+  if (summary.manualActions?.length) return 'manual_action_required';
+  if (catalog.assets?.some(asset => asset.errors?.length || !asset.exists)) return 'attention_required';
+  if (catalog.assets?.length) return 'review_ready';
+  return summary.status || 'unknown';
+}
+
+function nextActions(summary, catalog) {
+  const actions = [];
+  if (summary.errors?.length) actions.push('Review run errors before reusing assets.');
+  if (summary.manualActions?.length) actions.push(...summary.manualActions);
+  if (catalog.assets?.some(asset => asset.frames?.length)) actions.push('Review extracted frames for video quality.');
+  if (catalog.assets?.length) actions.push('Use reportPath for the human handoff.');
+  if (!catalog.assets?.length) actions.push('No assets were cataloged; inspect screenshots and run metadata.');
+  return actions;
+}

package/plugins/takomi-flow/scripts/lib/selftest.mjs

@@ -0,0 +1,153 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { defaultRunsDir, ensureDir, readJson, writeJson } from './paths.mjs';
+import { runDoctor } from './doctor.mjs';
+import { loadCapabilities } from './capabilities.mjs';
+import { loadTemplate } from './templates.mjs';
+import { createPreparedRequest } from './request.mjs';
+import { validateRequestFile } from './request-validator.mjs';
+import { createRun, saveResult, baseResult } from './result.mjs';
+import { catalogAssets } from './media.mjs';
+import { createReport } from './report.mjs';
+import { runWorkflow } from './workflow.mjs';
+import { reviewRun } from './review.mjs';
+import { runAudit } from './audit.mjs';
+import { collectRun } from './collect.mjs';
+import { loadExamples } from './examples.mjs';
+import { createAgentPlan } from './agent-plan.mjs';
+
+const execFileAsync = promisify(execFile);
+
+export async function runSelfTest(options = {}) {
+  const outputDir = path.resolve(options.outputDir || defaultRunsDir(), 'selftest');
+  ensureDir(outputDir);
+  const steps = [];
+  steps.push(await step('doctor', () => runDoctor({ outputDir })));
+  steps.push(await step('audit', () => runAudit({ outputDir })));
+  steps.push(await step('capabilities', () => loadCapabilities()));
+  steps.push(await step('examples', () => loadExamples('cinematic-video')));
+  steps.push(await step('agentPlan', () => createAgentPlan({
+    kind: 'video',
+    prompt: 'TakomiFlow self-test planned video prompt',
+    variations: 2,
+    aspectRatio: '16:9',
+    durationSeconds: 8,
+    extractFrames: 2,
+  })));
+  steps.push(await step('videoTemplate', () => loadTemplate('video')));
+  steps.push(await step('imageTemplate', () => loadTemplate('image')));
+  const prepared = await step('prepareAndValidate', () => prepareAndValidate(outputDir));
+  steps.push(prepared);
+  steps.push(await step('workflow', () => noSpendWorkflow(outputDir)));
+  steps.push(await step('settingsPlan', () => verifySettingsPlan(outputDir)));
+  steps.push(await step('guardedGenerate', () => guardedGenerate(prepared.data?.requestPath)));
+  const catalog = await step('assetCatalog', () => syntheticAssetCatalog(outputDir));
+  steps.push(catalog);
+  steps.push(await step('report', () => selftestReport(catalog.data?.runDir)));
+  steps.push(await step('review', () => selftestReview(catalog.data?.runDir)));
+  steps.push(await step('collect', () => selftestCollect(catalog.data?.runDir, outputDir)));
+  const failed = steps.some(item => item.status !== 'ok');
+  return {
+    schemaVersion: 1,
+    status: failed ? 'failed' : 'ok',
+    outputDir,
+    steps,
+  };
+}
+
+async function step(name, fn) {
+  try {
+    return { name, status: 'ok', data: await fn() };
+  } catch (error) {
+    return { name, status: 'failed', error: error.message };
+  }
+}
+
+function prepareAndValidate(outputDir) {
+  const { requestPath, request } = createPreparedRequest({
+    kind: 'video',
+    prompt: 'TakomiFlow self-test video prompt',
+    variations: 1,
+    'output-dir': outputDir,
+    'extract-frames': 2,
+  });
+  return { requestPath, request, validation: validateRequestFile(requestPath) };
+}
+
+function guardedGenerate(requestPath) {
+  if (!requestPath) throw new Error('No request path available.');
+  const request = readJson(requestPath);
+  if (request.allowSpend) throw new Error('Self-test request unexpectedly allows spend.');
+  return {
+    requestPath,
+    wouldSubmit: false,
+    reason: 'allowSpend is false, so generate must be blocked by the spend guard.',
+  };
+}
+
+async function noSpendWorkflow(outputDir) {
+  return runWorkflow({
+    kind: 'image',
+    prompt: 'TakomiFlow self-test image prompt',
+    variations: 1,
+    outputDir,
+  });
+}
+
+async function verifySettingsPlan(outputDir) {
+  const result = await runWorkflow({
+    kind: 'video',
+    prompt: 'TakomiFlow settings plan prompt',
+    variations: 2,
+    aspectRatio: '16:9',
+    durationSeconds: 8,
+    outputDir,
+  });
+  if (!result.settingsPlan?.selectorDependent?.length) {
+    throw new Error('Expected selector-dependent settings in workflow result.');
+  }
+  return result.settingsPlan;
+}
+
+async function syntheticAssetCatalog(outputDir) {
+  const run = createRun({ outputDir }, 'selftest-asset');
+  const videoPath = path.join(run.downloadsDir, 'sample.mp4');
+  await execFileAsync('ffmpeg', [
+    '-y',
+    '-f', 'lavfi',
+    '-i', 'testsrc=duration=2:size=320x180:rate=24',
+    '-c:v', 'libx264',
+    '-pix_fmt', 'yuv420p',
+    videoPath,
+  ]);
+  const result = baseResult('downloaded', run, {
+    command: 'selftest',
+    kind: 'video',
+    assets: [videoPath],
+  });
+  saveResult(run, result);
+  const catalog = await catalogAssets(run, [videoPath], { frames: 2 });
+  return { ...catalog, runDir: run.runDir };
+}
+
+function selftestReport(runDir) {
+  if (!runDir) throw new Error('No self-test run directory available.');
+  return createReport({ run: runDir });
+}
+
+async function selftestReview(runDir) {
+  if (!runDir) throw new Error('No self-test run directory available.');
+  return reviewRun({ run: runDir, frames: 2 });
+}
+
+async function selftestCollect(runDir, outputDir) {
+  if (!runDir) throw new Error('No self-test run directory available.');
+  return collectRun({
+    run: runDir,
+    targetDir: path.join(outputDir, 'collected'),
+    frames: 2,
+    includeFrames: true,
+  });
+}

package/plugins/takomi-flow/scripts/lib/settings-plan.mjs

@@ -0,0 +1,39 @@
+export function createSettingsPlan(request) {
+  const requested = {
+    kind: request.kind,
+    mode: request.mode,
+    variations: request.variations,
+    aspectRatio: request.aspectRatio,
+    durationSeconds: request.durationSeconds,
+    modelHint: request.modelHint,
+    extractFrames: request.extractFrames,
+    sourceAssets: request.sourceAssets || [],
+  };
+  const automatic = ['prompt', 'download folder', 'metadata', 'asset catalog'];
+  if (request.extractFrames > 0) automatic.push('video review frame extraction after download');
+  return {
+    schemaVersion: 1,
+    requested,
+    automatic,
+    selectorDependent: selectorDependent(request),
+    notes: [
+      'Prompt submission and downloads are automated through public Flow UI selectors.',
+      'Visual settings remain explicit in metadata until live Flow controls are observed and selector coverage is tuned.',
+    ],
+  };
+}
+
+function selectorDependent(request) {
+  const items = [];
+  if (request.mode) items.push({ field: 'mode', value: request.mode });
+  if (request.aspectRatio) items.push({ field: 'aspectRatio', value: request.aspectRatio });
+  if (request.durationSeconds) items.push({ field: 'durationSeconds', value: request.durationSeconds });
+  if (request.modelHint && request.modelHint !== 'best-available') {
+    items.push({ field: 'modelHint', value: request.modelHint });
+  }
+  if (request.sourceAssets?.length) {
+    items.push({ field: 'sourceAssets', value: request.sourceAssets });
+  }
+  if (request.variations > 1) items.push({ field: 'variations', value: request.variations });
+  return items;
+}

package/plugins/takomi-flow/scripts/lib/templates.mjs

@@ -0,0 +1,37 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ensureDir, writeJson } from './paths.mjs';
+
+const MODULE_DIR = path.dirname(fileURLToPath(import.meta.url));
+const PLUGIN_ROOT = path.resolve(MODULE_DIR, '..', '..');
+const TEMPLATE_DIR = path.join(PLUGIN_ROOT, 'assets', 'templates');
+const TEMPLATES = {
+  video: 'video-request.json',
+  image: 'image-request.json',
+};
+
+export function listTemplates() {
+  return Object.keys(TEMPLATES).map(kind => ({ kind, path: templatePath(kind) }));
+}
+
+export function loadTemplate(kind) {
+  const filePath = templatePath(kind);
+  return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+}
+
+export function writeTemplate(kind, outputDir) {
+  const template = loadTemplate(kind);
+  const destinationDir = ensureDir(path.resolve(outputDir));
+  const destination = path.join(destinationDir, TEMPLATES[kind]);
+  writeJson(destination, template);
+  return { kind, destination, template };
+}
+
+function templatePath(kind) {
+  const fileName = TEMPLATES[String(kind || '').toLowerCase()];
+  if (!fileName) {
+    throw new Error(`Unknown template "${kind}". Expected image or video.`);
+  }
+  return path.join(TEMPLATE_DIR, fileName);
+}