@iowarp/clio-coder 0.4.7 → 0.4.9

package/dist/chunk-PPIFDSBK.js

@@ -0,0 +1,409 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  resolveToCwd
+} from "./chunk-KP5BPXR3.js";
+import {
+  ToolNames
+} from "./chunk-V4XJWDHR.js";
+import {
+  StringEnum
+} from "./chunk-UIU7MGZ3.js";
+import {
+  typebox_exports
+} from "./chunk-GH5ZR6JP.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/tools/data/shared.ts
+init_esm_shims();
+import { createReadStream, statSync } from "node:fs";
+var DATA_FORMATS = ["csv", "tsv", "json", "jsonl"];
+function isDataFormat(value) {
+  return typeof value === "string" && DATA_FORMATS.includes(value);
+}
+function exactView() {
+  return { exact: true, sampled: false, converted: false };
+}
+function sampledView() {
+  return { exact: false, sampled: true, converted: false };
+}
+function cutView() {
+  return { exact: false, sampled: false, converted: false };
+}
+var DataRefusalError = class extends Error {
+  refusal;
+  constructor(refusal2) {
+    super(refusal2.message);
+    this.name = "DataRefusalError";
+    this.refusal = refusal2;
+  }
+};
+function refusal(reason, message, extra = {}) {
+  return { ok: false, reason, message, ...extra };
+}
+function isDataRefusal(value) {
+  return typeof value === "object" && value !== null && value.ok === false && typeof value.reason === "string";
+}
+function refusalFromError(error, path, signal) {
+  if (error instanceof DataRefusalError) return { ...error.refusal, path };
+  if (signal?.aborted) return refusal("aborted", "aborted before the scan finished", { path });
+  const code = error?.code;
+  if (code === "ENOENT") return refusal("not-found", `no file at ${path}`, { path });
+  if (code === "EISDIR") return refusal("not-a-file", `${path} is a directory, not a data file`, { path });
+  const message = error instanceof Error ? error.message : String(error);
+  return refusal("read-error", `cannot read ${path}: ${message}`, { path });
+}
+function abortedRefusal(path) {
+  return refusal("aborted", "aborted before the scan finished", { path });
+}
+function throwIfAborted(signal, path) {
+  if (signal?.aborted) throw new DataRefusalError(abortedRefusal(path));
+}
+function statDataFile(path) {
+  try {
+    const stat = statSync(path);
+    if (!stat.isFile()) return refusal("not-a-file", `${path} is not a regular file`, { path });
+    return { size: stat.size };
+  } catch (error) {
+    return refusalFromError(error, path);
+  }
+}
+var UTF8_LEAD_MIN = 194;
+var Utf8StreamDecoder = class {
+  pending = null;
+  /** Absolute byte offset of the first byte not yet decoded (the pending start). */
+  offset = 0;
+  /** Absolute byte offset of the first byte the next decoded text will begin at. */
+  get position() {
+    return this.offset;
+  }
+  push(chunk) {
+    const buffer = this.pending === null ? chunk : Buffer.concat([this.pending, chunk]);
+    const length = buffer.length;
+    let index = 0;
+    while (index < length) {
+      const lead = buffer[index];
+      if (lead < 128) {
+        index += 1;
+        continue;
+      }
+      let need;
+      let secondMin = 128;
+      let secondMax = 191;
+      if (lead >= UTF8_LEAD_MIN && lead <= 223) need = 2;
+      else if (lead === 224) {
+        need = 3;
+        secondMin = 160;
+      } else if (lead >= 225 && lead <= 236) need = 3;
+      else if (lead === 237) {
+        need = 3;
+        secondMax = 159;
+      } else if (lead >= 238 && lead <= 239) need = 3;
+      else if (lead === 240) {
+        need = 4;
+        secondMin = 144;
+      } else if (lead >= 241 && lead <= 243) need = 4;
+      else if (lead === 244) {
+        need = 4;
+        secondMax = 143;
+      } else {
+        throw this.invalid(index);
+      }
+      if (index + need > length) {
+        const second2 = buffer[index + 1];
+        if (second2 !== void 0 && (second2 < secondMin || second2 > secondMax)) throw this.invalid(index);
+        for (let k = 2; index + k < length; k += 1) {
+          const byte = buffer[index + k];
+          if (byte < 128 || byte > 191) throw this.invalid(index);
+        }
+        break;
+      }
+      const second = buffer[index + 1];
+      if (second < secondMin || second > secondMax) throw this.invalid(index);
+      for (let k = 2; k < need; k += 1) {
+        const byte = buffer[index + k];
+        if (byte < 128 || byte > 191) throw this.invalid(index);
+      }
+      index += need;
+    }
+    const text = buffer.toString("utf8", 0, index);
+    this.pending = index < length ? Buffer.from(buffer.subarray(index)) : null;
+    this.offset += index;
+    return text;
+  }
+  end() {
+    if (this.pending !== null) throw this.invalid(0);
+  }
+  invalid(relativeIndex) {
+    const byteOffset = this.offset + relativeIndex;
+    return new DataRefusalError(
+      refusal(
+        "invalid-utf8",
+        `invalid UTF-8 sequence starting at byte offset ${byteOffset}; this is not a UTF-8 text file`,
+        {
+          byteOffset
+        }
+      )
+    );
+  }
+};
+var BINARY_SNIFF_BYTES = 8192;
+var DEFAULT_HIGH_WATER_MARK = 64 * 1024;
+async function* streamTextChunks(path, options) {
+  const { signal, stats } = options;
+  throwIfAborted(signal, path);
+  const stream = createReadStream(path, { highWaterMark: options.highWaterMark ?? DEFAULT_HIGH_WATER_MARK });
+  const onAbort = () => {
+    stream.destroy(new DataRefusalError(abortedRefusal(path)));
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+  const decoder = new Utf8StreamDecoder();
+  let sniffRemaining = BINARY_SNIFF_BYTES;
+  let first = true;
+  try {
+    for await (const raw of stream) {
+      const chunk = raw;
+      throwIfAborted(signal, path);
+      stats.bytesRead += chunk.length;
+      if (sniffRemaining > 0) {
+        const probe = chunk.subarray(0, Math.min(sniffRemaining, chunk.length));
+        const nul = probe.indexOf(0);
+        if (nul !== -1) {
+          throw new DataRefusalError(
+            refusal("binary", `NUL byte at offset ${stats.bytesRead - chunk.length + nul}; this is a binary file`, {
+              byteOffset: stats.bytesRead - chunk.length + nul
+            })
+          );
+        }
+        sniffRemaining -= probe.length;
+      }
+      let byteOffset = decoder.position;
+      let text = decoder.push(chunk);
+      if (first) {
+        first = false;
+        if (text.startsWith("\uFEFF")) {
+          stats.bom = true;
+          text = text.slice(1);
+          byteOffset += 3;
+        }
+      }
+      if (text.length > 0) yield { text, byteOffset };
+    }
+    decoder.end();
+  } catch (error) {
+    throw error instanceof DataRefusalError ? error : new DataRefusalError(refusalFromError(error, path, signal));
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    stream.destroy();
+  }
+}
+var SENTINEL_TOKENS = /* @__PURE__ */ new Set(["NA", "N/A", "NaN", "null", "NULL", "None", "-"]);
+var INTEGER_PATTERN = /^[+-]?\d+$/u;
+var FLOAT_PATTERN = /^[+-]?(?:\d+\.\d*|\.\d+|\d+)(?:[eE][+-]?\d+)?$/u;
+var BOOLEAN_PATTERN = /^(?:true|false)$/iu;
+var DATE_PATTERN = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/u;
+function classifyCell(text) {
+  if (text.length === 0) return "empty";
+  if (SENTINEL_TOKENS.has(text)) return "sentinel";
+  if (INTEGER_PATTERN.test(text)) return "integer";
+  if (FLOAT_PATTERN.test(text)) return "float";
+  if (BOOLEAN_PATTERN.test(text)) return "boolean";
+  if (DATE_PATTERN.test(text)) return "date";
+  return "string";
+}
+function emptyCellHistogram() {
+  return { empty: 0, sentinel: 0, integer: 0, float: 0, boolean: 0, date: 0, string: 0 };
+}
+function inferColumnType(histogram) {
+  const typed = ["integer", "float", "boolean", "date", "string"].filter((cls) => histogram[cls] > 0);
+  if (typed.length === 0) return "empty";
+  if (typed.length === 1) return typed[0];
+  if (typed.every((cls) => cls === "integer" || cls === "float")) return "float";
+  return "mixed";
+}
+var MAX_SIGNIFICANT_DIGITS = 17;
+var MAX_NUMBER_LITERAL_CHARS = 512;
+function canonicalDecimal(literal) {
+  const match = /^([+-]?)(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/u.exec(literal);
+  if (match === null) return null;
+  const intDigits = match[2] ?? "";
+  const fracDigits = match[3] ?? "";
+  if (intDigits.length === 0 && fracDigits.length === 0) return null;
+  let digits = (intDigits + fracDigits).replace(/^0+/u, "");
+  if (digits.length === 0) return "0";
+  let exponent = Number(match[4] ?? "0") - fracDigits.length;
+  const trimmed = digits.replace(/0+$/u, "");
+  exponent += digits.length - trimmed.length;
+  digits = trimmed;
+  return `${match[1] === "-" ? "-" : ""}${digits}e${exponent}`;
+}
+function numberLiteralPrecision(literal) {
+  if (literal.length > MAX_NUMBER_LITERAL_CHARS) return "oversized-literal";
+  const canonical = canonicalDecimal(literal);
+  if (canonical === null) return null;
+  const value = Number(literal);
+  if (!Number.isFinite(value)) return "overflow";
+  if (value === 0) return canonical === "0" ? null : "underflow";
+  if (canonical === canonicalDecimal(String(value))) return null;
+  const exponentAt = canonical.indexOf("e");
+  const digits = canonical.slice(canonical.startsWith("-") ? 1 : 0, exponentAt);
+  const exponent = Number(canonical.slice(exponentAt + 1));
+  if (exponent >= 0 && Math.abs(value) > Number.MAX_SAFE_INTEGER) return "unsafe-integer";
+  if (digits.length > MAX_SIGNIFICANT_DIGITS) return "excess-digits";
+  return "inexact";
+}
+function resolveMaxRows(value, fallback) {
+  if (value === void 0) return fallback;
+  if (value === null || !Number.isFinite(value)) return Number.POSITIVE_INFINITY;
+  return Math.max(1, Math.floor(value));
+}
+var SAMPLE_TEXT_CAP = 512;
+function capText(text, cap = SAMPLE_TEXT_CAP) {
+  if (text.length <= cap) return { text, truncated: false };
+  return { text: `${Array.from(text).slice(0, cap).join("")}\u2026`, truncated: true };
+}
+function sampledNotice(rowsScanned, unit) {
+  return `sampled: ${rowsScanned} ${unit} scanned of an unknown total; counts are lower bounds and rowCount is null`;
+}
+function histogramRecord(map) {
+  const out = {};
+  for (const [key, count] of map) out[key] = count;
+  return out;
+}
+
+// src/tools/gateway/data-surface.ts
+init_esm_shims();
+var DATA_TOOL_NAME = ToolNames.Data;
+var DATA_OPS = ["inspect", "select", "validate"];
+var DESCRIPTION = "Inspect, select, or validate a structured data file without loading it whole: CSV/TSV (delimiter and header detection, per-column types, sentinels such as NA counted, never converted), JSON (document shape, RFC 6901 pointer selection), and JSON Lines (record windows). op=inspect reports schema, dimensions, and a sample; op=select returns a bounded window of rows, records, or the value at a pointer; op=validate checks the whole file against its format. Every result carries view {exact, sampled, converted} and honest counts (rowCount null means the scan stopped early), and large integers or long floats are reported, never rounded. Refuses invalid UTF-8, binary, and unsupported formats (HDF5, NetCDF, Parquet: use run_script with a library) with an actionable reason.";
+function numberArg(value) {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "string" && value.trim().length > 0) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : void 0;
+  }
+  return void 0;
+}
+function headerArg(value) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value === "boolean") return value;
+  if (value === "auto") return "auto";
+  if (value === "true") return true;
+  if (value === "false") return false;
+  return void 0;
+}
+function columnsArg(value) {
+  if (typeof value === "string") {
+    const parts = value.split(",").map((part) => part.trim()).filter((part) => part.length > 0);
+    return parts.length > 0 ? parts : void 0;
+  }
+  if (!Array.isArray(value)) return void 0;
+  const out = [];
+  for (const entry of value) {
+    if (typeof entry === "string" || typeof entry === "number" && Number.isFinite(entry)) out.push(entry);
+  }
+  return out.length > 0 ? out : void 0;
+}
+function prepareDataArguments(args) {
+  const out = { ...args };
+  if (typeof out.path !== "string") {
+    const alias = out.file ?? out.file_path ?? out.filePath;
+    if (typeof alias === "string") out.path = alias;
+  }
+  if (typeof out.path === "string") out.path = out.path.trim();
+  for (const key of ["sample_rows", "offset", "limit"]) {
+    const parsed = numberArg(out[key]);
+    if (parsed !== void 0) out[key] = parsed;
+    else if (out[key] !== void 0) delete out[key];
+  }
+  if (out.max_rows !== void 0 && out.max_rows !== null) {
+    const parsed = numberArg(out.max_rows);
+    if (parsed !== void 0) out.max_rows = parsed;
+    else delete out.max_rows;
+  }
+  const header = headerArg(out.header);
+  if (header !== void 0) out.header = header;
+  else if (out.header !== void 0) delete out.header;
+  const columns = columnsArg(out.columns);
+  if (columns !== void 0) out.columns = columns;
+  else if (out.columns !== void 0) delete out.columns;
+  return out;
+}
+function prepareDataAdmissionArguments(args, cwd = process.cwd()) {
+  const prepared = prepareDataArguments(args);
+  if (typeof prepared.path === "string" && prepared.path.length > 0) prepared.path = resolveToCwd(prepared.path, cwd);
+  return prepared;
+}
+var dataToolSurface = {
+  name: DATA_TOOL_NAME,
+  description: DESCRIPTION,
+  parameters: typebox_exports.Object({
+    op: StringEnum(DATA_OPS, { description: "inspect, select, or validate." }),
+    path: typebox_exports.String({ description: "Data file, relative to the workspace root or absolute." }),
+    format: typebox_exports.Optional(
+      StringEnum(DATA_FORMATS, {
+        description: "Format when the extension or content does not say: csv, tsv, json, jsonl."
+      })
+    ),
+    delimiter: typebox_exports.Optional(typebox_exports.String({ description: "CSV/TSV: one delimiter character (or \\t)." })),
+    header: typebox_exports.Optional(
+      typebox_exports.Union([typebox_exports.Boolean(), typebox_exports.Literal("auto")], {
+        description: 'CSV/TSV: "auto" (default) detects a header row; true or false forces it.'
+      })
+    ),
+    sample_rows: typebox_exports.Optional(
+      typebox_exports.Number({ description: "inspect: rows or top-level members kept as the sample (default 10, max 1000)." })
+    ),
+    max_rows: typebox_exports.Optional(
+      typebox_exports.Union([typebox_exports.Number(), typebox_exports.Null()], {
+        description: "inspect and validate: rows scanned before the view becomes sampled or the verdict partial (default 100000; null scans the whole file)."
+      })
+    ),
+    offset: typebox_exports.Optional(typebox_exports.Number({ description: "select: 0-based first row, record, or array element." })),
+    limit: typebox_exports.Optional(typebox_exports.Number({ description: "select: rows returned (default 50, max 1000)." })),
+    columns: typebox_exports.Optional(
+      typebox_exports.Array(typebox_exports.Union([typebox_exports.String(), typebox_exports.Number()]), {
+        description: "select, CSV/TSV: header names or 0-based indices to project."
+      })
+    ),
+    pointer: typebox_exports.Optional(
+      typebox_exports.String({ description: 'select, JSON: RFC 6901 pointer to the value to return; "" is the whole document.' })
+    )
+  }),
+  baseActionClass: "read",
+  executionMode: "parallel",
+  prepareArguments: prepareDataArguments,
+  prepareAdmissionArguments: prepareDataAdmissionArguments
+};
+
+export {
+  DATA_FORMATS,
+  isDataFormat,
+  exactView,
+  sampledView,
+  cutView,
+  DataRefusalError,
+  refusal,
+  isDataRefusal,
+  refusalFromError,
+  throwIfAborted,
+  statDataFile,
+  streamTextChunks,
+  classifyCell,
+  emptyCellHistogram,
+  inferColumnType,
+  MAX_NUMBER_LITERAL_CHARS,
+  numberLiteralPrecision,
+  resolveMaxRows,
+  capText,
+  sampledNotice,
+  histogramRecord,
+  DATA_TOOL_NAME,
+  DATA_OPS,
+  headerArg,
+  prepareDataArguments,
+  prepareDataAdmissionArguments,
+  dataToolSurface
+};
+//# sourceMappingURL=chunk-PPIFDSBK.js.map

package/dist/{chunk-T52TPHYC.js → chunk-PTFISXQO.js}

@@ -1,16 +1,17 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
+  MAX_ULP_TOLERANCE,
   compareCodepoints
-} from "./chunk-B6UM3OZC.js";
+} from "./chunk-2KUBKL63.js";
 import {
   byteLength
 } from "./chunk-MYI32N4R.js";
-import {
-  resolveSafeCwd
-} from "./chunk-GJ24ODAX.js";
 import {
   require_dist
 } from "./chunk-B5GGDIHT.js";
+import {
+  resolveSafeCwd
+} from "./chunk-XTQ7MEJG.js";
 import {
   __toESM,
   init_esm_shims
@@ -154,8 +155,8 @@ function validateTolerances(value, location) {
   }
   if (Object.hasOwn(value, "ulp")) {
     const ulp = value.ulp;
-    if (typeof ulp !== "number" || !Number.isInteger(ulp) || ulp < 0) {
-      return new Error(`${location}.ulp must be a non-negative integer`);
+    if (typeof ulp !== "number" || !Number.isInteger(ulp) || ulp < 0 || ulp > MAX_ULP_TOLERANCE) {
+      return new Error(`${location}.ulp must be a non-negative integer no greater than ${MAX_ULP_TOLERANCE}`);
     }
     tolerances.ulp = ulp;
   }
@@ -315,4 +316,4 @@ export {
   loadValidationContract,
   describeValidationContract
 };
-//# sourceMappingURL=chunk-T52TPHYC.js.map
+//# sourceMappingURL=chunk-PTFISXQO.js.map

package/dist/{chunk-C6GEXX4L.js → chunk-QB33Z5S7.js}

@@ -2,7 +2,7 @@ import { createRequire as __clioCreateRequire } from "node:module"; const requir
 import {
   ensureYaziProfile,
   yaziProfileDir
-} from "./chunk-T334FW2H.js";
+} from "./chunk-JU6MAMRJ.js";
 import {
   describeResolution,
   resolveToolBinary,
@@ -14,12 +14,12 @@ import {
 import {
   namingCompatibilityEnvironment
 } from "./chunk-DVNAPPXU.js";
-import {
-  resolvePackageRoot
-} from "./chunk-E3LEPLQ2.js";
 import {
   clioCacheDir
 } from "./chunk-CTTI7G3T.js";
+import {
+  resolvePackageRoot
+} from "./chunk-E3LEPLQ2.js";
 import {
   init_esm_shims
 } from "./chunk-ECBHH7LU.js";
@@ -1862,4 +1862,4 @@ export {
   createYaziSession,
   createMuxDomainModule
 };
-//# sourceMappingURL=chunk-C6GEXX4L.js.map
+//# sourceMappingURL=chunk-QB33Z5S7.js.map

package/dist/{chunk-VMATUZB6.js → chunk-QGNII5VC.js}

@@ -1,25 +1,25 @@
 import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
 import {
   discoverAgentRecipes
-} from "./chunk-4UHVS5T7.js";
+} from "./chunk-WGRDABW7.js";
 import {
   compileFleetExecutionPlan
-} from "./chunk-RTLNFZMD.js";
-import {
-  requestExecutionRole,
-  withAttemptRole
-} from "./chunk-3LXJOICS.js";
+} from "./chunk-DIAJYJYG.js";
 import {
   loadFleetCommands,
   loadFleetContract,
   renderFleetPrompt
-} from "./chunk-KKEYGFX4.js";
+} from "./chunk-7QQRPB2E.js";
+import {
+  requestExecutionRole,
+  withAttemptRole
+} from "./chunk-H6IUCY6Q.js";
 import {
   normalizeAgentSpec
-} from "./chunk-34XHRVKG.js";
+} from "./chunk-I47EJPYL.js";
 import {
   readSettings
-} from "./chunk-4QKAITQT.js";
+} from "./chunk-FPS4R2RN.js";
 import {
   init_esm_shims
 } from "./chunk-ECBHH7LU.js";
@@ -107,4 +107,4 @@ function inspectFleet(name, vars) {
 export {
   inspectFleet
 };
-//# sourceMappingURL=chunk-VMATUZB6.js.map
+//# sourceMappingURL=chunk-QGNII5VC.js.map