@gemwright/ai 0.0.0 → 0.8.0

package/dist/life-journal-worker.js

@@ -0,0 +1,469 @@
+// @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  if (mod && typeof mod === "object" || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true
+        });
+  }
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res, err) => () => {
+  if (fn)
+    try {
+      res = fn(fn = 0);
+    } catch (e) {
+      err = [e];
+    }
+  if (err)
+    throw err[0];
+  return res;
+};
+
+// src/telemetry-metrics.ts
+class RuntimeMetrics {
+  counters = new Map;
+  histograms = new Map;
+  starts = new Map;
+  increment(name, amount = 1) {
+    const key = this.counters.has(name) || this.counters.size < 512 ? name : "other";
+    this.counters.set(key, (this.counters.get(key) ?? 0) + amount);
+  }
+  duration(name, ms) {
+    if (!Number.isFinite(ms) || ms < 0)
+      return;
+    const key = this.histograms.has(name) || this.histograms.size < 64 ? name : "other";
+    const histogram = this.histograms.get(key) ?? { count: 0, sum: 0, max: 0, buckets: bounds.map(() => 0) };
+    histogram.count++;
+    histogram.sum += ms;
+    histogram.max = Math.max(histogram.max, ms);
+    const index = bounds.findIndex((bound) => ms <= bound);
+    histogram.buckets[index] = (histogram.buckets[index] ?? 0) + 1;
+    this.histograms.set(key, histogram);
+  }
+  observe(event) {
+    this.increment(`${event.component}.${event.type}.${event.result}`);
+    if (event.type !== "action_lifecycle" || !event.actionId)
+      return;
+    if (["proposed", "authorized", "dispatched", "started"].includes(event.result)) {
+      if (!this.starts.has(event.actionId))
+        this.starts.set(event.actionId, Date.parse(event.at));
+      if (this.starts.size > 4096)
+        this.starts.delete(this.starts.keys().next().value ?? "");
+    } else if (["completed", "failed", "interrupted", "timed-out", "unconfirmed"].includes(event.result)) {
+      const start = this.starts.get(event.actionId);
+      if (start !== undefined)
+        this.duration("action_ms", Date.parse(event.at) - start);
+      this.starts.delete(event.actionId);
+    }
+  }
+  snapshot() {
+    return {
+      counters: Object.fromEntries(this.counters),
+      histograms: Object.fromEntries([...this.histograms].map(([name, h]) => {
+        const percentile = (fraction) => {
+          let count = 0;
+          for (let i = 0;i < bounds.length; i++) {
+            count += h.buckets[i] ?? 0;
+            if (count >= h.count * fraction)
+              return bounds[i] === Infinity ? h.max : bounds[i];
+          }
+          return h.max;
+        };
+        return [
+          name,
+          {
+            count: h.count,
+            mean: h.sum / Math.max(1, h.count),
+            max: h.max,
+            p50: percentile(0.5),
+            p95: percentile(0.95),
+            p99: percentile(0.99)
+          }
+        ];
+      }))
+    };
+  }
+}
+function markThreat(session, active, at) {
+  if (!active) {
+    threats.delete(session);
+    return;
+  }
+  if (!threats.has(session))
+    threats.set(session, { at, recorded: new Set });
+}
+function observeInterruption(session, event) {
+  const threat = threats.get(session);
+  const name = event.stage === "interrupted" ? "work_interrupt_ms" : event.kind === "escape" && event.stage === "authorized" && !event.command ? "safety_authorize_ms" : undefined;
+  if (!threat || !name || threat.recorded.has(name))
+    return;
+  runtimeMetrics.duration(name, event.at - threat.at);
+  threat.recorded.add(name);
+}
+var bounds, runtimeMetrics, threats;
+var init_telemetry_metrics = __esm(() => {
+  bounds = [1, 5, 10, 25, 50, 100, 250, 500, 1000, 5000, 30000, Infinity];
+  runtimeMetrics = new RuntimeMetrics;
+  threats = new WeakMap;
+});
+
+// src/telemetry-schema.ts
+function redact(value, depth = 0, seen = new WeakSet) {
+  if (depth > 12)
+    return "[depth-limit]";
+  if (value instanceof Error)
+    return { name: value.name, message: String(redact(value.message, depth + 1, seen)) };
+  if (typeof value === "string")
+    return value.replace(/\b(Bearer\s+)\S+/gi, "$1[redacted]").replace(/\b(password|api[_-]?key|secret|token)=([^\s&]+)/gi, "$1=[redacted]");
+  if (typeof value === "bigint")
+    return value.toString();
+  if (value === null || typeof value !== "object")
+    return value;
+  if (seen.has(value))
+    return "[circular]";
+  seen.add(value);
+  try {
+    if (Array.isArray(value))
+      return value.map((item) => redact(item, depth + 1, seen));
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+      key,
+      sensitive.test(key) ? "[redacted]" : redact(item, depth + 1, seen)
+    ]));
+  } finally {
+    seen.delete(value);
+  }
+}
+var sensitive;
+var init_telemetry_schema = __esm(() => {
+  sensitive = /^(?:password|passwd|secret|authorization|cookie|token|api[_-]?key|credentials|accountRef|username)$/i;
+});
+
+// src/telemetry.ts
+import { AsyncLocalStorage } from "async_hooks";
+function updateTrace(fields) {
+  const current = context.getStore();
+  if (current)
+    Object.assign(current, fields);
+}
+function registerActor(session, residentId, name) {
+  const actor = { residentId, name, sessionId: crypto.randomUUID() };
+  actors.set(session, actor);
+  return actor;
+}
+function actorFor(session) {
+  return {
+    ...actors.get(session) ?? { residentId: null, name: null, sessionId: null },
+    position: session.world.position ? { map: session.world.map, ...session.world.position } : null
+  };
+}
+function configureTelemetry(options) {
+  const previous = { sink, output };
+  sink = options.sink ?? sink;
+  output = options.output ?? output;
+  return () => {
+    sink = previous.sink;
+    output = previous.output;
+  };
+}
+function makeEvent(component, type, result, details, fields = {}) {
+  const current = context.getStore();
+  const actor = current?.actor?.();
+  return {
+    schemaVersion: 2,
+    id: crypto.randomUUID(),
+    at: new Date().toISOString(),
+    runId,
+    deploymentId: process.env.RAILWAY_DEPLOYMENT_ID ?? null,
+    sequence: ++sequence,
+    component,
+    message: String(redact(typeof details.message === "string" ? details.message : `${component}: ${type} ${result}`)),
+    level: result === "failed" ? "error" : "info",
+    type,
+    result,
+    residentId: actor?.residentId ?? null,
+    name: actor?.name ?? null,
+    sessionId: actor?.sessionId ?? null,
+    traceId: current?.traceId ?? current?.intentId ?? current?.actionId ?? actor?.sessionId ?? runId,
+    intentId: current?.intentId,
+    decisionId: current?.decisionId,
+    actionId: current?.actionId,
+    parentId: current?.parentId,
+    position: actor?.position ?? null,
+    ...Object.fromEntries(Object.entries(fields).filter(([, value]) => value !== undefined)),
+    details: redact(details)
+  };
+}
+function emitEvent(event, options = {}) {
+  runtimeMetrics.observe(event);
+  if (options.journal !== false)
+    sink?.(event);
+  if (options.stdout)
+    output?.(JSON.stringify(event), event.level);
+}
+function operational(component, level, message, details = {}) {
+  const event = makeEvent(component, "operational_log", level === "error" ? "failed" : "observed", { message, ...details }, { level });
+  emitEvent(event, { stdout: true });
+  return event;
+}
+function checkpointEvent(checkpoint, component, type, result, details, fields = {}) {
+  const session = checkpointSession(checkpoint);
+  emitEvent(makeEvent(component, type, result, details, { ...session ? actorFor(session) : {}, ...fields }));
+}
+var context, runId, sequence = 0, sink, output, actors, checkpoints, traceContext = () => context.getStore(), inTrace = (fields, run) => context.run({ ...context.getStore(), ...fields }, run), inSession = (session, run) => inTrace({ actor: () => actorFor(session) }, run), bindCheckpoint = (checkpoint, session) => checkpoints.set(checkpoint, session), checkpointSession = (checkpoint) => checkpoints.get(checkpoint);
+var init_telemetry = __esm(() => {
+  init_telemetry_metrics();
+  init_telemetry_schema();
+  context = new AsyncLocalStorage;
+  runId = crypto.randomUUID();
+  actors = new WeakMap;
+  checkpoints = new WeakMap;
+});
+
+// src/life-journal-worker.ts
+import { parentPort, workerData } from "worker_threads";
+
+// src/journal-files.ts
+init_telemetry();
+import { mkdir, open, readdir, stat, statfs, unlink } from "fs/promises";
+import { join } from "path";
+import { promisify } from "util";
+import { gzip } from "zlib";
+var compress = promisify(gzip);
+var traceTypes = new Set([
+  "perception_snapshot",
+  "perception_delta",
+  "action_lifecycle",
+  "activity",
+  "operational_log",
+  "runtime_metrics",
+  "runtime_health",
+  "resident_health"
+]);
+var tracePattern = /^\d{4}-\d{2}-\d{2}\.trace\.\d{8}\.jsonl\.gz$/;
+var dayPattern = /^(\d{4}-\d{2}-\d{2})(?:\.\d{8})?\.jsonl\.gz$/;
+
+class JournalFiles {
+  directory;
+  traces = [];
+  history = [];
+  traceBytes = 0;
+  historyBytes = 0;
+  evictedBytes = 0;
+  evictedFiles = 0;
+  diskCheckedAt = 0;
+  options;
+  constructor(directory, options = {}) {
+    this.directory = directory;
+    this.options = {
+      traceBudgetBytes: 512 * 1024 * 1024,
+      segmentBytes: 16 * 1024 * 1024,
+      reserveBytes: 128 * 1024 * 1024,
+      historyBudgetBytes: 1024 * 1024 * 1024,
+      historySegmentBytes: 64 * 1024 * 1024,
+      historyMaxDays: 2,
+      ...options
+    };
+  }
+  async initialize() {
+    await mkdir(this.directory, { recursive: true, mode: 448 });
+    for (const name of (await readdir(this.directory)).sort()) {
+      if (!name.endsWith(".jsonl.gz"))
+        continue;
+      const file = await stat(join(this.directory, name));
+      if (!file.isFile())
+        continue;
+      if (tracePattern.test(name)) {
+        this.traces.push({ name, bytes: file.size });
+        this.traceBytes += file.size;
+      } else if (dayPattern.test(name)) {
+        this.history.push({ name, bytes: file.size });
+        this.historyBytes += file.size;
+      }
+    }
+  }
+  statistics() {
+    return {
+      historyBytes: this.historyBytes,
+      traceBytes: this.traceBytes,
+      historyBudgetBytes: this.options.historyBudgetBytes,
+      traceBudgetBytes: this.options.traceBudgetBytes,
+      evictedBytes: this.evictedBytes,
+      evictedFiles: this.evictedFiles
+    };
+  }
+  async append(name, events, level) {
+    const bytes = await compress(`${events.map((event) => JSON.stringify(event)).join(`
+`)}
+`, { level });
+    const file = await open(join(this.directory, name), "a", 384);
+    try {
+      await file.writeFile(bytes);
+      await file.sync();
+    } finally {
+      await file.close();
+    }
+    return bytes.length;
+  }
+  async evict(name) {
+    const entry = this.history.find((file) => file.name === name);
+    if (!entry)
+      return 0;
+    await unlink(join(this.directory, name));
+    this.history = this.history.filter((file) => file.name !== name);
+    this.historyBytes -= entry.bytes;
+    this.evictedBytes += entry.bytes;
+    this.evictedFiles++;
+    return entry.bytes;
+  }
+  async trim(incoming = 0, keep) {
+    const removable = () => this.history.filter((file) => file.name !== keep);
+    const today = new Date().toISOString().slice(0, 10);
+    const oldestDay = new Date(Date.now() - this.options.historyMaxDays * 86400000).toISOString().slice(0, 10);
+    for (const file of removable()) {
+      const day = dayPattern.exec(file.name)?.[1] ?? today;
+      if (day < oldestDay)
+        await this.evict(file.name);
+    }
+    while (this.historyBytes + incoming > this.options.historyBudgetBytes) {
+      const oldest = removable().sort((a, b) => a.name.localeCompare(b.name))[0];
+      if (!oldest)
+        break;
+      await this.evict(oldest.name);
+    }
+    const remove = [];
+    let remaining = this.traceBytes;
+    for (const trace of this.traces) {
+      if (remaining + incoming <= this.options.traceBudgetBytes)
+        break;
+      remove.push(trace);
+      remaining -= trace.bytes;
+    }
+    if (!remove.length)
+      return;
+    const event = makeEvent("journal", "journal_retention", "observed", {
+      reason: "Bounded diagnostic trace window; life-event history is retained",
+      files: remove.map((file) => file.name),
+      bytes: remove.reduce((sum, file) => sum + file.bytes, 0),
+      replayComplete: false
+    }, { level: "warn" });
+    const segment = this.segment(event.at.slice(0, 10));
+    const written = await this.append(segment.name, [event], 6);
+    segment.bytes += written;
+    this.historyBytes += written;
+    for (const trace of remove) {
+      await unlink(join(this.directory, trace.name));
+      this.traceBytes -= trace.bytes;
+      this.evictedBytes += trace.bytes;
+      this.evictedFiles++;
+      this.traces = this.traces.filter((file) => file.name !== trace.name);
+    }
+  }
+  segment(day) {
+    const files = this.history.filter((file) => dayPattern.exec(file.name)?.[1] === day).sort((a, b) => a.name.localeCompare(b.name));
+    const latest = files.at(-1);
+    if (latest && latest.bytes < this.options.historySegmentBytes && latest.name !== `${day}.jsonl.gz`)
+      return latest;
+    const index = files.filter((file) => /\.\d{8}\.jsonl\.gz$/.test(file.name)).length;
+    const fresh = { name: `${day}.${String(index).padStart(8, "0")}.jsonl.gz`, bytes: 0 };
+    this.history.push(fresh);
+    this.history.sort((a, b) => a.name.localeCompare(b.name));
+    return fresh;
+  }
+  async write(events) {
+    await this.trim();
+    if (Date.now() - this.diskCheckedAt > 5000) {
+      const disk = await statfs(this.directory);
+      const free = Number(disk.bavail) * Number(disk.bsize);
+      if (free < this.options.reserveBytes)
+        throw new Error("Journal disk reserve reached; archive life-event history before continuing");
+      this.diskCheckedAt = Date.now();
+    }
+    const groups = new Map;
+    for (const event of events) {
+      const day = event.at.slice(0, 10);
+      if (!/^\d{4}-\d{2}-\d{2}$/.test(day))
+        throw new Error("Invalid life-event timestamp");
+      const trace = traceTypes.has(event.type) && event.level !== "error" && event.level !== "warn";
+      const key = day + (trace ? ".trace" : "");
+      const group = groups.get(key) ?? [];
+      group.push(event);
+      groups.set(key, group);
+    }
+    for (const [key, group] of groups) {
+      if (!key.endsWith(".trace")) {
+        const day = key;
+        const segment = this.segment(day);
+        const bytes = await this.append(segment.name, group, 6);
+        segment.bytes += bytes;
+        this.historyBytes += bytes;
+        await this.trim(0, segment.name);
+        continue;
+      }
+      const latest = this.traces.filter((file) => file.name.startsWith(`${key}.`)).at(-1);
+      const index = latest ? Number(latest.name.split(".")[2]) + (latest.bytes >= this.options.segmentBytes ? 1 : 0) : 0;
+      const name = `${key}.${String(index).padStart(8, "0")}.jsonl.gz`;
+      const bytes = await this.append(name, group, 3);
+      const file = this.traces.find((file) => file.name === name);
+      if (file)
+        file.bytes += bytes;
+      else {
+        this.traces.push({ name, bytes });
+        this.traces.sort((a, b) => a.name.localeCompare(b.name));
+      }
+      this.traceBytes += bytes;
+      await this.trim(0, name);
+    }
+  }
+}
+
+// src/life-journal-worker.ts
+var files = new JournalFiles(String(workerData.directory));
+await files.initialize();
+var chain = Promise.resolve();
+parentPort?.on("message", (message) => {
+  chain = chain.then(async () => {
+    await files.write(message.events);
+    parentPort?.postMessage({ through: message.through, storage: files.statistics() });
+  }).catch((error) => parentPort?.postMessage({
+    problem: `Life-event journal could not be saved: ${error instanceof Error ? error.message : String(error)}`
+  }));
+});
+parentPort?.postMessage({ ready: true });