@lovehlmmm/primekit 1.0.0

package/skills/show-off/scripts/capture-sections.js

@@ -0,0 +1,310 @@
+#!/usr/bin/env node
+/**
+ * Parallel section screenshot capture for show-off skill.
+ * Captures multiple sections at multiple viewport ratios concurrently.
+ *
+ * Usage:
+ *   node capture-sections.js \
+ *     --url "file:///path/to/page.html" \
+ *     --output-dir "./images" \
+ *     --sections "#hero,#about,#features" \
+ *     --ratios "horizontal,vertical,square" \
+ *     --delay 2000
+ *
+ * Uses a local Puppeteer dependency from show-off/scripts/package.json.
+ */
+import path from 'path';
+import fs from 'fs/promises';
+import { fileURLToPath } from 'url';
+import puppeteer from 'puppeteer';
+
+// Viewport presets per ratio name
+const VIEWPORTS = {
+  horizontal: { width: 1920, height: 1080, label: 'horizontal' },  // 16:9
+  vertical:   { width: 1080, height: 1920, label: 'vertical' },    // 9:16
+  square:     { width: 1080, height: 1080, label: 'square' },      // 1:1
+};
+
+// Optional Sharp compression for large captures.
+let sharp = null;
+try { sharp = (await import('sharp')).default; } catch { /* noop */ }
+
+function parseArgs(argv) {
+  const args = {};
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (!arg.startsWith('--')) continue;
+
+    const key = arg.slice(2);
+    const nextArg = argv[i + 1];
+    if (nextArg && !nextArg.startsWith('--')) {
+      args[key] = nextArg;
+      i++;
+    } else {
+      args[key] = true;
+    }
+  }
+
+  return args;
+}
+
+function resolveHeadless(value) {
+  if (value === false || value === 'false') return false;
+  if (value === true || value === 'true') return true;
+  if (process.env.CI || process.env.GITHUB_ACTIONS || process.env.GITLAB_CI || process.env.JENKINS_URL) return true;
+  return process.platform === 'linux';
+}
+
+async function getBrowser(options = {}) {
+  const executablePath = options.executablePath || process.env.PUPPETEER_EXECUTABLE_PATH || process.env.CHROME_EXECUTABLE_PATH;
+  return puppeteer.launch({
+    headless: resolveHeadless(options.headless),
+    args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage'],
+    defaultViewport: { width: 1920, height: 1080 },
+    ...(executablePath && { executablePath }),
+  });
+}
+
+async function getPage(browser) {
+  const pages = await browser.pages();
+  return pages[0] || browser.newPage();
+}
+
+function outputJSON(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+function outputError(error) {
+  console.error(JSON.stringify({
+    success: false,
+    error: error.message,
+    stack: error.stack,
+  }, null, 2));
+}
+
+/**
+ * Wait until the page is visually ready:
+ *  1. Fonts loaded (`document.fonts.ready`)
+ *  2. Every <img> complete and non-zero natural size (or explicitly broken)
+ *  3. Every CSS background-image resolved (best-effort via Image() preload)
+ *  4. Two rAF paints to let layout + compositor settle
+ *  5. Final `settleDelay` ms for animations / lazy-triggered work
+ *
+ * Timeout bounds each wait so a broken asset never hangs the capture.
+ */
+async function waitForRender(page, { settleDelay = 500, timeout = 15000 } = {}) {
+  await page.evaluate(async (timeoutMs) => {
+    const withTimeout = (promise, ms) =>
+      Promise.race([promise, new Promise((r) => setTimeout(r, ms))]);
+
+    if (document.fonts && document.fonts.ready) {
+      await withTimeout(document.fonts.ready, timeoutMs);
+    }
+
+    const imgs = Array.from(document.images || []);
+    await withTimeout(
+      Promise.all(
+        imgs.map((img) =>
+          img.complete
+            ? Promise.resolve()
+            : new Promise((res) => {
+                img.addEventListener('load', res, { once: true });
+                img.addEventListener('error', res, { once: true });
+              }),
+        ),
+      ),
+      timeoutMs,
+    );
+
+    const bgUrls = new Set();
+    for (const el of document.querySelectorAll('*')) {
+      const bg = getComputedStyle(el).backgroundImage;
+      if (!bg || bg === 'none') continue;
+      for (const m of bg.matchAll(/url\(["']?([^"')]+)["']?\)/g)) bgUrls.add(m[1]);
+    }
+    await withTimeout(
+      Promise.all(
+        Array.from(bgUrls).map(
+          (url) =>
+            new Promise((res) => {
+              const probe = new Image();
+              probe.addEventListener('load', res, { once: true });
+              probe.addEventListener('error', res, { once: true });
+              probe.src = url;
+            }),
+        ),
+      ),
+      timeoutMs,
+    );
+
+    await new Promise((r) => requestAnimationFrame(() => requestAnimationFrame(r)));
+  }, timeout);
+
+  if (settleDelay > 0) await new Promise((r) => setTimeout(r, settleDelay));
+}
+
+/**
+ * Compress image if it exceeds maxSizeMB.
+ */
+async function compressIfNeeded(filePath, maxSizeMB = 5) {
+  const stats = await fs.stat(filePath);
+  if (stats.size <= maxSizeMB * 1024 * 1024) return { compressed: false, size: stats.size };
+  if (!sharp) return { compressed: false, size: stats.size };
+
+  const ext = path.extname(filePath).toLowerCase();
+  const buf = await fs.readFile(filePath);
+  let out;
+  if (ext === '.png') {
+    out = await sharp(buf).png({ quality: 80, compressionLevel: 9 }).toBuffer();
+  } else if (ext === '.jpg' || ext === '.jpeg') {
+    out = await sharp(buf).jpeg({ quality: 80, progressive: true, mozjpeg: true }).toBuffer();
+  } else if (ext === '.webp') {
+    out = await sharp(buf).webp({ quality: 80 }).toBuffer();
+  } else {
+    out = await sharp(buf).jpeg({ quality: 80, progressive: true }).toBuffer();
+  }
+  await fs.writeFile(filePath, out);
+  return { compressed: true, size: out.length };
+}
+
+/**
+ * Capture a single section at a given viewport ratio.
+ * Returns result metadata object.
+ */
+async function captureOne(page, selector, ratio, outputDir, format, quality, maxSize) {
+  const vp = VIEWPORTS[ratio];
+  if (!vp) throw new Error(`Unknown ratio: ${ratio}. Use: ${Object.keys(VIEWPORTS).join(', ')}`);
+
+  // Resize viewport
+  await page.setViewport({ width: vp.width, height: vp.height, deviceScaleFactor: 2 });
+
+  // Scroll section into view and wait for any lazy-loaded content
+  const el = await page.$(selector);
+  if (!el) throw new Error(`Section not found: ${selector}`);
+  await el.scrollIntoView();
+  await page.evaluate(() => new Promise(r => requestAnimationFrame(() => requestAnimationFrame(r))));
+
+  // Build filename: {ratio}-{sectionName}.{format}
+  const sectionName = selector.replace(/^[#.]/, '').replace(/[^a-zA-Z0-9-_]/g, '_');
+  const fileName = `${vp.label}-${sectionName}.${format}`;
+  const filePath = path.join(outputDir, fileName);
+
+  const opts = { path: filePath, type: format };
+  if (format !== 'png' && quality) opts.quality = quality;
+
+  await el.screenshot(opts);
+
+  const comp = await compressIfNeeded(filePath, maxSize);
+
+  return {
+    section: selector,
+    ratio,
+    file: filePath,
+    size: comp.size,
+    compressed: comp.compressed,
+  };
+}
+
+/**
+ * Main: parse args, open page, capture all section+ratio combos in parallel.
+ */
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+
+  if (!args.url || !args['output-dir'] || !args.sections) {
+    outputError(new Error('Required: --url, --output-dir, --sections'));
+    process.exit(1);
+  }
+
+  const url = args.url;
+  const outputDir = path.resolve(args['output-dir']);
+  const sections = args.sections.split(',').map(s => s.trim());
+  const ratios = (args.ratios || 'horizontal,vertical,square').split(',').map(s => s.trim());
+  // `--delay` is the post-ready settle delay (kept for back-compat).
+  // `--settle-delay` is a preferred alias. `--render-timeout` bounds each readiness check.
+  const settleDelay = parseInt(args['settle-delay'] || args.delay || '1500', 10);
+  const renderTimeout = parseInt(args['render-timeout'] || '15000', 10);
+  const format = args.format || 'png';
+  const quality = parseInt(args.quality || '90', 10);
+  const maxSize = parseFloat(args['max-size'] || '5');
+
+  await fs.mkdir(outputDir, { recursive: true });
+
+  const browser = await getBrowser({ headless: args.headless, executablePath: args['executable-path'] });
+  const page = await getPage(browser);
+
+  // Navigate and wait for full network+asset+font readiness before any capture.
+  await page.goto(url, { waitUntil: 'networkidle0', timeout: renderTimeout + 15000 });
+  await waitForRender(page, { settleDelay, timeout: renderTimeout });
+
+  // Build capture tasks: one per (section, ratio) pair
+  // Group by ratio to minimise viewport switches — captures within same ratio run sequentially,
+  // but different ratios run in parallel (each gets its own page context via browser.newPage).
+  const results = [];
+  const errors = [];
+
+  const ratioTasks = ratios.map(async (ratio) => {
+    // Each ratio gets a fresh page so viewport changes don't conflict
+    const ratioPage = await browser.newPage();
+    const vp = VIEWPORTS[ratio];
+    await ratioPage.setViewport({ width: vp.width, height: vp.height, deviceScaleFactor: 2 });
+    await ratioPage.goto(url, { waitUntil: 'networkidle0', timeout: renderTimeout + 15000 });
+    await waitForRender(ratioPage, { settleDelay, timeout: renderTimeout });
+
+    for (const selector of sections) {
+      try {
+        const el = await ratioPage.$(selector);
+        if (!el) {
+          errors.push({ section: selector, ratio, error: `Element not found: ${selector}` });
+          continue;
+        }
+        await el.scrollIntoView();
+        // Let scroll-linked animations / IntersectionObserver reveals trigger, then repaint.
+        await waitForRender(ratioPage, { settleDelay: Math.min(settleDelay, 400), timeout: renderTimeout });
+
+        const sectionName = selector.replace(/^[#.]/, '').replace(/[^a-zA-Z0-9-_]/g, '_');
+        const fileName = `${vp.label}-${sectionName}.${format}`;
+        const filePath = path.join(outputDir, fileName);
+
+        const opts = { path: filePath, type: format };
+        if (format !== 'png' && quality) opts.quality = quality;
+
+        await el.screenshot(opts);
+        const comp = await compressIfNeeded(filePath, maxSize);
+
+        results.push({
+          section: selector,
+          ratio,
+          file: filePath,
+          size: comp.size,
+          compressed: comp.compressed,
+        });
+      } catch (err) {
+        errors.push({ section: selector, ratio, error: err.message });
+      }
+    }
+
+    await ratioPage.close();
+  });
+
+  // Run all ratios in parallel
+  await Promise.all(ratioTasks);
+
+  // Close original page and browser now that the capture batch is complete.
+  await browser.close();
+
+  outputJSON({
+    success: errors.length === 0,
+    total: results.length,
+    captured: results,
+    errors: errors.length > 0 ? errors : undefined,
+  });
+
+  process.exit(errors.length > 0 ? 1 : 0);
+}
+
+main().catch(err => {
+  outputError(err);
+  process.exit(1);
+});

package/skills/show-off/scripts/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "show-off-scripts",
+  "version": "1.0.0",
+  "description": "Parallel section capture scripts for show-off skill",
+  "type": "module",
+  "scripts": {
+    "test": "node --test preferences.test.js"
+  },
+  "dependencies": {
+    "puppeteer": "^24.15.0",
+    "sharp": "^0.33.5"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}

package/skills/show-off/scripts/preferences.js

@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { pathToFileURL } from 'url';
+
+export const DEFAULT_PREFERENCES = Object.freeze({
+  version: 1,
+  screenshots: true,
+  publishing: true,
+  languages: Object.freeze(['vi', 'en']),
+});
+
+const TRUE_VALUES = new Set(['1', 'true', 'yes', 'y', 'on', 'enable', 'enabled']);
+const FALSE_VALUES = new Set(['0', 'false', 'no', 'n', 'off', 'disable', 'disabled']);
+const VALID_LANGUAGES = new Set(['en', 'vi']);
+
+export function resolvePreferencesPath(env = process.env) {
+  if (env.SHOW_OFF_PREFS_PATH) return path.resolve(env.SHOW_OFF_PREFS_PATH);
+  const home = env.AGENTKIT_HOME || path.join(os.homedir(), '.primekit');
+  return path.join(home, 'show-off', 'preferences.json');
+}
+
+function parseBoolean(value, flagName) {
+  if (typeof value === 'boolean') return value;
+  if (value === undefined || value === null) {
+    throw new Error(`${flagName} requires on/off, true/false, or yes/no`);
+  }
+  const normalized = String(value).trim().toLowerCase();
+  if (TRUE_VALUES.has(normalized)) return true;
+  if (FALSE_VALUES.has(normalized)) return false;
+  throw new Error(`${flagName} received invalid boolean value: ${value}`);
+}
+
+function parseLanguages(value) {
+  if (Array.isArray(value)) return normalizeLanguages(value);
+  if (typeof value !== 'string' || value.trim() === '') {
+    throw new Error('--languages requires en, vi, or en,vi');
+  }
+  return normalizeLanguages(value.split(',').map((item) => item.trim()));
+}
+
+function normalizeLanguages(languages) {
+  const unique = [];
+  for (const raw of languages) {
+    const lang = String(raw).trim().toLowerCase();
+    if (!VALID_LANGUAGES.has(lang)) {
+      throw new Error(`Unsupported language "${raw}". Use en, vi, or en,vi.`);
+    }
+    if (!unique.includes(lang)) unique.push(lang);
+  }
+  if (unique.length === 0) throw new Error('At least one language is required');
+  return unique;
+}
+
+export function normalizePreferences(input = {}) {
+  const merged = {
+    ...DEFAULT_PREFERENCES,
+    ...input,
+  };
+
+  return {
+    version: 1,
+    screenshots: parseBoolean(merged.screenshots, 'screenshots'),
+    publishing: parseBoolean(merged.publishing, 'publishing'),
+    languages: parseLanguages(merged.languages),
+  };
+}
+
+export async function loadPreferences({ env = process.env } = {}) {
+  const preferencesPath = resolvePreferencesPath(env);
+  try {
+    const raw = await fs.readFile(preferencesPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return {
+      path: preferencesPath,
+      exists: true,
+      preferences: normalizePreferences(parsed),
+      warnings: [],
+    };
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      return {
+        path: preferencesPath,
+        exists: false,
+        preferences: normalizePreferences(DEFAULT_PREFERENCES),
+        warnings: [],
+      };
+    }
+
+    return {
+      path: preferencesPath,
+      exists: true,
+      preferences: normalizePreferences(DEFAULT_PREFERENCES),
+      warnings: [`Could not read preferences; using defaults. ${error.message}`],
+    };
+  }
+}
+
+export async function savePreferences(preferences, { env = process.env } = {}) {
+  const preferencesPath = resolvePreferencesPath(env);
+  const normalized = normalizePreferences(preferences);
+  const payload = {
+    ...normalized,
+    updatedAt: new Date().toISOString(),
+  };
+  const dir = path.dirname(preferencesPath);
+  const tmpPath = `${preferencesPath}.${process.pid}.${Date.now()}.tmp`;
+
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(tmpPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
+  await fs.rename(tmpPath, preferencesPath);
+
+  return {
+    path: preferencesPath,
+    preferences: payload,
+  };
+}
+
+export async function resetPreferences({ env = process.env } = {}) {
+  const preferencesPath = resolvePreferencesPath(env);
+  try {
+    await fs.unlink(preferencesPath);
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+  return {
+    path: preferencesPath,
+    preferences: normalizePreferences(DEFAULT_PREFERENCES),
+  };
+}
+
+export function parseSetArgs(argv) {
+  const updates = {};
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+
+    if (arg === '--no-screenshots') {
+      updates.screenshots = false;
+      continue;
+    }
+    if (arg === '--screenshots') {
+      updates.screenshots = parseBoolean(argv[++i], '--screenshots');
+      continue;
+    }
+    if (arg === '--no-publishing' || arg === '--no-publish') {
+      updates.publishing = false;
+      continue;
+    }
+    if (arg === '--publishing' || arg === '--publish') {
+      updates.publishing = parseBoolean(argv[++i], arg);
+      continue;
+    }
+    if (arg === '--no-dual-language') {
+      updates.languages = ['en'];
+      continue;
+    }
+    if (arg === '--dual-language') {
+      updates.languages = parseBoolean(argv[++i], '--dual-language') ? ['vi', 'en'] : ['en'];
+      continue;
+    }
+    if (arg === '--language' || arg === '--languages') {
+      updates.languages = parseLanguages(argv[++i]);
+      continue;
+    }
+
+    throw new Error(`Unknown option: ${arg}`);
+  }
+
+  return updates;
+}
+
+function withDerivedFields(result) {
+  const preferences = {
+    ...result.preferences,
+    dualLanguage: result.preferences.languages.length > 1,
+  };
+  return {
+    success: true,
+    ...result,
+    preferences,
+  };
+}
+
+function writeJson(data) {
+  process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+
+function writeError(error) {
+  process.stderr.write(`${JSON.stringify({ success: false, error: error.message }, null, 2)}\n`);
+}
+
+export async function main(argv = process.argv.slice(2), { env = process.env } = {}) {
+  const command = argv[0] || 'get';
+
+  if (command === 'path') {
+    writeJson({ success: true, path: resolvePreferencesPath(env) });
+    return;
+  }
+
+  if (command === 'get') {
+    writeJson(withDerivedFields(await loadPreferences({ env })));
+    return;
+  }
+
+  if (command === 'set') {
+    const loaded = await loadPreferences({ env });
+    const updates = parseSetArgs(argv.slice(1));
+    const saved = await savePreferences({ ...loaded.preferences, ...updates }, { env });
+    writeJson(withDerivedFields({ ...saved, exists: true, warnings: loaded.warnings || [] }));
+    return;
+  }
+
+  if (command === 'reset') {
+    writeJson(withDerivedFields(await resetPreferences({ env })));
+    return;
+  }
+
+  throw new Error(`Unknown command: ${command}`);
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1]).href) {
+  main().catch((error) => {
+    writeError(error);
+    process.exit(1);
+  });
+}

package/skills/show-off/scripts/preferences.test.js

@@ -0,0 +1,94 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import {
+  loadPreferences,
+  parseSetArgs,
+  resetPreferences,
+  savePreferences,
+} from './preferences.js';
+
+async function withTempPrefs(fn) {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'primekit-show-off-prefs-'));
+  const prefsPath = path.join(dir, 'preferences.json');
+  try {
+    await fn({ SHOW_OFF_PREFS_PATH: prefsPath }, prefsPath);
+  } finally {
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+}
+
+test('loadPreferences returns default enabled workflow preferences', async () => {
+  await withTempPrefs(async (env) => {
+    const loaded = await loadPreferences({ env });
+
+    assert.equal(loaded.exists, false);
+    assert.equal(loaded.preferences.screenshots, true);
+    assert.equal(loaded.preferences.publishing, true);
+    assert.deepEqual(loaded.preferences.languages, ['vi', 'en']);
+  });
+});
+
+test('resolve defaults under AGENTKIT_HOME', async () => {
+  const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'primekit-home-'));
+  try {
+    const loaded = await loadPreferences({ env: { AGENTKIT_HOME: dir } });
+    assert.equal(loaded.path, path.join(dir, 'show-off', 'preferences.json'));
+    assert.equal(loaded.preferences.publishing, true);
+  } finally {
+    await fs.rm(dir, { recursive: true, force: true });
+  }
+});
+
+test('savePreferences persists opt-out choices', async () => {
+  await withTempPrefs(async (env, prefsPath) => {
+    await savePreferences(
+      { screenshots: false, publishing: false, languages: ['en'] },
+      { env },
+    );
+
+    const stored = JSON.parse(await fs.readFile(prefsPath, 'utf8'));
+    const loaded = await loadPreferences({ env });
+
+    assert.equal(stored.screenshots, false);
+    assert.equal(stored.publishing, false);
+    assert.deepEqual(loaded.preferences.languages, ['en']);
+  });
+});
+
+test('parseSetArgs supports user-facing aliases', () => {
+  const updates = parseSetArgs([
+    '--no-screenshots',
+    '--no-publish',
+    '--languages',
+    'en',
+  ]);
+
+  assert.deepEqual(updates, {
+    screenshots: false,
+    publishing: false,
+    languages: ['en'],
+  });
+});
+
+test('resetPreferences removes persisted preferences', async () => {
+  await withTempPrefs(async (env, prefsPath) => {
+    await savePreferences({ screenshots: false, publishing: true, languages: ['vi'] }, { env });
+    await resetPreferences({ env });
+
+    await assert.rejects(fs.stat(prefsPath), { code: 'ENOENT' });
+    const loaded = await loadPreferences({ env });
+    assert.equal(loaded.preferences.screenshots, true);
+    assert.deepEqual(loaded.preferences.languages, ['vi', 'en']);
+  });
+});
+
+test('parseSetArgs rejects unsupported languages', () => {
+  assert.throws(
+    () => parseSetArgs(['--languages', 'en,fr']),
+    /Unsupported language/,
+  );
+});

package/skills/skill-creator/LICENSE-MIT.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 David Ondrej
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.