quiver-cli 1.3.1 → 2.0.0

package/template/.agents/skills/design/impeccable/scripts/lib/impeccable-paths.mjs

@@ -1,137 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { resolveProjectRoot } from '../context.mjs';
-import { designSidecarCandidatesFor } from './staleness.mjs';
-export { IMPECCABLE_COMMAND_PREFIX } from './provider.mjs';
-
-export const IMPECCABLE_DIR = '.impeccable';
-export const LIVE_DIR = 'live';
-export const CRITIQUE_DIR = 'critique';
-
-export function getImpeccableDir(cwd = process.cwd(), options = {}) {
-  return path.join(resolveProjectRoot(cwd, options), IMPECCABLE_DIR);
-}
-
-export function getDesignSidecarPath(cwd = process.cwd(), options = {}) {
-  return path.join(getImpeccableDir(cwd, options), 'design.json');
-}
-
-export function getDesignSidecarCandidates(cwd = process.cwd(), contextDir = cwd, options = {}) {
-  return designSidecarCandidatesFor(resolveProjectRoot(cwd, options), contextDir);
-}
-
-export function resolveDesignSidecarPath(cwd = process.cwd(), contextDir = cwd, options = {}) {
-  return firstExisting(getDesignSidecarCandidates(cwd, contextDir, options));
-}
-
-export function getLiveDir(cwd = process.cwd(), options = {}) {
-  return path.join(getImpeccableDir(cwd, options), LIVE_DIR);
-}
-
-export function getLiveConfigPath(cwd = process.cwd(), options = {}) {
-  return path.join(getLiveDir(cwd, options), 'config.json');
-}
-
-export function getLegacyLiveConfigPath(scriptsDir) {
-  return path.join(scriptsDir, 'config.json');
-}
-
-export function resolveLiveConfigPath({ cwd = process.cwd(), scriptsDir, env = process.env, targetPath } = {}) {
-  if (env.IMPECCABLE_LIVE_CONFIG && env.IMPECCABLE_LIVE_CONFIG.trim()) {
-    const configured = env.IMPECCABLE_LIVE_CONFIG.trim();
-    return path.isAbsolute(configured) ? configured : path.resolve(cwd, configured);
-  }
-  const primary = getLiveConfigPath(cwd, { targetPath });
-  if (fs.existsSync(primary)) return primary;
-  if (scriptsDir) {
-    const legacy = getLegacyLiveConfigPath(scriptsDir);
-    if (fs.existsSync(legacy)) return legacy;
-  }
-  return primary;
-}
-
-export function getLiveServerPath(cwd = process.cwd(), options = {}) {
-  return path.join(getLiveDir(cwd, options), 'server.json');
-}
-
-export function getLegacyLiveServerPath(cwd = process.cwd(), options = {}) {
-  return path.join(resolveProjectRoot(cwd, options), '.impeccable-live.json');
-}
-
-export function readLiveServerInfo(cwd = process.cwd(), options = {}) {
-  for (const filePath of [getLiveServerPath(cwd, options), getLegacyLiveServerPath(cwd, options)]) {
-    try {
-      const info = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
-      if (info && typeof info.pid === 'number' && !isLiveServerPidReachable(info.pid)) {
-        try { fs.unlinkSync(filePath); } catch {}
-        continue;
-      }
-      return { info, path: filePath };
-    } catch {
-      /* try next */
-    }
-  }
-  return null;
-}
-
-export function isLiveServerPidReachable(pid) {
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    // ESRCH means "no such process". EPERM means the process exists but this
-    // user cannot signal it, so the live server info is still valid.
-    return err?.code !== 'ESRCH';
-  }
-}
-
-export function writeLiveServerInfo(cwd = process.cwd(), info, options = {}) {
-  const filePath = getLiveServerPath(cwd, options);
-  fs.mkdirSync(path.dirname(filePath), { recursive: true });
-  fs.writeFileSync(filePath, JSON.stringify(info));
-  return filePath;
-}
-
-export function removeLiveServerInfo(cwd = process.cwd(), options = {}) {
-  for (const filePath of [getLiveServerPath(cwd, options), getLegacyLiveServerPath(cwd, options)]) {
-    try { fs.unlinkSync(filePath); } catch {}
-  }
-}
-
-/**
- * Session IDs become path segments (journals, snapshots, accept receipts,
- * preview manifests, generated component dirs). They arrive from CLI `--id`
- * arguments and HTTP payloads, so anything containing a separator or `..` must
- * be rejected before it reaches path.join, which would happily escape
- * `.impeccable/live/`. Real IDs are 8 hex chars; the tests use short slugs.
- */
-export function safeSessionId(id) {
-  if (typeof id !== 'string' || !/^[A-Za-z0-9_-]{1,128}$/.test(id)) {
-    throw new Error('invalid session id: ' + id);
-  }
-  return id;
-}
-
-export function getLiveSessionsDir(cwd = process.cwd(), options = {}) {
-  return path.join(getLiveDir(cwd, options), 'sessions');
-}
-
-export function getLegacyLiveSessionsDir(cwd = process.cwd(), options = {}) {
-  return path.join(resolveProjectRoot(cwd, options), '.impeccable-live', 'sessions');
-}
-
-export function getLiveAnnotationsDir(cwd = process.cwd(), options = {}) {
-  return path.join(getLiveDir(cwd, options), 'annotations');
-}
-
-export function getCritiqueDir(cwd = process.cwd(), options = {}) {
-  return path.join(getImpeccableDir(cwd, options), CRITIQUE_DIR);
-}
-
-export function getLegacyLiveAnnotationsDir(cwd = process.cwd(), options = {}) {
-  return path.join(resolveProjectRoot(cwd, options), '.impeccable-live', 'annotations');
-}
-
-function firstExisting(paths) {
-  return paths.find((filePath) => fs.existsSync(filePath)) || null;
-}

package/template/.agents/skills/design/impeccable/scripts/lib/is-generated.mjs

@@ -1,72 +0,0 @@
-/**
- * Decide whether a given file is "generated" (regenerated by a build step,
- * unsafe to write variants into) or "source" (safe to edit, changes persist).
- *
- * Why this matters: when the user picks an element on a page whose underlying
- * file is regenerated by a build step (e.g. `scripts/build-sub-pages.js`
- * rewriting `public/docs/*.html`), writing variants or accepted changes into
- * that file is silent data loss — the next build wipes them.
- *
- * Signals, in order of reliability:
- *   1. Git check-ignore: gitignored files are assumed generated.
- *   2. File-header markers ("GENERATED", "DO NOT EDIT", "AUTO-GENERATED")
- *      within the first ~300 characters — catches non-git projects.
- */
-
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-
-const HEADER_SCAN_BYTES = 300;
-const HEADER_MARKERS = [
-  /@generated\b/i,
-  /\bGENERATED\s+FILE\b/,
-  /\bAUTO-?GENERATED\b/i,
-  /\bDO\s+NOT\s+EDIT\b/i,
-];
-
-/**
- * @param {string} filePath - absolute or cwd-relative path
- * @param {object} [options]
- * @param {string} [options.cwd] - project root (defaults to process.cwd())
- */
-export function isGeneratedFile(filePath, options = {}) {
-  const cwd = options.cwd || process.cwd();
-  const absPath = path.isAbsolute(filePath) ? filePath : path.resolve(cwd, filePath);
-
-  if (isGitIgnored(absPath, cwd)) return true;
-  if (hasGeneratedHeader(absPath)) return true;
-  return false;
-}
-
-function isGitIgnored(absPath, cwd) {
-  try {
-    // argv form, never a shell: this runs on every file the live-mode source
-    // walk reaches, so a hostile filename embedding $(...) or backticks must
-    // not be interpretable (issue #476). JSON.stringify is not shell quoting.
-    execFileSync('git', ['check-ignore', '--quiet', absPath], {
-      cwd,
-      stdio: 'ignore',
-    });
-    return true; // exit 0 = ignored
-  } catch (err) {
-    // Exit code 1 = not ignored. Exit code 128 = not a git repo or other error.
-    // In both cases, treat as "not known to be ignored."
-    return false;
-  }
-}
-
-function hasGeneratedHeader(absPath) {
-  let fd;
-  try {
-    fd = fs.openSync(absPath, 'r');
-    const buf = Buffer.alloc(HEADER_SCAN_BYTES);
-    const bytesRead = fs.readSync(fd, buf, 0, HEADER_SCAN_BYTES, 0);
-    const head = buf.slice(0, bytesRead).toString('utf-8');
-    return HEADER_MARKERS.some((re) => re.test(head));
-  } catch {
-    return false;
-  } finally {
-    if (fd !== undefined) { try { fs.closeSync(fd); } catch {} }
-  }
-}

package/template/.agents/skills/design/impeccable/scripts/lib/live-path-globs.mjs

@@ -1,37 +0,0 @@
-/**
- * Convert a live-config glob pattern to a RegExp.
- *
- * Supports `**` across path segments, `*` within one segment, and `?` for one
- * character. Callers normalize project-relative paths to forward slashes.
- */
-export function livePathGlobToRegex(pattern) {
-  let re = '';
-  let i = 0;
-  while (i < pattern.length) {
-    const c = pattern[i];
-    if (c === '*') {
-      if (pattern[i + 1] === '*') {
-        if (pattern[i + 2] === '/') {
-          re += '(?:.*/)?';
-          i += 3;
-        } else {
-          re += '.*';
-          i += 2;
-        }
-      } else {
-        re += '[^/]*';
-        i += 1;
-      }
-    } else if (c === '?') {
-      re += '[^/]';
-      i += 1;
-    } else if (/[.+^${}()|[\]\\]/.test(c)) {
-      re += `\\${c}`;
-      i += 1;
-    } else {
-      re += c;
-      i += 1;
-    }
-  }
-  return new RegExp(`^${re}$`);
-}

package/template/.agents/skills/design/impeccable/scripts/lib/open-system-browser.mjs

@@ -1,26 +0,0 @@
-import { spawn } from 'node:child_process';
-
-export function browserOpenCommand(url, {
-  platform = process.platform,
-  comspec = process.env.ComSpec || process.env.COMSPEC || 'cmd.exe',
-} = {}) {
-  if (platform === 'darwin') return { command: 'open', args: [url] };
-  if (platform === 'win32') return { command: comspec, args: ['/c', 'start', '', url] };
-  return { command: 'xdg-open', args: [url] };
-}
-
-export function openSystemBrowser(url, {
-  platform = process.platform,
-  comspec = process.env.ComSpec || process.env.COMSPEC || 'cmd.exe',
-  spawnImpl = spawn,
-} = {}) {
-  const { command, args } = browserOpenCommand(url, { platform, comspec });
-  try {
-    const child = spawnImpl(command, args, { stdio: 'ignore', detached: true });
-    child.on('error', () => {});
-    child.unref();
-    return true;
-  } catch {
-    return false;
-  }
-}

package/template/.agents/skills/design/impeccable/scripts/lib/png.mjs

@@ -1,281 +0,0 @@
-/**
- * Dependency-free PNG decode/encode for the skill scripts.
- *
- * decodePng(buffer) -> { width, height, data } where data is RGBA8 (Uint8Array,
- * width*height*4). Handles every color type (0, 2, 3, 4, 6), bit depths 1-16
- * (16-bit is reduced to 8), all five filters, and Adam7 interlacing.
- *
- * encodePng({ width, height, data }) -> Buffer, RGBA8 in, 8-bit RGBA PNG out.
- *
- * Kept small on purpose: the skill scripts ship without npm dependencies, and
- * comps (gpt-image PNGs) and screenshots (Playwright / harness PNGs) are the
- * only formats the comp-fidelity tooling has to read.
- */
-import zlib from 'node:zlib';
-import fs from 'node:fs';
-import { execFileSync } from 'node:child_process';
-
-const SIGNATURE = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-
-const crcTable = (() => {
-  const t = new Uint32Array(256);
-  for (let n = 0; n < 256; n++) {
-    let c = n;
-    for (let k = 0; k < 8; k++) c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
-    t[n] = c >>> 0;
-  }
-  return t;
-})();
-
-function crc32(data) {
-  let c = 0xffffffff;
-  for (let i = 0; i < data.length; i++) c = crcTable[(c ^ data[i]) & 0xff] ^ (c >>> 8);
-  return (c ^ 0xffffffff) >>> 0;
-}
-
-export function isPng(buf) {
-  return buf && buf.length > 8 && buf.subarray(0, 8).equals(SIGNATURE);
-}
-
-function readChunks(buf) {
-  const chunks = [];
-  let pos = 8;
-  while (pos + 8 <= buf.length) {
-    const length = buf.readUInt32BE(pos);
-    const type = buf.toString('latin1', pos + 4, pos + 8);
-    const data = buf.subarray(pos + 8, pos + 8 + length);
-    chunks.push({ type, data });
-    pos += 12 + length;
-    if (type === 'IEND') break;
-  }
-  return chunks;
-}
-
-const CHANNELS = { 0: 1, 2: 3, 3: 1, 4: 2, 6: 4 };
-
-function paeth(a, b, c) {
-  const p = a + b - c;
-  const pa = Math.abs(p - a), pb = Math.abs(p - b), pc = Math.abs(p - c);
-  if (pa <= pb && pa <= pc) return a;
-  if (pb <= pc) return b;
-  return c;
-}
-
-/** Unfilter one pass of scanlines in place; returns the raw (unfiltered) bytes. */
-function unfilter(raw, width, height, bpp, bitDepth, channels) {
-  const stride = Math.ceil((width * channels * bitDepth) / 8);
-  const out = new Uint8Array(stride * height);
-  let inPos = 0;
-  let prev = null;
-  for (let y = 0; y < height; y++) {
-    const filter = raw[inPos++];
-    const line = out.subarray(y * stride, (y + 1) * stride);
-    line.set(raw.subarray(inPos, inPos + stride));
-    inPos += stride;
-    switch (filter) {
-      case 0: break;
-      case 1: for (let i = bpp; i < stride; i++) line[i] = (line[i] + line[i - bpp]) & 0xff; break;
-      case 2: if (prev) for (let i = 0; i < stride; i++) line[i] = (line[i] + prev[i]) & 0xff; break;
-      case 3:
-        for (let i = 0; i < stride; i++) {
-          const left = i >= bpp ? line[i - bpp] : 0;
-          const up = prev ? prev[i] : 0;
-          line[i] = (line[i] + ((left + up) >> 1)) & 0xff;
-        }
-        break;
-      case 4:
-        for (let i = 0; i < stride; i++) {
-          const left = i >= bpp ? line[i - bpp] : 0;
-          const up = prev ? prev[i] : 0;
-          const ul = prev && i >= bpp ? prev[i - bpp] : 0;
-          line[i] = (line[i] + paeth(left, up, ul)) & 0xff;
-        }
-        break;
-      default: throw new Error(`png: unknown filter ${filter} on row ${y}`);
-    }
-    prev = line;
-  }
-  return { bytes: out, stride, consumed: inPos };
-}
-
-/** Read sample `index` (0-based across the row) from a packed scanline. */
-function sampleReader(bitDepth) {
-  if (bitDepth === 8) return (line, i) => line[i];
-  if (bitDepth === 16) return (line, i) => line[i * 2]; // high byte
-  const perByte = 8 / bitDepth;
-  const mask = (1 << bitDepth) - 1;
-  const scale = 255 / mask;
-  return (line, i) => {
-    const byte = line[(i / perByte) | 0];
-    const shift = 8 - bitDepth * ((i % perByte) + 1);
-    return Math.round(((byte >> shift) & mask) * scale);
-  };
-}
-
-function writePixels(dst, dstWidth, bytes, stride, passWidth, passHeight, colorType, bitDepth, palette, trns, mapX, mapY) {
-  const channels = CHANNELS[colorType];
-  const read = sampleReader(bitDepth);
-  const rawIndex = bitDepth < 8 ? (line, i) => {
-    const perByte = 8 / bitDepth;
-    const mask = (1 << bitDepth) - 1;
-    const byte = line[(i / perByte) | 0];
-    const shift = 8 - bitDepth * ((i % perByte) + 1);
-    return (byte >> shift) & mask;
-  } : read;
-  for (let y = 0; y < passHeight; y++) {
-    const line = bytes.subarray(y * stride, (y + 1) * stride);
-    const dy = mapY(y);
-    for (let x = 0; x < passWidth; x++) {
-      const dx = mapX(x);
-      const o = (dy * dstWidth + dx) * 4;
-      let r, g, b, a = 255;
-      switch (colorType) {
-        case 0: {
-          r = g = b = read(line, x);
-          if (trns && trns.gray === rawIndex(line, x)) a = 0;
-          break;
-        }
-        case 2: {
-          r = read(line, x * 3); g = read(line, x * 3 + 1); b = read(line, x * 3 + 2);
-          break;
-        }
-        case 3: {
-          const idx = rawIndex(line, x);
-          r = palette[idx * 3]; g = palette[idx * 3 + 1]; b = palette[idx * 3 + 2];
-          if (trns && trns.alpha && idx < trns.alpha.length) a = trns.alpha[idx];
-          break;
-        }
-        case 4: {
-          r = g = b = read(line, x * 2); a = read(line, x * 2 + 1);
-          break;
-        }
-        case 6: {
-          r = read(line, x * 4); g = read(line, x * 4 + 1); b = read(line, x * 4 + 2); a = read(line, x * 4 + 3);
-          break;
-        }
-        default: throw new Error(`png: unsupported color type ${colorType}`);
-      }
-      dst[o] = r; dst[o + 1] = g; dst[o + 2] = b; dst[o + 3] = a;
-    }
-  }
-  return channels;
-}
-
-export function decodePng(buf) {
-  if (!isPng(buf)) throw new Error('png: not a PNG (bad signature)');
-  const chunks = readChunks(buf);
-  const ihdr = chunks.find((c) => c.type === 'IHDR');
-  if (!ihdr) throw new Error('png: missing IHDR');
-  const width = ihdr.data.readUInt32BE(0);
-  const height = ihdr.data.readUInt32BE(4);
-  const bitDepth = ihdr.data[8];
-  const colorType = ihdr.data[9];
-  const interlace = ihdr.data[12];
-  const channels = CHANNELS[colorType];
-  if (!channels) throw new Error(`png: unsupported color type ${colorType}`);
-  const palChunk = chunks.find((c) => c.type === 'PLTE');
-  const palette = palChunk ? palChunk.data : null;
-  const trnsChunk = chunks.find((c) => c.type === 'tRNS');
-  let trns = null;
-  if (trnsChunk) {
-    if (colorType === 3) trns = { alpha: trnsChunk.data };
-    else if (colorType === 0) trns = { gray: trnsChunk.data.readUInt16BE(0) >> (bitDepth === 16 ? 8 : 0) };
-  }
-  const idat = Buffer.concat(chunks.filter((c) => c.type === 'IDAT').map((c) => c.data));
-  const raw = zlib.inflateSync(idat);
-  const bpp = Math.max(1, Math.ceil((channels * bitDepth) / 8));
-  const data = new Uint8Array(width * height * 4);
-  const text = {};
-  for (const c of chunks) {
-    if (c.type === 'tEXt') {
-      const z = c.data.indexOf(0);
-      if (z > 0) text[c.data.toString('latin1', 0, z)] = c.data.toString('utf8', z + 1);
-    }
-  }
-
-  if (interlace === 0) {
-    const { bytes, stride } = unfilter(raw, width, height, bpp, bitDepth, channels);
-    writePixels(data, width, bytes, stride, width, height, colorType, bitDepth, palette, trns, (x) => x, (y) => y);
-  } else {
-    // Adam7
-    const passes = [
-      [0, 0, 8, 8], [4, 0, 8, 8], [0, 4, 4, 8], [2, 0, 4, 4], [0, 2, 2, 4], [1, 0, 2, 2], [0, 1, 1, 2],
-    ];
-    let offset = 0;
-    for (const [sx, sy, dx, dy] of passes) {
-      const pw = Math.ceil((width - sx) / dx);
-      const ph = Math.ceil((height - sy) / dy);
-      if (pw <= 0 || ph <= 0) continue;
-      const { bytes, stride, consumed } = unfilter(raw.subarray(offset), pw, ph, bpp, bitDepth, channels);
-      offset += consumed;
-      writePixels(data, width, bytes, stride, pw, ph, colorType, bitDepth, palette, trns, (x) => sx + x * dx, (y) => sy + y * dy);
-    }
-  }
-  return { width, height, data, text };
-}
-
-function chunk(type, data) {
-  const len = Buffer.alloc(4);
-  len.writeUInt32BE(data.length, 0);
-  const typeBuf = Buffer.from(type, 'latin1');
-  const crc = Buffer.alloc(4);
-  crc.writeUInt32BE(crc32(Buffer.concat([typeBuf, data])), 0);
-  return Buffer.concat([len, typeBuf, data, crc]);
-}
-
-/**
- * Encode RGBA8 to PNG. `text` (optional) is a map of tEXt keyword -> value.
- * Uses filter type 0 on every row: comps and screenshots compress fine and the
- * encoder stays trivial.
- */
-export function encodePng({ width, height, data }, { text = null, level = 6 } = {}) {
-  if (data.length !== width * height * 4) throw new Error(`png: data length ${data.length} != ${width}x${height}x4`);
-  const stride = width * 4;
-  const raw = Buffer.alloc((stride + 1) * height);
-  for (let y = 0; y < height; y++) {
-    raw[y * (stride + 1)] = 0;
-    raw.set(data.subarray(y * stride, (y + 1) * stride), y * (stride + 1) + 1);
-  }
-  const ihdr = Buffer.alloc(13);
-  ihdr.writeUInt32BE(width, 0);
-  ihdr.writeUInt32BE(height, 4);
-  ihdr[8] = 8; ihdr[9] = 6; ihdr[10] = 0; ihdr[11] = 0; ihdr[12] = 0;
-  const parts = [SIGNATURE, chunk('IHDR', ihdr)];
-  if (text) {
-    for (const [k, v] of Object.entries(text)) {
-      parts.push(chunk('tEXt', Buffer.concat([Buffer.from(k, 'latin1'), Buffer.from([0]), Buffer.from(String(v), 'utf8')])));
-    }
-  }
-  parts.push(chunk('IDAT', zlib.deflateSync(raw, { level })));
-  parts.push(chunk('IEND', Buffer.alloc(0)));
-  return Buffer.concat(parts);
-}
-
-/**
- * Read any raster the comp pipeline meets (PNG natively; WebP / JPEG / GIF /
- * AVIF through a converter on PATH) as RGBA. Non-PNG input is converted to a
- * sibling cache file `<name>.<ext>.png` next to the source, never in place:
- * a session that overwrites `comp.webp` with PNG bytes leaves a file the
- * next tool cannot trust and a transcript replay cannot reconstruct.
- * Returns { image, path } where path is the PNG actually decoded.
- */
-export function loadRaster(file) {
-  const buf = fs.readFileSync(file);
-  if (isPng(buf)) return { image: decodePng(buf), path: file };
-  const cache = `${file}.png`;
-  if (fs.existsSync(cache)) {
-    try { const b = fs.readFileSync(cache); if (isPng(b)) return { image: decodePng(b), path: cache }; } catch { /* reconvert */ }
-  }
-  const attempts = [
-    ['dwebp', [file, '-o', cache]],
-    ['sips', ['-s', 'format', 'png', file, '--out', cache]],
-    ['magick', [file, cache]],
-    ['convert', [file, cache]],
-  ];
-  let lastErr = null;
-  for (const [cmd, args] of attempts) {
-    try { execFileSync(cmd, args, { stdio: 'ignore' }); const b = fs.readFileSync(cache); if (isPng(b)) return { image: decodePng(b), path: cache }; }
-    catch (e) { lastErr = e; }
-  }
-  throw new Error(`png: ${file} is not a PNG and no converter (dwebp, sips, magick, convert) could produce ${cache}${lastErr ? `: ${lastErr.message}` : ''}`);
-}

package/template/.agents/skills/design/impeccable/scripts/lib/provider.mjs

@@ -1,5 +0,0 @@
-// Source scripts default to slash commands. The provider build replaces only
-// this exact declaration, avoiding heuristic rewrites across executable code.
-export const IMPECCABLE_COMMAND_PREFIX = "/";
-export const IMPECCABLE_PROVIDER_ID = "pi";
-export const IMPECCABLE_COMMAND = `${IMPECCABLE_COMMAND_PREFIX}impeccable`;