@litfamily/litopencode 1.0.0

package/skills/frontend-ui-ux/scripts/bounded-json.mjs

@@ -0,0 +1,45 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { argumentInvalid, fileInvalid, jsonInvalid } from "./contract-error.mjs";
+import { parseStrictJson } from "./strict-json.mjs";
+
+const decoder = new TextDecoder("utf-8", { fatal: true });
+
+function inside(root, target) {
+  const relative = path.relative(root, target);
+  return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+}
+
+export function parseBoundedJson(buffer, { maxBytes = 1024 * 1024 } = {}) {
+  if (!Buffer.isBuffer(buffer)) throw argumentInvalid("JSON input must be a Buffer");
+  if (!Number.isSafeInteger(maxBytes) || maxBytes < 1) throw argumentInvalid("maxBytes must be a positive integer");
+  if (buffer.length > maxBytes) throw jsonInvalid(`JSON input size ${buffer.length} bytes exceeds ${maxBytes} bytes`);
+  let text;
+  try {
+    text = decoder.decode(buffer);
+  } catch {
+    throw jsonInvalid("JSON input is not valid UTF-8");
+  }
+  return parseStrictJson(text);
+}
+
+export async function readBoundedJsonFile(
+  filePath,
+  { authorizedRoot, maxBytes = 1024 * 1024, validate = (value) => value } = {}
+) {
+  if (typeof filePath !== "string" || filePath.length === 0) throw argumentInvalid("filePath is required");
+  if (typeof authorizedRoot !== "string" || authorizedRoot.length === 0) {
+    throw argumentInvalid("authorizedRoot is required");
+  }
+  const rootPath = path.resolve(authorizedRoot);
+  const requested = path.resolve(filePath);
+  if (!inside(rootPath, requested)) throw fileInvalid("JSON path is outside the authorized root");
+  const root = await fs.realpath(rootPath);
+  const stat = await fs.lstat(requested);
+  if (stat.isSymbolicLink()) throw fileInvalid("JSON path must not be a symlink");
+  if (!stat.isFile()) throw fileInvalid("JSON path must be a regular file, not a device");
+  if (stat.size > maxBytes) throw fileInvalid(`JSON file size ${stat.size} bytes exceeds ${maxBytes} bytes`);
+  const resolved = await fs.realpath(requested);
+  if (!inside(root, resolved)) throw fileInvalid("Resolved JSON path is outside the authorized root");
+  return validate(parseBoundedJson(await fs.readFile(resolved), { maxBytes }));
+}

package/skills/frontend-ui-ux/scripts/canonical-json.mjs

@@ -0,0 +1,26 @@
+function normalize(value, seen) {
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error("Canonical JSON rejects non-finite numbers");
+    return value;
+  }
+  if (Array.isArray(value)) return value.map((entry) => normalize(entry, seen));
+  if (typeof value !== "object") throw new Error(`Canonical JSON rejects ${typeof value}`);
+  if (seen.has(value)) throw new Error("Canonical JSON rejects cyclic input");
+  seen.add(value);
+  const output = {};
+  for (const key of Object.keys(value).sort()) output[key] = normalize(value[key], seen);
+  seen.delete(value);
+  return output;
+}
+
+export function canonicalizeValue(value) {
+  return normalize(value, new Set());
+}
+
+// Canonical form: object keys sorted recursively, array order preserved, and the
+// document terminated by a single newline. Every hash in this system is taken
+// over that exact byte sequence, so the newline is part of the contract.
+export function canonicalJson(value) {
+  return `${JSON.stringify(canonicalizeValue(value))}\n`;
+}

package/skills/frontend-ui-ux/scripts/contract-error.mjs

@@ -0,0 +1,15 @@
+// Trust-layer failures all surface as the same exit code, so the machine-readable
+// `code` is what lets a caller separate a bad payload from an unusable file from a
+// bad argument without matching on prose.
+export class ContractError extends Error {
+  constructor(code, message) {
+    super(`${code}: ${message}`);
+    this.name = "ContractError";
+    this.code = code;
+  }
+}
+
+export const jsonInvalid = (message) => new ContractError("JSON_INVALID", message);
+export const fileInvalid = (message) => new ContractError("FILE_INVALID", message);
+export const argumentInvalid = (message) => new ContractError("ARGUMENT_INVALID", message);
+export const designContractInvalid = (message) => new ContractError("DESIGN_CONTRACT_INVALID", message);

package/skills/frontend-ui-ux/scripts/csv.mjs

@@ -0,0 +1,64 @@
+export function parseRfc4180(text, label = "CSV") {
+  if (typeof text !== "string") throw new TypeError(`${label} must be UTF-8 text`);
+  const rows = [];
+  let row = [];
+  let field = "";
+  let quoted = false;
+  let afterQuote = false;
+  for (let index = 0; index < text.length; index += 1) {
+    const character = text[index];
+    if (quoted) {
+      if (character === '"') {
+        if (text[index + 1] === '"') {
+          field += '"';
+          index += 1;
+        } else {
+          quoted = false;
+          afterQuote = true;
+        }
+      } else {
+        field += character;
+      }
+      continue;
+    }
+    if (afterQuote) {
+      if (character === ",") {
+        row.push(field);
+        field = "";
+        afterQuote = false;
+      } else if (character === "\n") {
+        row.push(field);
+        rows.push(row);
+        row = [];
+        field = "";
+        afterQuote = false;
+      } else {
+        throw new Error(`${label}: unexpected character after closing quote`);
+      }
+      continue;
+    }
+    if (character === '"') {
+      if (field.length === 0) quoted = true;
+      else field += character;
+    } else if (character === ",") {
+      row.push(field);
+      field = "";
+    } else if (character === "\n") {
+      row.push(field);
+      rows.push(row);
+      row = [];
+      field = "";
+    } else {
+      field += character;
+    }
+  }
+  if (quoted) throw new Error(`${label}: unterminated quoted field`);
+  if (afterQuote || field.length > 0 || row.length > 0) {
+    row.push(field);
+    rows.push(row);
+  }
+  if (rows.length === 0) throw new Error(`${label}: empty CSV`);
+  const width = rows[0].length;
+  if (rows.some((candidate) => candidate.length !== width)) throw new Error(`${label}: inconsistent row width`);
+  return rows;
+}

package/skills/frontend-ui-ux/scripts/dataset.mjs

@@ -0,0 +1,65 @@
+import { createHash } from "node:crypto";
+import fs from "node:fs/promises";
+import { parseStrictJson } from "./strict-json.mjs";
+
+export const canonicalDatasetSha256 = "a89011236a6ff14e12ec55fccbfab1bbd40ae34614cea5710c022121aa841bb8";
+export const canonicalDatasetBytes = 1_023_482;
+export const canonicalDatasetRecords = 2_277;
+const maximumDatasetBytes = 4 * 1024 * 1024;
+const datasetUrl = new URL("../data/design-intelligence.json", import.meta.url);
+let canonicalDatasetPromise;
+
+function normalizedExpectedHash(value) {
+  if (value === undefined) return undefined;
+  if (typeof value !== "string") throw new TypeError("expectedSha256 must be a string");
+  const normalized = value.startsWith("sha256:") ? value.slice(7) : value;
+  if (!/^[a-f0-9]{64}$/u.test(normalized)) throw new Error("expectedSha256 must contain 64 lowercase hexadecimal digits");
+  return normalized;
+}
+
+function assertRecord(record, index, ids) {
+  if (record === null || typeof record !== "object" || Array.isArray(record)) {
+    throw new Error(`Malformed design-intelligence dataset record ${index}: expected object`);
+  }
+  if (typeof record.record_id !== "string" || record.record_id === "") {
+    throw new Error(`Malformed design-intelligence dataset record ${index}: missing record_id`);
+  }
+  if (typeof record.domain !== "string" || record.domain === "") {
+    throw new Error(`Malformed design-intelligence dataset record ${index}: missing domain`);
+  }
+  if (ids.has(record.record_id)) throw new Error(`Malformed design-intelligence dataset: duplicate record_id ${record.record_id}`);
+  ids.add(record.record_id);
+}
+
+export async function validateDesignIntelligenceDataset({ data, expectedSha256 } = {}) {
+  const bytes = Buffer.isBuffer(data) ? data : Buffer.from(data ?? "", "utf8");
+  if (bytes.length > maximumDatasetBytes) throw new Error("Design-intelligence dataset exceeds 4 MiB");
+  const expected = normalizedExpectedHash(expectedSha256);
+  if (expected !== undefined) {
+    const actual = createHash("sha256").update(bytes).digest("hex");
+    if (actual !== expected) throw new Error(`Corrupt design-intelligence dataset checksum: expected ${expected}, got ${actual}`);
+  }
+  const parsed = parseStrictJson(bytes.toString("utf8"));
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed) || !Array.isArray(parsed.records)) {
+    throw new Error("Malformed design-intelligence dataset: records array is required");
+  }
+  const ids = new Set();
+  parsed.records.forEach((record, index) => assertRecord(record, index, ids));
+  return parsed;
+}
+
+export async function readCanonicalDesignIntelligence() {
+  canonicalDatasetPromise ??= fs.readFile(datasetUrl).then(async (data) => {
+    if (data.length !== canonicalDatasetBytes) {
+      throw new Error(`Corrupt canonical design-intelligence byte count: expected ${canonicalDatasetBytes}, got ${data.length}`);
+    }
+    const parsed = await validateDesignIntelligenceDataset({ data, expectedSha256: canonicalDatasetSha256 });
+    if (parsed.records.length !== canonicalDatasetRecords) {
+      throw new Error(
+        `Corrupt canonical design-intelligence record count: expected ${canonicalDatasetRecords}, got ${parsed.records.length}`
+      );
+    }
+    return parsed;
+  });
+  return canonicalDatasetPromise;
+}