@birdapi/velinstyle 1.2.1 → 1.3.0

package/packages/velinstyle-motion/src/providers-catalog.js

@@ -0,0 +1,44 @@
+/**
+ * Motion engines / AI providers catalog for `velinstyle motion providers`.
+ */
+import {
+  PIXVERSE_AFFILIATE_URL,
+  formatPixVerseSignupHelp,
+} from './ai/providers/pixverse-setup.js';
+
+export function listMotionProviders() {
+  return [
+    {
+      id: 'local',
+      kind: 'local',
+      title: 'LOCAL',
+      description: 'Kostenlos, lokal',
+      requiresApiKey: false,
+    },
+    {
+      id: 'pixverse',
+      kind: 'ai',
+      title: 'PIXVERSE',
+      description: 'AI Image-to-Video',
+      requiresApiKey: true,
+      setupCommand: 'velinstyle motion setup pixverse',
+      signupUrl: PIXVERSE_AFFILIATE_URL,
+      note: 'API erforderlich',
+    },
+  ];
+}
+
+/**
+ * Human-readable providers listing (German, matches plan copy).
+ */
+export function formatMotionProvidersText() {
+  return [
+    'VelinStyle Motion Providers',
+    '',
+    'LOCAL',
+    'Kostenlos, lokal',
+    '',
+    formatPixVerseSignupHelp(),
+    '',
+  ].join('\n');
+}

package/packages/velinstyle-motion/src/registry/presets.js

@@ -0,0 +1,25 @@
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const ROOT = dirname(fileURLToPath(import.meta.url));
+const DATA = JSON.parse(readFileSync(join(ROOT, 'presets.json'), 'utf8'));
+
+export function listClipPresets() {
+  return DATA.presets.slice();
+}
+
+export function getClipPreset(id) {
+  if (!id) return null;
+  const key = String(id).toLowerCase();
+  return DATA.presets.find((p) => p.id === key || p.title.toLowerCase() === key) || null;
+}
+
+export function listWizardChoices() {
+  return listClipPresets().map((p, i) => ({
+    index: i + 1,
+    id: p.id,
+    title: p.title,
+    engine: p.engine,
+  }));
+}

package/packages/velinstyle-motion/src/registry/presets.json

@@ -0,0 +1,85 @@
+{
+  "schema": "velinstyle.motion.clip.presets",
+  "version": 1,
+  "presets": [
+    {
+      "id": "soft-zoom",
+      "title": "Soft Zoom",
+      "engine": "local",
+      "effects": ["zoom"],
+      "durationMs": 4000,
+      "easing": "ease-in-out",
+      "status": "stable",
+      "description": "Gentle Ken Burns zoom-in on the image."
+    },
+    {
+      "id": "cinematic",
+      "title": "Cinematic",
+      "engine": "local",
+      "effects": ["pan", "zoom"],
+      "durationMs": 5000,
+      "easing": "ease-in-out",
+      "status": "stable",
+      "description": "Slow pan with subtle zoom for hero/showcase frames."
+    },
+    {
+      "id": "atelier",
+      "title": "Atelier Reveal",
+      "engine": "local",
+      "effects": ["intro", "soft-zoom"],
+      "durationMs": 4500,
+      "easing": "cubic-bezier(0.22, 1, 0.36, 1)",
+      "status": "stable",
+      "description": "Atelier-style fade-in then soft zoom — good for batch reels."
+    },
+    {
+      "id": "rotate",
+      "title": "Rotate",
+      "engine": "local",
+      "effects": ["rotate"],
+      "durationMs": 4000,
+      "easing": "ease-in-out",
+      "status": "stable",
+      "description": "Subtle rotation with settle."
+    },
+    {
+      "id": "particle-reveal",
+      "title": "Particle Reveal",
+      "engine": "local",
+      "effects": ["particles", "fade"],
+      "durationMs": 5000,
+      "easing": "ease-out",
+      "status": "stable",
+      "description": "Particle overlay fade revealing the image."
+    },
+    {
+      "id": "rotate-explode",
+      "title": "Rotate + Explosion",
+      "engine": "local",
+      "effects": ["rotate", "particles"],
+      "durationMs": 4500,
+      "easing": "cubic-bezier(0.34, 1.56, 0.64, 1)",
+      "status": "stable",
+      "description": "Spin then particle burst."
+    },
+    {
+      "id": "ai-reveal",
+      "title": "AI Animation",
+      "engine": "ai",
+      "effects": ["ai"],
+      "durationMs": 5000,
+      "easing": null,
+      "status": "beta",
+      "description": "Provider-driven image-to-video (PixVerse by default). Requires credits."
+    },
+    {
+      "id": "custom-prompt",
+      "title": "Eigener Prompt / Custom Prompt",
+      "engine": "hybrid",
+      "effects": ["mini-prompt"],
+      "durationMs": 5000,
+      "status": "beta",
+      "description": "Mini-prompt → structured motion profile (local or AI)."
+    }
+  ]
+}

package/packages/velinstyle-motion/src/ux/cost-gate.js

@@ -0,0 +1,37 @@
+/**
+ * Cost confirmation gate before AI jobs.
+ */
+import { createInterface } from 'readline';
+
+/**
+ * @param {object} opts
+ * @param {string} opts.provider
+ * @param {string} opts.model
+ * @param {number} opts.duration
+ * @param {string} opts.quality
+ * @param {boolean} [opts.yes]
+ * @param {boolean} [opts.quiet]
+ */
+export async function confirmAiCost(opts) {
+  if (opts.yes || opts.quiet || !process.stdin.isTTY) return true;
+
+  const lines = [
+    '',
+    `${opts.provider || 'AI'}`,
+    `Modell: ${opts.model}`,
+    `Dauer: ${opts.duration} Sekunden`,
+    `Qualität: ${opts.quality}`,
+    '',
+    `Dieser Auftrag verwendet ${opts.provider || 'Provider'}-Credits.`,
+    '',
+  ];
+  process.stdout.write(lines.join('\n'));
+
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  const answer = await new Promise((resolve) => {
+    rl.question('Starten? [J/n] ', resolve);
+  });
+  rl.close();
+  const a = (answer || 'j').trim().toLowerCase();
+  return a === '' || a === 'j' || a === 'y' || a === 'ja' || a === 'yes';
+}

package/packages/velinstyle-motion/src/ux/pixverse-gate.js

@@ -0,0 +1,153 @@
+/**
+ * Ensure PixVerse API key before AI jobs.
+ * Hard rules: --yes → no browser/prompt; setup_completed → no auto affiliate reopen.
+ * Affiliate-first: open partner link / copy link / enter key — never bare platform bypass.
+ */
+import { createInterface } from 'readline';
+import {
+  hasPixVerseApiKey,
+  isPixVerseSetupCompleted,
+  loadMotionConfig,
+  loadMotionDotEnv,
+  markPixVerseSetupCompleted,
+} from '../config.js';
+import {
+  PIXVERSE_DOCS_URL,
+  PIXVERSE_KEY_MISSING_HINT,
+  copyPixVersePartnerLink,
+  formatPixVerseSignupHelp,
+  formatPixVerseTrackerHint,
+  runPixVersePartnerOpenFlow,
+  promptAndSaveApiKey,
+} from '../ai/providers/pixverse-setup.js';
+
+function ask(rl, q) {
+  return new Promise((resolve) => {
+    rl.question(q, resolve);
+  });
+}
+
+function writeCopied(result) {
+  if (result.ok) {
+    process.stdout.write(`\nPartnerlink kopiert:\n${result.url}\n`);
+  } else {
+    process.stdout.write(`\nPartnerlink (manuell kopieren):\n${result.url}\n`);
+  }
+  process.stdout.write(`\n${formatPixVerseTrackerHint()}\n`);
+}
+
+/**
+ * @param {object} opts
+ * @param {string} [opts.cwd]
+ * @param {boolean} [opts.yes]
+ * @param {boolean} [opts.quiet]
+ * @param {boolean} [opts.json]
+ * @param {boolean} [opts.dryRun]
+ * @param {(url: string, o?: object) => object|string} [opts.openImpl]
+ * @returns {Promise<{ ok: boolean, dryRun?: boolean }>}
+ */
+export async function ensurePixVerseReady(opts = {}) {
+  const cwd = opts.cwd || process.cwd();
+  loadMotionDotEnv(cwd);
+  loadMotionConfig(cwd);
+
+  if (hasPixVerseApiKey(undefined, cwd)) {
+    return { ok: true };
+  }
+
+  const nonInteractive = Boolean(opts.yes || opts.quiet || opts.json || !process.stdin.isTTY);
+
+  if (opts.dryRun || process.env.VELIN_MOTION_DRY_RUN === '1') {
+    return { ok: true, dryRun: true };
+  }
+
+  if (nonInteractive) {
+    throw new Error(PIXVERSE_KEY_MISSING_HINT);
+  }
+
+  const completed = isPixVerseSetupCompleted(cwd);
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+
+  try {
+    if (!completed) {
+      process.stdout.write(`\nVelinStyle Motion\n\n${formatPixVerseSignupHelp()}\n\n`);
+      const choice = (await ask(rl, 'Auswahl [1/2/3/4]: ')).trim();
+      if (choice === '4' || choice.toLowerCase() === 'q' || choice.toLowerCase() === 'c') {
+        throw new Error('Abgebrochen');
+      }
+      if (choice === '1' || choice === '') {
+        const outcome = await runPixVersePartnerOpenFlow({
+          rl,
+          openImpl: opts.openImpl,
+          spawnImpl: opts.spawnImpl,
+          copyImpl: opts.copyImpl,
+          forceFail: opts.forceFail,
+        });
+        if (outcome === 'aborted') throw new Error('Abgebrochen');
+        process.stdout.write(
+          '\nRichte den API-Zugang im PixVerse-Dashboard ein, dann füge den Key hier ein.\n',
+        );
+        await promptAndSaveApiKey({ cwd, rl });
+        markPixVerseSetupCompleted(cwd);
+        return { ok: true };
+      }
+      if (choice === '2') {
+        writeCopied(copyPixVersePartnerLink({ copyImpl: opts.copyImpl }));
+        process.stdout.write(
+          '\nÖffne den kopierten Partnerlink, richte den API-Zugang ein, dann Key hier einfügen.\n',
+        );
+        await promptAndSaveApiKey({ cwd, rl });
+        markPixVerseSetupCompleted(cwd);
+        return { ok: true };
+      }
+      if (choice === '3') {
+        process.stdout.write(
+          '\nAPI-Key aus dem PixVerse-Dashboard einfügen (Env / .velin/motion/.env).\n',
+        );
+        await promptAndSaveApiKey({ cwd, rl });
+        markPixVerseSetupCompleted(cwd);
+        return { ok: true };
+      }
+      throw new Error('Abgebrochen');
+    }
+
+    // setup_completed but key missing — same affiliate-first menu, no auto browser
+    process.stdout.write(
+      [
+        '',
+        'VelinStyle Motion',
+        '',
+        'PixVerse Setup',
+        '',
+        'PixVerse API-Key fehlt (Env / .velin/motion/.env).',
+        'Oder erneut: velinstyle motion setup pixverse',
+        '',
+        formatPixVerseSignupHelp().split('\n').slice(6).join('\n'),
+        '',
+      ].join('\n'),
+    );
+    const choice = (await ask(rl, 'Auswahl [1/2/3/4]: ')).trim();
+    if (choice === '4' || choice.toLowerCase() === 'q' || choice.toLowerCase() === 'c') {
+      throw new Error('Abgebrochen');
+    }
+    if (choice === '1' || choice === '') {
+      const outcome = await runPixVersePartnerOpenFlow({
+        rl,
+        openImpl: opts.openImpl,
+        spawnImpl: opts.spawnImpl,
+        copyImpl: opts.copyImpl,
+        forceFail: opts.forceFail,
+      });
+      if (outcome === 'aborted') throw new Error('Abgebrochen');
+    } else if (choice === '2') {
+      writeCopied(copyPixVersePartnerLink({ copyImpl: opts.copyImpl }));
+    } else if (choice !== '3') {
+      throw new Error('Abgebrochen');
+    }
+    process.stdout.write(`Docs: ${PIXVERSE_DOCS_URL}\n`);
+    await promptAndSaveApiKey({ cwd, rl });
+    return { ok: true };
+  } finally {
+    rl.close();
+  }
+}

package/packages/velinstyle-motion/src/ux/wizard.js

@@ -0,0 +1,171 @@
+/**
+ * Interactive TTY wizard for motion create / atelier.
+ */
+import { createInterface } from 'readline';
+import { listWizardChoices, getClipPreset } from '../registry/presets.js';
+import { listAiProviders, loadBuiltinAiProviders } from '../ai/provider.js';
+import { suggestFromMiniPrompt } from '../ai/mini-prompt.js';
+
+function rl() {
+  return createInterface({ input: process.stdin, output: process.stdout });
+}
+
+function ask(r, q) {
+  return new Promise((resolve) => r.question(q, resolve));
+}
+
+/**
+ * @param {object} ctx
+ * @param {string} ctx.image
+ * @param {boolean} [ctx.ai]
+ * @param {boolean} [ctx.yes]
+ * @param {object} [ctx.flags] — prefilled non-interactive
+ */
+export async function runCreateWizard(ctx = {}) {
+  if (ctx.yes || ctx.flags?.preset || !process.stdin.isTTY) {
+    return resolveNonInteractive(ctx);
+  }
+
+  const r = rl();
+  try {
+    process.stdout.write(`\nVelinStyle Motion\n\nBild: ${ctx.image}\n\nAnimation auswählen:\n\n`);
+    const choices = listWizardChoices();
+    for (const c of choices) {
+      process.stdout.write(`${c.index}. ${c.title}${c.engine === 'ai' ? ' (AI)' : ''}\n`);
+    }
+    process.stdout.write(`${choices.length + 1}. Eigener Prompt / Mini-Prompt\n`);
+    const raw = await ask(r, '\nAuswahl: ');
+    const n = Number(raw);
+    let preset = null;
+    let profile = null;
+    let engine = 'local';
+    let provider = null;
+    let promptText = '';
+
+    if (n === choices.length + 1 || ctx.ai) {
+      const phrase = await ask(r, '\nWas soll passieren?\n> ');
+      const suggestions = suggestFromMiniPrompt(phrase);
+      if (suggestions.length) {
+        process.stdout.write('\nVelinStyle schlägt vor:\n\n');
+        suggestions.forEach((s, i) => process.stdout.write(`[${i + 1}] ${s.label}\n`));
+        const pick = Number(await ask(r, '\nAuswahl: ')) || 1;
+        profile = suggestions[Math.max(0, Math.min(suggestions.length, pick) - 1)];
+      } else {
+        profile = suggestFromMiniPrompt(phrase)[0];
+      }
+      engine = ctx.ai || (await ask(r, 'Engine [local/ai] (local): ')) === 'ai' ? 'ai' : (ctx.ai ? 'ai' : 'local');
+      if (ctx.ai) engine = 'ai';
+      preset = getClipPreset(engine === 'ai' ? 'ai-reveal' : 'custom-prompt');
+    } else {
+      const choice = choices[n - 1] || choices[0];
+      preset = getClipPreset(choice.id);
+      engine = preset.engine === 'ai' || preset.engine === 'hybrid' ? (choice.engine === 'ai' ? 'ai' : 'local') : 'local';
+      if (preset.engine === 'ai') engine = 'ai';
+    }
+
+    if (engine === 'ai') {
+      await loadBuiltinAiProviders();
+      const providers = listAiProviders();
+      process.stdout.write('\nAI Provider\n\n');
+      providers.forEach((p, i) => process.stdout.write(`${i + 1}. ${p.title}\n`));
+      process.stdout.write(`${providers.length + 1}. Weitere Provider (bald)\n`);
+      const pi = Number(await ask(r, '\nAuswahl: ')) || 1;
+      if (pi > providers.length) {
+        throw new Error('Weitere Provider sind in 1.3.0 noch nicht verfügbar — bitte PixVerse wählen.');
+      }
+      provider = providers[pi - 1];
+      const model = (await ask(r, `Modell [${provider.models[0]}]: `)) || provider.models[0];
+      const quality = (await ask(r, 'Qualität [720p]: ')) || '720p';
+      const duration = Number(await ask(r, 'Dauer Sekunden [5]: ')) || 5;
+      promptText = profile?.aiPrompt || (await ask(r, 'Prompt (Enter = Profil): ')) || profile?.aiPrompt || '';
+
+      process.stdout.write(`\n${provider.title} Animation\n\n`);
+      process.stdout.write(`Bild: ${ctx.image}\n`);
+      process.stdout.write(`Preset: ${preset?.title || 'AI'}\n`);
+      process.stdout.write(`Dauer: ${duration}s\n`);
+      process.stdout.write(`Modell: ${model}\n`);
+      process.stdout.write(`Qualität: ${quality}\n`);
+      process.stdout.write(`Prompt: ${promptText}\n`);
+
+      return {
+        image: ctx.image,
+        preset: preset?.id || 'ai-reveal',
+        engine: 'ai',
+        provider: provider.id,
+        model,
+        quality,
+        duration,
+        prompt: promptText,
+        profile,
+      };
+    }
+
+    const duration = Number(await ask(r, 'Dauer Sekunden [4]: ')) || (preset?.durationMs || 4000) / 1000;
+    process.stdout.write(`\nLocal Animation\nBild: ${ctx.image}\nPreset: ${preset?.title}\nDauer: ${duration}s\n`);
+    const ok = await ask(r, '\nStarten? [J/n] ');
+    if (ok && !/^(j|y|ja|yes)?$/i.test(ok.trim() || 'j')) {
+      throw new Error('Abgebrochen');
+    }
+    return {
+      image: ctx.image,
+      preset: preset?.id || 'soft-zoom',
+      engine: 'local',
+      duration,
+      profile,
+    };
+  } finally {
+    r.close();
+  }
+}
+
+function resolveNonInteractive(ctx) {
+  const flags = ctx.flags || {};
+  const presetId = flags.preset || (ctx.ai ? 'ai-reveal' : 'soft-zoom');
+  const preset = getClipPreset(presetId);
+  return {
+    image: ctx.image,
+    preset: preset?.id || presetId,
+    engine: flags.style || (ctx.ai || preset?.engine === 'ai' ? 'ai' : 'local'),
+    provider: flags.provider || 'pixverse',
+    model: flags.model,
+    quality: flags.quality || '720p',
+    duration: flags.duration ? Number(flags.duration) : undefined,
+    prompt: flags.prompt,
+    profile: flags.profile,
+    outDir: flags.out,
+  };
+}
+
+/**
+ * Atelier batch wizard (simplified interactive).
+ */
+export async function runAtelierWizard(ctx = {}) {
+  if (ctx.yes || !process.stdin.isTTY) {
+    return {
+      count: ctx.count || 10,
+      preset: ctx.preset || 'atelier',
+      engine: ctx.ai ? 'ai' : 'local',
+      provider: 'pixverse',
+      duration: ctx.duration || 5,
+      quality: '720p',
+      outDir: ctx.outDir || './motion-output',
+    };
+  }
+  const r = rl();
+  try {
+    process.stdout.write(`\nVelinStyle Atelier Motion\n\n${ctx.assetCount ?? '?'} Assets gefunden.\n\n`);
+    const count = Number(await ask(r, 'Wie viele Animationen?\n> ')) || 10;
+    const preset = (await ask(r, 'Preset [atelier]: ')) || 'atelier';
+    const engine = (await ask(r, 'Engine [local/ai]: ')) || 'local';
+    let provider = 'pixverse';
+    let quality = '720p';
+    if (engine === 'ai') {
+      provider = (await ask(r, 'Provider [pixverse]: ')) || 'pixverse';
+      quality = (await ask(r, 'Qualität [720p]: ')) || '720p';
+    }
+    const duration = Number(await ask(r, 'Dauer [5]: ')) || 5;
+    return { count, preset, engine, provider, duration, quality, outDir: './motion-output' };
+  } finally {
+    r.close();
+  }
+}

package/packages/velinstyle-motion/src/validate-image.js

@@ -0,0 +1,91 @@
+/**
+ * Validate still-image inputs for Motion Clip CLI (local + AI).
+ * Rejects missing, empty, wrong-extension, and non-image payloads.
+ */
+import { existsSync, statSync, openSync, readSync, closeSync } from 'fs';
+import { extname, basename } from 'path';
+
+const ALLOWED_EXT = new Set(['.webp', '.png', '.jpg', '.jpeg']);
+
+/**
+ * @param {string} filePath absolute path
+ * @param {string} [label]
+ */
+export function assertMotionImageFile(filePath, label = 'Image') {
+  if (!filePath || typeof filePath !== 'string') {
+    throw new Error(`${label} path is required`);
+  }
+  if (!existsSync(filePath)) {
+    throw new Error(`${label} not found: ${filePath}`);
+  }
+  let st;
+  try {
+    st = statSync(filePath);
+  } catch {
+    throw new Error(`${label} not readable: ${filePath}`);
+  }
+  if (!st.isFile()) {
+    throw new Error(`${label} must be a file: ${filePath}`);
+  }
+  if (st.size <= 0) {
+    throw new Error(`${label} is empty (0 bytes): ${basename(filePath)}`);
+  }
+
+  const ext = extname(filePath).toLowerCase();
+  if (!ALLOWED_EXT.has(ext)) {
+    throw new Error(
+      `${label} has unsupported extension "${ext || '(none)'}" — use .webp, .png, .jpg, or .jpeg`,
+    );
+  }
+
+  const head = readHead(filePath, 16);
+  if (!looksLikeRasterImage(head)) {
+    throw new Error(
+      `${label} is not a valid PNG/JPEG/WebP file: ${basename(filePath)}`,
+    );
+  }
+
+  return { path: filePath, size: st.size, ext };
+}
+
+/**
+ * @param {string} filePath
+ * @param {number} n
+ */
+function readHead(filePath, n) {
+  const buf = Buffer.alloc(n);
+  const fd = openSync(filePath, 'r');
+  try {
+    readSync(fd, buf, 0, n, 0);
+  } finally {
+    closeSync(fd);
+  }
+  return buf;
+}
+
+/**
+ * Accept PNG / JPEG / WebP magic regardless of which allowed extension was used
+ * (fixtures often store PNG bytes under a .webp name).
+ * @param {Buffer} buf
+ */
+function looksLikeRasterImage(buf) {
+  if (!buf || buf.length < 3) return false;
+  if (buf[0] === 0x89 && buf[1] === 0x50 && buf[2] === 0x4e && buf[3] === 0x47) return true;
+  if (buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) return true;
+  if (
+    buf.length >= 12 &&
+    buf[0] === 0x52 &&
+    buf[1] === 0x49 &&
+    buf[2] === 0x46 &&
+    buf[3] === 0x46 &&
+    buf[8] === 0x57 &&
+    buf[9] === 0x45 &&
+    buf[10] === 0x42 &&
+    buf[11] === 0x50
+  ) {
+    return true;
+  }
+  return false;
+}
+
+export { ALLOWED_EXT as MOTION_IMAGE_EXTENSIONS };

package/packages/velinstyle-skills/catalog.json

@@ -1,6 +1,6 @@
 {
   "version": "1.0.0",
-  "generatedAt": "2026-08-02T07:30:24.706Z",
+  "generatedAt": "2026-08-09T18:36:20.293Z",
   "totals": {
     "skills": 40,
     "packs": 6,