@iowarp/clio-coder 0.4.9 → 0.5.0

package/dist/chunk-YBUECLAF.js

@@ -0,0 +1,618 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  expandConfigPath
+} from "./chunk-VNBICSS2.js";
+import {
+  StringEnum
+} from "./chunk-L7G7K4I2.js";
+import {
+  VERIFICATION_SCRIPT_FAMILY_HINT
+} from "./chunk-M4KFUXS7.js";
+import {
+  ToolNames
+} from "./chunk-V4XJWDHR.js";
+import {
+  typebox_exports
+} from "./chunk-GH5ZR6JP.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/core/file-references.ts
+init_esm_shims();
+import { existsSync, readFileSync, statSync } from "node:fs";
+import path2 from "node:path";
+
+// src/utils/image-resize.ts
+init_esm_shims();
+
+// src/utils/exif-orientation.ts
+init_esm_shims();
+function byte(bytes, offset) {
+  return bytes[offset] ?? 0;
+}
+function readOrientationFromTiff(bytes, tiffStart) {
+  if (tiffStart + 8 > bytes.length) return 1;
+  const byteOrder = byte(bytes, tiffStart) << 8 | byte(bytes, tiffStart + 1);
+  const le = byteOrder === 18761;
+  const read16 = (pos) => {
+    if (le) return byte(bytes, pos) | byte(bytes, pos + 1) << 8;
+    return byte(bytes, pos) << 8 | byte(bytes, pos + 1);
+  };
+  const read32 = (pos) => {
+    if (le) {
+      return byte(bytes, pos) | byte(bytes, pos + 1) << 8 | byte(bytes, pos + 2) << 16 | byte(bytes, pos + 3) << 24;
+    }
+    return (byte(bytes, pos) << 24 | byte(bytes, pos + 1) << 16 | byte(bytes, pos + 2) << 8 | byte(bytes, pos + 3)) >>> 0;
+  };
+  const ifdOffset = read32(tiffStart + 4);
+  const ifdStart = tiffStart + ifdOffset;
+  if (ifdStart + 2 > bytes.length) return 1;
+  const entryCount = read16(ifdStart);
+  for (let i = 0; i < entryCount; i++) {
+    const entryPos = ifdStart + 2 + i * 12;
+    if (entryPos + 12 > bytes.length) return 1;
+    if (read16(entryPos) === 274) {
+      const value = read16(entryPos + 8);
+      return value >= 1 && value <= 8 ? value : 1;
+    }
+  }
+  return 1;
+}
+function hasExifHeader(bytes, offset) {
+  return byte(bytes, offset) === 69 && byte(bytes, offset + 1) === 120 && byte(bytes, offset + 2) === 105 && byte(bytes, offset + 3) === 102 && byte(bytes, offset + 4) === 0 && byte(bytes, offset + 5) === 0;
+}
+function findJpegTiffOffset(bytes) {
+  let offset = 2;
+  while (offset < bytes.length - 1) {
+    if (byte(bytes, offset) !== 255) return -1;
+    const marker = byte(bytes, offset + 1);
+    if (marker === 255) {
+      offset++;
+      continue;
+    }
+    if (marker === 225) {
+      if (offset + 4 >= bytes.length) return -1;
+      const segmentStart = offset + 4;
+      if (segmentStart + 6 > bytes.length) return -1;
+      if (!hasExifHeader(bytes, segmentStart)) return -1;
+      return segmentStart + 6;
+    }
+    if (offset + 4 > bytes.length) return -1;
+    const length = byte(bytes, offset + 2) << 8 | byte(bytes, offset + 3);
+    offset += 2 + length;
+  }
+  return -1;
+}
+function findWebpTiffOffset(bytes) {
+  let offset = 12;
+  while (offset + 8 <= bytes.length) {
+    const chunkId = String.fromCharCode(
+      byte(bytes, offset),
+      byte(bytes, offset + 1),
+      byte(bytes, offset + 2),
+      byte(bytes, offset + 3)
+    );
+    const chunkSize = byte(bytes, offset + 4) | byte(bytes, offset + 5) << 8 | byte(bytes, offset + 6) << 16 | byte(bytes, offset + 7) << 24;
+    const dataStart = offset + 8;
+    if (chunkId === "EXIF") {
+      if (dataStart + chunkSize > bytes.length) return -1;
+      return chunkSize >= 6 && hasExifHeader(bytes, dataStart) ? dataStart + 6 : dataStart;
+    }
+    offset = dataStart + chunkSize + chunkSize % 2;
+  }
+  return -1;
+}
+function getExifOrientation(bytes) {
+  let tiffOffset = -1;
+  if (bytes.length >= 2 && byte(bytes, 0) === 255 && byte(bytes, 1) === 216) {
+    tiffOffset = findJpegTiffOffset(bytes);
+  } else if (bytes.length >= 12 && byte(bytes, 0) === 82 && byte(bytes, 1) === 73 && byte(bytes, 2) === 70 && byte(bytes, 3) === 70 && byte(bytes, 8) === 87 && byte(bytes, 9) === 69 && byte(bytes, 10) === 66 && byte(bytes, 11) === 80) {
+    tiffOffset = findWebpTiffOffset(bytes);
+  }
+  if (tiffOffset === -1) return 1;
+  return readOrientationFromTiff(bytes, tiffOffset);
+}
+function rotate90(photon, image, dstIndex) {
+  const w = image.get_width();
+  const h = image.get_height();
+  const src = image.get_raw_pixels();
+  const dst = new Uint8Array(src.length);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      const srcIdx = (y * w + x) * 4;
+      const dstIdx = dstIndex(x, y, w, h) * 4;
+      dst[dstIdx] = src[srcIdx] ?? 0;
+      dst[dstIdx + 1] = src[srcIdx + 1] ?? 0;
+      dst[dstIdx + 2] = src[srcIdx + 2] ?? 0;
+      dst[dstIdx + 3] = src[srcIdx + 3] ?? 0;
+    }
+  }
+  return new photon.PhotonImage(dst, h, w);
+}
+function applyExifOrientation(photon, image, originalBytes) {
+  const orientation = getExifOrientation(originalBytes);
+  if (orientation === 1) return image;
+  switch (orientation) {
+    case 2:
+      photon.fliph(image);
+      return image;
+    case 3:
+      photon.fliph(image);
+      photon.flipv(image);
+      return image;
+    case 4:
+      photon.flipv(image);
+      return image;
+    case 5: {
+      const rotated = rotate90(photon, image, (x, y, _w, h) => x * h + (h - 1 - y));
+      photon.fliph(rotated);
+      return rotated;
+    }
+    case 6:
+      return rotate90(photon, image, (x, y, _w, h) => x * h + (h - 1 - y));
+    case 7: {
+      const rotated = rotate90(photon, image, (x, y, w, h) => (w - 1 - x) * h + y);
+      photon.fliph(rotated);
+      return rotated;
+    }
+    case 8:
+      return rotate90(photon, image, (x, y, w, h) => (w - 1 - x) * h + y);
+    default:
+      return image;
+  }
+}
+
+// src/utils/photon.ts
+init_esm_shims();
+import { createRequire } from "node:module";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var require2 = createRequire(import.meta.url);
+var fs = require2("node:fs");
+var WASM_FILENAME = "photon_rs_bg.wasm";
+var photonModule = null;
+var loadPromise = null;
+function pathOrNull(file) {
+  if (typeof file === "string") return file;
+  if (file instanceof URL) return fileURLToPath(file);
+  return null;
+}
+function getFallbackWasmPaths() {
+  const execDir = path.dirname(process.execPath);
+  return [
+    path.join(execDir, WASM_FILENAME),
+    path.join(execDir, "photon", WASM_FILENAME),
+    path.join(process.cwd(), WASM_FILENAME)
+  ];
+}
+function patchPhotonWasmRead() {
+  const originalReadFileSync = fs.readFileSync.bind(fs);
+  const fallbackPaths = getFallbackWasmPaths();
+  const mutableFs = fs;
+  const patchedReadFileSync = ((...args) => {
+    const [file, options] = args;
+    const resolvedPath = pathOrNull(file);
+    if (resolvedPath?.endsWith(WASM_FILENAME)) {
+      try {
+        return originalReadFileSync(...args);
+      } catch (error) {
+        const err = error;
+        if (err?.code && err.code !== "ENOENT") throw error;
+        for (const fallbackPath of fallbackPaths) {
+          if (!fs.existsSync(fallbackPath)) continue;
+          if (options === void 0) return originalReadFileSync(fallbackPath);
+          return originalReadFileSync(fallbackPath, options);
+        }
+        throw error;
+      }
+    }
+    return originalReadFileSync(...args);
+  });
+  try {
+    mutableFs.readFileSync = patchedReadFileSync;
+  } catch {
+    Object.defineProperty(fs, "readFileSync", {
+      value: patchedReadFileSync,
+      writable: true,
+      configurable: true
+    });
+  }
+  return () => {
+    try {
+      mutableFs.readFileSync = originalReadFileSync;
+    } catch {
+      Object.defineProperty(fs, "readFileSync", {
+        value: originalReadFileSync,
+        writable: true,
+        configurable: true
+      });
+    }
+  };
+}
+async function loadPhoton() {
+  if (photonModule) return photonModule;
+  if (loadPromise) return loadPromise;
+  loadPromise = (async () => {
+    const restoreReadFileSync = patchPhotonWasmRead();
+    try {
+      photonModule = await import("@silvia-odwyer/photon-node");
+      return photonModule;
+    } catch {
+      photonModule = null;
+      return photonModule;
+    } finally {
+      restoreReadFileSync();
+    }
+  })();
+  return loadPromise;
+}
+
+// src/utils/image-resize.ts
+var DEFAULT_MAX_BYTES = 4.5 * 1024 * 1024;
+var DEFAULT_OPTIONS = {
+  maxWidth: 2e3,
+  maxHeight: 2e3,
+  maxBytes: DEFAULT_MAX_BYTES,
+  jpegQuality: 80
+};
+function encodeCandidate(buffer, mimeType) {
+  const data = Buffer.from(buffer).toString("base64");
+  return {
+    data,
+    encodedSize: Buffer.byteLength(data, "utf-8"),
+    mimeType
+  };
+}
+async function resizeImage(img, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const inputBuffer = Buffer.from(img.data, "base64");
+  const inputBase64Size = Buffer.byteLength(img.data, "utf-8");
+  const photon = await loadPhoton();
+  if (!photon) return null;
+  const loadedPhoton = photon;
+  let image;
+  try {
+    let tryEncodings2 = function(width, height, jpegQualities) {
+      const resized = loadedPhoton.resize(loadedImage, width, height, loadedPhoton.SamplingFilter.Lanczos3);
+      try {
+        const candidates = [encodeCandidate(resized.get_bytes(), "image/png")];
+        for (const quality of jpegQualities) {
+          candidates.push(encodeCandidate(resized.get_bytes_jpeg(quality), "image/jpeg"));
+        }
+        return candidates;
+      } finally {
+        resized.free();
+      }
+    };
+    var tryEncodings = tryEncodings2;
+    const inputBytes = new Uint8Array(inputBuffer);
+    const rawImage = photon.PhotonImage.new_from_byteslice(inputBytes);
+    image = applyExifOrientation(photon, rawImage, inputBytes);
+    if (image !== rawImage) rawImage.free();
+    const originalWidth = image.get_width();
+    const originalHeight = image.get_height();
+    const format = img.mimeType?.split("/")[1] ?? "png";
+    if (originalWidth <= opts.maxWidth && originalHeight <= opts.maxHeight && inputBase64Size < opts.maxBytes) {
+      return {
+        data: img.data,
+        mimeType: img.mimeType ?? `image/${format}`,
+        originalWidth,
+        originalHeight,
+        width: originalWidth,
+        height: originalHeight,
+        wasResized: false
+      };
+    }
+    let targetWidth = originalWidth;
+    let targetHeight = originalHeight;
+    if (targetWidth > opts.maxWidth) {
+      targetHeight = Math.round(targetHeight * opts.maxWidth / targetWidth);
+      targetWidth = opts.maxWidth;
+    }
+    if (targetHeight > opts.maxHeight) {
+      targetWidth = Math.round(targetWidth * opts.maxHeight / targetHeight);
+      targetHeight = opts.maxHeight;
+    }
+    const loadedImage = image;
+    const qualitySteps = Array.from(/* @__PURE__ */ new Set([opts.jpegQuality, 85, 70, 55, 40]));
+    let currentWidth = targetWidth;
+    let currentHeight = targetHeight;
+    while (true) {
+      const candidates = tryEncodings2(currentWidth, currentHeight, qualitySteps);
+      for (const candidate of candidates) {
+        if (candidate.encodedSize < opts.maxBytes) {
+          return {
+            data: candidate.data,
+            mimeType: candidate.mimeType,
+            originalWidth,
+            originalHeight,
+            width: currentWidth,
+            height: currentHeight,
+            wasResized: true
+          };
+        }
+      }
+      if (currentWidth === 1 && currentHeight === 1) break;
+      const nextWidth = currentWidth === 1 ? 1 : Math.max(1, Math.floor(currentWidth * 0.75));
+      const nextHeight = currentHeight === 1 ? 1 : Math.max(1, Math.floor(currentHeight * 0.75));
+      if (nextWidth === currentWidth && nextHeight === currentHeight) break;
+      currentWidth = nextWidth;
+      currentHeight = nextHeight;
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    if (image) image.free();
+  }
+}
+function formatDimensionNote(result2) {
+  if (!result2.wasResized) return void 0;
+  const scale = result2.originalWidth / result2.width;
+  return `[Image: original ${result2.originalWidth}x${result2.originalHeight}, displayed at ${result2.width}x${result2.height}. Multiply coordinates by ${scale.toFixed(2)} to map to original image.]`;
+}
+
+// src/core/file-references.ts
+var DEFAULT_IMAGE_MAX_BASE64_BYTES = 4.5 * 1024 * 1024;
+function decodeQuotedFileArg(input, start, quote) {
+  let value = "";
+  let escaped = false;
+  for (let index = start; index < input.length; index += 1) {
+    const character = input[index] ?? "";
+    if (escaped) {
+      value += character;
+      escaped = false;
+      continue;
+    }
+    if (character === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (character === quote) return { value, end: index + 1 };
+    value += character;
+  }
+  return null;
+}
+function inlineFileReferences(input) {
+  const references = [];
+  for (let start = 0; start < input.length; start += 1) {
+    if (input[start] !== "@" || start > 0 && !/\s/u.test(input[start - 1] ?? "")) continue;
+    const next = input[start + 1];
+    if (next === '"' || next === "'") {
+      const decoded = decodeQuotedFileArg(input, start + 2, next);
+      if (!decoded || decoded.value.length === 0) continue;
+      references.push({
+        start,
+        end: decoded.end,
+        raw: input.slice(start, decoded.end),
+        fileArg: decoded.value,
+        quoted: true
+      });
+      start = decoded.end - 1;
+      continue;
+    }
+    let end = start + 1;
+    while (end < input.length && !/\s/u.test(input[end] ?? "")) end += 1;
+    if (end === start + 1) continue;
+    references.push({
+      start,
+      end,
+      raw: input.slice(start, end),
+      fileArg: input.slice(start + 1, end),
+      quoted: false
+    });
+    start = end - 1;
+  }
+  return references;
+}
+function renderTextFile(filePath, content) {
+  return `<file name="${filePath}">
+${content}
+</file>
+`;
+}
+function renderImageFile(filePath, content = "") {
+  return `<file name="${filePath}">${content}</file>
+`;
+}
+function result(text, diagnostics = [], images = [], referencedPaths = []) {
+  return { text, diagnostics, images, referencedPaths };
+}
+function detectSupportedImageMimeType(bytes) {
+  if (bytes.length >= 8 && bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10]))) {
+    return "image/png";
+  }
+  if (bytes.length >= 3 && bytes[0] === 255 && bytes[1] === 216 && bytes[2] === 255) {
+    return "image/jpeg";
+  }
+  const signature = bytes.subarray(0, 6).toString("ascii");
+  if (signature === "GIF87a" || signature === "GIF89a") return "image/gif";
+  if (bytes.length >= 12 && bytes.subarray(0, 4).toString("ascii") === "RIFF" && bytes.subarray(8, 12).toString("ascii") === "WEBP") {
+    return "image/webp";
+  }
+  return null;
+}
+async function prepareBoundedImage(bytes, maxBytes) {
+  const mimeType = detectSupportedImageMimeType(bytes);
+  if (mimeType === null || maxBytes <= 0) return null;
+  const original = { type: "image", mimeType, data: bytes.toString("base64") };
+  const resized = await resizeImage(original, { maxBytes });
+  if (resized) return { type: "image", mimeType: resized.mimeType, data: resized.data };
+  return Buffer.byteLength(original.data) <= maxBytes ? original : null;
+}
+async function readFileReferenceAsync(fileArg, options) {
+  const filePath = expandConfigPath(fileArg, options.cwd === void 0 ? void 0 : { cwd: options.cwd });
+  if (!existsSync(filePath)) {
+    if (options.missing === "leave") return result(`@${fileArg}`);
+    return result("", [{ type: "error", message: `file not found: ${filePath}`, path: filePath }]);
+  }
+  let stat;
+  try {
+    stat = statSync(filePath);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return result("", [{ type: "error", message: `file could not be stat'ed: ${reason}`, path: filePath }]);
+  }
+  if (!stat.isFile()) {
+    return result("", [{ type: "error", message: `not a file: ${filePath}`, path: filePath }]);
+  }
+  if (stat.size === 0) return result("", [], [], [filePath]);
+  try {
+    const bytes = readFileSync(filePath);
+    const imageMimeType = detectSupportedImageMimeType(bytes);
+    if (imageMimeType) {
+      if (options.includeImages !== true) return result(`@${fileArg}`);
+      const originalImage = {
+        type: "image",
+        mimeType: imageMimeType,
+        data: bytes.toString("base64")
+      };
+      if (options.autoResizeImages === false) {
+        return result(renderImageFile(filePath), [], [originalImage], [filePath]);
+      }
+      const resized = await resizeImage(originalImage);
+      if (!resized) {
+        if (Buffer.byteLength(originalImage.data, "utf-8") < DEFAULT_IMAGE_MAX_BASE64_BYTES) {
+          return result(renderImageFile(filePath), [], [originalImage], [filePath]);
+        }
+        return result(
+          renderImageFile(filePath, "[Image omitted: could not be resized below the inline image size limit.]"),
+          [],
+          [],
+          [filePath]
+        );
+      }
+      return result(
+        renderImageFile(filePath, formatDimensionNote(resized)),
+        [],
+        [{ type: "image", mimeType: resized.mimeType, data: resized.data }],
+        [filePath]
+      );
+    }
+    return result(renderTextFile(filePath, bytes.toString("utf8")), [], [], [filePath]);
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    return result("", [{ type: "error", message: `file could not be read: ${reason}`, path: filePath }]);
+  }
+}
+async function readFileArgsAsync(fileArgs, options = {}) {
+  const diagnostics = [];
+  const images = [];
+  const referencedPaths = [];
+  let text = "";
+  for (const fileArg of fileArgs) {
+    const ref = await readFileReferenceAsync(fileArg, {
+      ...options,
+      missing: options.missing ?? "error",
+      includeImages: true
+    });
+    text += ref.text;
+    images.push(...ref.images);
+    diagnostics.push(...ref.diagnostics);
+    referencedPaths.push(...ref.referencedPaths);
+  }
+  return { text, images, diagnostics, referencedPaths };
+}
+function splitTrailingPunctuation(token) {
+  const match = token.match(/^(.+?)([),.;:!?]+)$/);
+  if (!match?.[1] || !match[2]) return { fileArg: token, suffix: "" };
+  const candidate = match[1];
+  const suffix = match[2];
+  const ext = path2.extname(candidate);
+  if (ext.length === 0 && suffix.startsWith(".")) return { fileArg: token, suffix: "" };
+  return { fileArg: candidate, suffix };
+}
+async function expandInlineFileReferencesAsync(input, options = {}) {
+  const diagnostics = [];
+  const images = [];
+  const referencedPaths = [];
+  let text = "";
+  let lastIndex = 0;
+  for (const reference of inlineFileReferences(input)) {
+    text += input.slice(lastIndex, reference.start);
+    const direct = await readFileReferenceAsync(reference.fileArg, {
+      ...options,
+      missing: "leave",
+      includeImages: options.includeImages === true
+    });
+    if (direct.text !== `@${reference.fileArg}`) {
+      diagnostics.push(...direct.diagnostics);
+      images.push(...direct.images);
+      referencedPaths.push(...direct.referencedPaths);
+      text += direct.text;
+      lastIndex = reference.end;
+      continue;
+    }
+    const { fileArg, suffix } = reference.quoted ? { fileArg: reference.fileArg, suffix: "" } : splitTrailingPunctuation(reference.fileArg);
+    if (fileArg === reference.fileArg) {
+      text += reference.raw;
+      lastIndex = reference.end;
+      continue;
+    }
+    const stripped = await readFileReferenceAsync(fileArg, {
+      ...options,
+      missing: "leave",
+      includeImages: options.includeImages === true
+    });
+    if (stripped.text === `@${fileArg}`) {
+      text += reference.raw;
+      lastIndex = reference.end;
+      continue;
+    }
+    diagnostics.push(...stripped.diagnostics);
+    images.push(...stripped.images);
+    referencedPaths.push(...stripped.referencedPaths);
+    text += `${stripped.text}${suffix}`;
+    lastIndex = reference.end;
+  }
+  text += input.slice(lastIndex);
+  return { text, images, diagnostics, referencedPaths };
+}
+
+// src/tools/verify/surface.ts
+init_esm_shims();
+var BROWSER_MODES = ["auto", "required", "off"];
+function prepareVerifyArguments(args) {
+  if (!args || typeof args !== "object" || Array.isArray(args)) return args;
+  const next = { ...args };
+  if (typeof next.args === "string") {
+    try {
+      const parsed = JSON.parse(next.args);
+      if (Array.isArray(parsed)) next.args = parsed;
+    } catch {
+    }
+  }
+  return next;
+}
+var verifyToolSurface = {
+  name: ToolNames.Verify,
+  description: 'Run a declared verification check: no arguments lists package scripts and .clio-coder/verifiers.yaml entries, check=<id> runs one, and check="frontend" with path validates an HTML/CSS/JS artifact.',
+  parameters: typebox_exports.Object({
+    check: typebox_exports.Optional(
+      typebox_exports.String({
+        description: `Check id, package script (${VERIFICATION_SCRIPT_FAMILY_HINT}), or "frontend"; omit to list.`
+      })
+    ),
+    path: typebox_exports.Optional(typebox_exports.String({ description: "frontend: artifact file under the workspace root." })),
+    args: typebox_exports.Optional(typebox_exports.Array(typebox_exports.String(), { description: "Package scripts only: arguments after --." })),
+    browser: typebox_exports.Optional(StringEnum(BROWSER_MODES, { description: "frontend: headless browser mode (default auto)." })),
+    cwd: typebox_exports.Optional(typebox_exports.String({ description: "Package scripts only: working directory." })),
+    timeout_ms: typebox_exports.Optional(typebox_exports.Number({ description: "Package and frontend checks only: timeout in ms." })),
+    max_output_bytes: typebox_exports.Optional(typebox_exports.Number({ description: "Output cap in bytes (default 600000)." }))
+  }),
+  baseActionClass: "execute",
+  executionMode: "sequential",
+  prepareArguments: prepareVerifyArguments
+};
+
+export {
+  detectSupportedImageMimeType,
+  prepareBoundedImage,
+  readFileArgsAsync,
+  expandInlineFileReferencesAsync,
+  BROWSER_MODES,
+  prepareVerifyArguments,
+  verifyToolSurface
+};
+//# sourceMappingURL=chunk-YBUECLAF.js.map