@visual-z/xeno 0.8.4 → 0.9.1

package/src/core/data-query.ts

@@ -1,201 +0,0 @@
-/** N.3: a finite read-only query algebra; no model-generated code is evaluated. */
-import { isRecord } from "./event-validation.ts";
-import { canonicalValue } from "./continuation.ts";
-import { assertNever } from "./exhaustive.ts";
-import { resolveJsonPointer, validateJsonPointer } from "./json-pointer.ts";
-
-export type DataRow = Record<string, unknown>;
-export type DataFormat = "csv" | "json" | "jsonl" | "lines";
-type Predicate = { field: string; op: "eq" | "ne" | "contains" | "gt" | "gte" | "lt" | "lte"; value: unknown };
-type Aggregate = { op: "count" | "sum" | "avg" | "min" | "max"; field?: string; as: string };
-export interface DataQuery {
-  format: DataFormat;
-  pointer?: string;
-  where?: readonly Predicate[];
-  select?: readonly string[];
-  group_by?: readonly string[];
-  aggregate?: readonly Aggregate[];
-  order_by?: readonly { field: string; descending?: boolean }[];
-}
-
-// Resource bounds, not partial-result caps. Assumed for the synchronous parser;
-// exceeding one rejects the query and asks for a smaller input, never reports totals.
-export const MAX_QUERY_RECORDS = 250_000;
-
-function fields(value: unknown, name: string): string[] | undefined {
-  if (value === undefined) return undefined;
-  if (!Array.isArray(value) || value.length > 64 || value.some((v) => typeof v !== "string" || !v) || new Set(value).size !== value.length) throw new Error(`invalid ${name}`);
-  return value as string[];
-}
-export function parseDataQuery(input: unknown): DataQuery {
-  if (!isRecord(input) || !["csv", "json", "jsonl", "lines"].includes(String(input["format"]))) throw new Error("query format must be csv, json, jsonl, or lines");
-  const out: DataQuery = { format: input["format"] as DataFormat };
-  for (const name of ["select", "group_by"] as const) {
-    const list = fields(input[name], name); if (list !== undefined) out[name] = list;
-  }
-  if (input["pointer"] !== undefined) {
-    if (typeof input["pointer"] !== "string") throw new Error("pointer must be a JSON pointer");
-    validateJsonPointer(input["pointer"]);
-    out.pointer = input["pointer"];
-  }
-  if (input["where"] !== undefined) {
-    if (!Array.isArray(input["where"]) || input["where"].length > 64) throw new Error("invalid where");
-    out.where = input["where"].map((value: unknown) => {
-      if (!isRecord(value) || typeof value["field"] !== "string" || !["eq", "ne", "contains", "gt", "gte", "lt", "lte"].includes(String(value["op"])) || !("value" in value)) throw new Error("invalid predicate");
-      return value as Predicate;
-    });
-  }
-  if (input["aggregate"] !== undefined) {
-    if (!Array.isArray(input["aggregate"]) || input["aggregate"].length > 64) throw new Error("invalid aggregate");
-    out.aggregate = input["aggregate"].map((value: unknown) => {
-      if (!isRecord(value) || !["count", "sum", "avg", "min", "max"].includes(String(value["op"])) ||
-          typeof value["as"] !== "string" || !value["as"] || (value["field"] !== undefined && typeof value["field"] !== "string") ||
-          (value["op"] !== "count" && !value["field"])) throw new Error("invalid aggregate; numeric operations need field, all operations need as");
-      return value as Aggregate;
-    });
-    const names = [...(out.group_by ?? []), ...out.aggregate.map((a) => a.as)];
-    if (new Set(names).size !== names.length) throw new Error("duplicate result column");
-  }
-  if (input["order_by"] !== undefined) {
-    if (!Array.isArray(input["order_by"]) || input["order_by"].length > 64) throw new Error("invalid order_by");
-    out.order_by = input["order_by"].map((value: unknown) => {
-      if (!isRecord(value) || typeof value["field"] !== "string" || (value["descending"] !== undefined && typeof value["descending"] !== "boolean")) throw new Error("invalid order_by field");
-      return value as { field: string; descending?: boolean };
-    });
-  }
-  if (out.group_by?.length && !out.aggregate?.length) throw new Error("group_by requires aggregate");
-  return out;
-}
-
-/** CSV records, including quoted commas/newlines and doubled quotes (RFC 4180). */
-export function csvRecords(text: string): string[][] {
-  const records: string[][] = [];
-  let row: string[] = [], cell = "", quoted = false, closed = false;
-  const push = () => {
-    row.push(cell); cell = ""; closed = false;
-    records.push(row);
-    row = [];
-    if (records.length > MAX_QUERY_RECORDS + 1) throw new Error("query record resource limit exceeded");
-  };
-  for (let i = text.charCodeAt(0) === 0xfeff ? 1 : 0; i < text.length; i++) {
-    const c = text[i]!;
-    if (quoted) {
-      if (c === '"') {
-        if (text[i + 1] === '"') { cell += '"'; i++; }
-        else { quoted = false; closed = true; }
-      } else cell += c;
-    } else if (c === ",") { row.push(cell); cell = ""; closed = false; }
-    else if (c === "\n" || c === "\r") { push(); if (c === "\r" && text[i + 1] === "\n") i++; }
-    else if (c === '"' && cell === "" && !closed) quoted = true;
-    else {
-      if (closed || c === '"') throw new Error("malformed CSV quoting");
-      cell += c;
-    }
-  }
-  if (quoted) throw new Error("unterminated CSV quote");
-  if (cell !== "" || row.length > 0 || closed) push();
-  return records;
-}
-
-const rowOf = (value: unknown): DataRow => isRecord(value) ? value : { value };
-function parseRows(text: string, query: DataQuery): DataRow[] {
-  if (query.format === "csv") {
-    const [header, ...records] = csvRecords(text);
-    if (!header) return [];
-    if (header.some((key) => key.length === 0) || new Set(header).size !== header.length) throw new Error("CSV headers must be nonempty and unique");
-    return records.map((row, i) => {
-      if (row.length !== header.length) throw new Error(`CSV record ${i + 2} has ${row.length} fields, expected ${header.length}`);
-      return Object.fromEntries(header.map((key, col) => [key, row[col]]));
-    });
-  }
-  if (query.format === "json") {
-    const value = resolveJsonPointer(JSON.parse(text.replace(/^\uFEFF/, "")), query.pointer ?? "");
-    const rows = Array.isArray(value) ? value : [value];
-    if (rows.length > MAX_QUERY_RECORDS) throw new Error("query record resource limit exceeded");
-    return rows.map(rowOf);
-  }
-  const lines = text.replace(/^\uFEFF/, "").split(/\r?\n/);
-  if (lines.at(-1) === "") lines.pop();
-  if (lines.length > MAX_QUERY_RECORDS) throw new Error("query record resource limit exceeded");
-  return query.format === "jsonl" ? lines.filter((line) => line.trim() !== "").map((line) => rowOf(JSON.parse(line))) : lines.map((line, i) => ({ line: i + 1, text: line }));
-}
-
-function field(row: DataRow, key: string): unknown {
-  if (Object.hasOwn(row, key)) return row[key];
-  let value: unknown = row;
-  for (const part of key.split(".")) {
-    if (value === null || typeof value !== "object" || !Object.hasOwn(value, part)) return null;
-    value = (value as DataRow)[part];
-  }
-  return value ?? null;
-}
-function compare(a: unknown, b: unknown): number {
-  if (a === b) return 0;
-  if (a === null || a === undefined) return -1;
-  if (b === null || b === undefined) return 1;
-  if (typeof a === "number" && typeof b === "number") return a - b;
-  const left = String(a), right = String(b);
-  return left < right ? -1 : left > right ? 1 : 0;
-}
-function matches(row: DataRow, predicate: Predicate): boolean {
-  const raw = field(row, predicate.field), expected = predicate.value;
-  const value = typeof expected === "number" && typeof raw === "string" && raw.trim() !== "" ? Number(raw) : raw;
-  if (typeof value === "number" && !Number.isFinite(value)) return false;
-  switch (predicate.op) {
-    case "eq": return canonicalValue(value) === canonicalValue(expected);
-    case "ne": return canonicalValue(value) !== canonicalValue(expected);
-    case "contains": return String(value ?? "").includes(String(expected));
-    case "gt": return value !== null && compare(value, expected) > 0;
-    case "gte": return value !== null && compare(value, expected) >= 0;
-    case "lt": return value !== null && compare(value, expected) < 0;
-    case "lte": return value !== null && compare(value, expected) <= 0;
-    default: return assertNever(predicate.op, "query predicate");
-  }
-}
-function aggregate(rows: readonly DataRow[], spec: Aggregate): number | null {
-  const values = spec.field === undefined ? rows : rows.map((row) => field(row, spec.field!)).filter((value) => value !== null && value !== undefined && value !== "");
-  if (spec.op === "count") return values.length;
-  const numbers = values.map((value) => typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : NaN);
-  if (numbers.some((n) => !Number.isFinite(n))) throw new Error(`non-numeric value in ${spec.field}`);
-  if (numbers.length === 0) return spec.op === "sum" ? 0 : null;
-  let result: number;
-  switch (spec.op) {
-    case "sum": result = numbers.reduce((a, b) => a + b, 0); break;
-    case "avg": result = numbers.reduce((a, b) => a + b, 0) / numbers.length; break;
-    case "min": result = numbers.reduce((a, b) => Math.min(a, b)); break;
-    case "max": result = numbers.reduce((a, b) => Math.max(a, b)); break;
-    default: return assertNever(spec.op, "query aggregate");
-  }
-  if (!Number.isFinite(result)) throw new Error("numeric overflow in aggregate");
-  return result;
-}
-
-export function queryData(text: string, query: DataQuery): { total: number; matched: number; rows: DataRow[] } {
-  const all = parseRows(text, query);
-  if (all.length > MAX_QUERY_RECORDS) throw new Error("query record resource limit exceeded");
-  const matched = all.filter((row) => (query.where ?? []).every((predicate) => matches(row, predicate)));
-  let rows = matched;
-  if (query.aggregate?.length) {
-    const groups = new Map<string, { keys: unknown[]; rows: DataRow[] }>();
-    if (!query.group_by?.length) groups.set("[]", { keys: [], rows: matched });
-    else for (const row of matched) {
-      const keys = query.group_by.map((key) => field(row, key)), key = canonicalValue(keys);
-      let group = groups.get(key);
-      if (!group) { group = { keys, rows: [] }; groups.set(key, group); }
-      group.rows.push(row);
-    }
-    rows = [...groups.values()].map((group) => Object.fromEntries([
-      ...(query.group_by ?? []).map((key, i) => [key, group.keys[i]]),
-      ...query.aggregate!.map((spec) => [spec.as, aggregate(group.rows, spec)]),
-    ]));
-  }
-  if (query.order_by?.length) rows = rows.toSorted((a, b) => {
-    for (const order of query.order_by!) {
-      const result = compare(field(a, order.field), field(b, order.field));
-      if (result !== 0) return order.descending ? -result : result;
-    }
-    return 0;
-  });
-  if (query.select) rows = rows.map((row) => Object.fromEntries(query.select!.map((key) => [key, field(row, key)])));
-  return { total: all.length, matched: matched.length, rows };
-}

package/src/core/deadline.ts

@@ -1,40 +0,0 @@
-/**
- * A wall-clock notice for runs judged against a deadline.
- *
- * An evaluation kills a task at its timeout; a model that does not know the
- * time is often still exploring when it does, and leaves nothing verifiable
- * behind. LangChain's Terminal-Bench harness injects the remaining budget for
- * this reason. Time arrives as arguments: core reads no clock.
- */
-import type { GuidanceEvent, LogEvent } from "./events.ts";
-import { currentRequestEvents } from "./request-state.ts";
-
-/**
- * Assumed, not measured: a quarter of the budget leaves room for one
- * fix-test-finish round. Earlier would cut exploration short; later is no
- * warning at all.
- */
-export const DEADLINE_FRACTION = 0.75;
-
-const clock = (ms: number) => {
-  const total = Math.max(0, Math.round(ms / 1000));
-  const m = Math.floor(total / 60), s = total % 60;
-  return m === 0 ? `${s}s` : s === 0 ? `${m}m` : `${m}m ${s}s`;
-};
-
-export function deadlineNotice(
-  startedAt: string, now: string, budgetMs: number, events: readonly LogEvent[],
-): Pick<GuidanceEvent, "reason" | "text" | "sources"> | null {
-  const start = Date.parse(startedAt), current = Date.parse(now);
-  if (!Number.isFinite(start) || !Number.isFinite(current) || !Number.isFinite(budgetMs) || budgetMs <= 0) {
-    throw new RangeError("deadline needs valid timestamps and a positive budget");
-  }
-  const request = currentRequestEvents(events);
-  if (request.some((event) => event.t === "guidance" && event.reason === "deadline")) return null;
-  const used = current - start;
-  if (used < budgetMs * DEADLINE_FRACTION) return null;
-  return { reason: "deadline", sources: [], text:
-    `Harness: ${clock(used)} of ${clock(budgetMs)} used; ${clock(budgetMs - used)} remain before this run is stopped. ` +
-    "Stop exploring. Converge on the most complete result you can verify now: finish the change in progress, run its check, " +
-    "and leave the workspace in a working state." };
-}