agent-workflow-inspector 0.0.0-stage → 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,1179 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { constants } from "fs";
+import { Command, Option } from "commander";
+import { open, lstat, opendir, realpath, link, unlink } from "fs/promises";
+import { resolve, join, dirname, parse as parsePath } from "path";
+import { randomUUID } from "crypto";
+
+// src/core/analysis.ts
+import { z as z3 } from "zod";
+
+// src/security/index.ts
+var LIMITS = Object.freeze({
+  fileBytes: 16 * 1024 * 1024,
+  spans: 5e4,
+  traces: 5e4,
+  repetitionWindow: 100,
+  aggregateBytes: 64 * 1024 * 1024,
+  processedBytes: 64 * 1024 * 1024,
+  depth: 64,
+  stringLength: 65536,
+  nodes: 1e6,
+  files: 256,
+  findings: 1e3
+});
+var AwiError = class extends Error {
+};
+function safeText(value) {
+  return value.replace(/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/gu, "?");
+}
+function validateValue(value, allowUndefinedProperties = false) {
+  let nodes = 0;
+  let bytes = 0;
+  function charge(amount) {
+    bytes += amount;
+    if (bytes > LIMITS.processedBytes)
+      throw new AwiError("JSON content exceeds processed size limit");
+  }
+  function visit(item, depth) {
+    if (++nodes > LIMITS.nodes || depth > LIMITS.depth)
+      throw new AwiError("JSON structure exceeds resource limits");
+    if (typeof item === "string" && item.length > LIMITS.stringLength)
+      throw new AwiError("JSON string exceeds resource limit");
+    if (typeof item === "number" && !Number.isFinite(item))
+      throw new AwiError("Non-finite number");
+    if (item !== null && typeof item === "object") {
+      charge(2);
+      const array = Array.isArray(item);
+      const prototype = Object.getPrototypeOf(item);
+      if (array ? prototype !== Array.prototype : prototype !== Object.prototype && prototype !== null)
+        throw new AwiError("Only plain JSON objects and arrays are supported");
+      if (array && nodes + item.length > LIMITS.nodes)
+        throw new AwiError("JSON structure exceeds resource limits");
+      const keys = Reflect.ownKeys(item);
+      if (nodes + keys.length - (array ? 1 : 0) > LIMITS.nodes)
+        throw new AwiError("JSON structure exceeds resource limits");
+      let arrayIndex = 0;
+      for (const key of keys) {
+        if (typeof key === "symbol")
+          throw new AwiError("Symbol keys are not JSON");
+        if (array && key === "length") continue;
+        if (array && key !== String(arrayIndex++))
+          throw new AwiError("Sparse or extended arrays are not JSON");
+        if (key.length > LIMITS.stringLength)
+          throw new AwiError("JSON key exceeds resource limit");
+        if (["__proto__", "prototype", "constructor"].includes(key))
+          throw new AwiError("Unsafe object key");
+        const descriptor = Object.getOwnPropertyDescriptor(item, key);
+        if (descriptor.get || descriptor.set)
+          throw new AwiError("Accessors are not JSON");
+        if (!descriptor.enumerable)
+          throw new AwiError("Non-enumerable properties are not JSON");
+        if (descriptor.value === void 0 && allowUndefinedProperties && !array)
+          continue;
+        if (!array) charge(Buffer.byteLength(JSON.stringify(key)) + 1);
+        charge(1);
+        visit(descriptor.value, depth + 1);
+      }
+      if (array && arrayIndex !== item.length)
+        throw new AwiError("Sparse or extended arrays are not JSON");
+    } else if (!["string", "number", "boolean"].includes(typeof item) && item !== null)
+      throw new AwiError("Unsupported JSON value");
+    else charge(Buffer.byteLength(JSON.stringify(item)));
+  }
+  visit(value, 0);
+}
+function parseJson(text) {
+  if (Buffer.byteLength(text) > LIMITS.fileBytes)
+    throw new AwiError("Input exceeds maximum file size");
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new AwiError("Invalid JSON");
+  }
+  validateValue(value);
+  return value;
+}
+function redact(value) {
+  if (Array.isArray(value)) return value.map(redact);
+  if (value && typeof value === "object")
+    return Object.fromEntries(
+      Object.entries(value).map(([k, v]) => [
+        k,
+        /authorization|password|secret|token|api.?key|cookie|credential|prompt|message|output|result/i.test(
+          k
+        ) ? "[REDACTED]" : redact(v)
+      ])
+    );
+  return typeof value === "string" ? safeText(value) : value;
+}
+function validateIgnorePaths(paths) {
+  if (!Array.isArray(paths) || paths.length > 100 || paths.some(
+    (path) => typeof path !== "string" || path.length > LIMITS.stringLength || !/^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/.test(path) || path.split(".").length > LIMITS.depth || path.split(".").some(
+      (key) => ["__proto__", "constructor", "prototype"].includes(key)
+    )
+  ))
+    throw new AwiError("Invalid fingerprint ignore paths");
+}
+
+// src/core/timestamps.ts
+function timeNanoseconds(value) {
+  const milliseconds = Date.parse(value);
+  const fraction = /\.(\d+)(?:Z|[+-]\d{2}:\d{2})$/.exec(value)?.[1] ?? "";
+  if (!Number.isFinite(milliseconds) || fraction.length > 9)
+    throw new AwiError("Invalid or unsupported timestamp precision");
+  return BigInt(milliseconds) * 1000000n + BigInt(fraction.padEnd(9, "0").slice(3) || "0");
+}
+function validTime(value) {
+  try {
+    timeNanoseconds(value);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/adapters/index.ts
+import { z } from "zod";
+var time = z.string().datetime({ offset: true }).refine(validTime);
+var count = z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var operation = z.strictObject({
+  id: z.string().min(1),
+  parentId: z.string().min(1).optional(),
+  type: z.enum(["tool", "agent", "model", "workflow", "generic"]),
+  name: z.string().min(1),
+  toolName: z.string().optional(),
+  startTime: time.optional(),
+  endTime: time.optional(),
+  status: z.enum(["ok", "error", "unknown"]).default("unknown"),
+  error: z.strictObject({
+    code: z.string().optional(),
+    message: z.string().optional()
+  }).optional(),
+  arguments: z.unknown().optional(),
+  resultMetadata: z.record(z.string(), z.unknown()).optional(),
+  usage: z.strictObject({
+    inputTokens: count.optional(),
+    outputTokens: count.optional(),
+    totalTokens: count.optional()
+  }).optional(),
+  cost: z.strictObject({
+    amount: z.number().finite().nonnegative(),
+    currency: z.string().regex(/^[A-Z]{3}$/)
+  }).optional(),
+  metadata: z.record(z.string(), z.unknown()).optional()
+});
+var traceSchema = z.strictObject({
+  version: z.literal(1),
+  traceId: z.string().min(1),
+  metadata: z.record(z.string(), z.unknown()).optional(),
+  operations: z.array(operation).max(LIMITS.spans)
+});
+var record = (v) => v !== null && typeof v === "object" && !Array.isArray(v) ? v : {};
+function list(v) {
+  if (!Array.isArray(v)) throw new AwiError("Invalid OTLP array");
+  return v;
+}
+function string(v) {
+  return typeof v === "string" ? v : void 0;
+}
+function anyValue(v) {
+  const r = record(v);
+  const fields = [
+    "stringValue",
+    "boolValue",
+    "intValue",
+    "doubleValue",
+    "bytesValue",
+    "arrayValue",
+    "kvlistValue"
+  ].filter((key) => key in r);
+  if (!fields.length) return void 0;
+  if (fields.length !== 1) throw new AwiError("Invalid OTLP AnyValue");
+  const field = fields[0];
+  const value = r[field];
+  if (field === "stringValue" || field === "bytesValue") {
+    if (typeof value !== "string")
+      throw new AwiError("Invalid OTLP string value");
+    return value;
+  }
+  if (field === "boolValue") {
+    if (typeof value !== "boolean")
+      throw new AwiError("Invalid OTLP boolean value");
+    return value;
+  }
+  if (field === "doubleValue") {
+    if (typeof value !== "number" || !Number.isFinite(value))
+      throw new AwiError("Invalid OTLP double value");
+    return value;
+  }
+  if (field === "intValue") {
+    if ((typeof value !== "string" || !/^[-]?\d{1,19}$/.test(value)) && (typeof value !== "number" || !Number.isSafeInteger(value)))
+      throw new AwiError("Invalid OTLP integer value");
+    const integer = BigInt(value);
+    if (integer < -9223372036854775808n || integer > 9223372036854775807n)
+      throw new AwiError("OTLP integer out of range");
+    const number = Number(integer);
+    return Number.isSafeInteger(number) ? number : String(value);
+  }
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new AwiError("Invalid OTLP structured value");
+  if (field === "arrayValue") {
+    const items = list(record(value).values ?? []).map(anyValue);
+    return items.some((item) => item === void 0) ? void 0 : items;
+  }
+  return attributes(record(value).values, true);
+}
+function attributes(v, complete = false) {
+  const entries = [];
+  for (const attribute of list(v ?? [])) {
+    const raw = record(attribute);
+    if (typeof raw.key !== "string")
+      throw new AwiError("Invalid OTLP attribute key");
+    const value = anyValue(raw.value);
+    if (value === void 0 && complete) return void 0;
+    entries.push([raw.key, value]);
+  }
+  return Object.fromEntries(
+    [...new Map(entries)].filter(([, value]) => value !== void 0)
+  );
+}
+function attributeEncoding(values, key) {
+  const attribute = list(values ?? []).findLast(
+    (item) => record(item).key === key
+  );
+  return record(record(attribute).value);
+}
+function textAttribute(values, key) {
+  return string(attributeEncoding(values, key).stringValue);
+}
+function hasBinaryValue(value) {
+  return value !== null && typeof value === "object" && ("bytesValue" in value || Object.values(value).some(hasBinaryValue));
+}
+function timestamp(v) {
+  if (v === void 0 || v === "0" || v === 0) return void 0;
+  if ((typeof v !== "string" || !/^\d{1,20}$/.test(v)) && (typeof v !== "number" || !Number.isSafeInteger(v)))
+    throw new AwiError("Invalid OTLP nanosecond timestamp");
+  const ns = BigInt(v);
+  if (ns === 0n) return void 0;
+  if (ns < 0n || ns > 18446744073709551615n)
+    throw new AwiError("OTLP timestamp out of range");
+  const iso = new Date(Number(ns / 1000000n)).toISOString();
+  return ns % 1000000n === 0n ? iso : iso.replace(
+    /\.\d{3}Z$/,
+    "." + (ns % 1000000000n).toString().padStart(9, "0") + "Z"
+  );
+}
+function otel(value) {
+  const grouped = /* @__PURE__ */ new Map();
+  let total = 0;
+  for (const resource of list(record(value).resourceSpans)) {
+    const r = record(resource);
+    const resourceAttributes = attributes(record(r.resource).attributes);
+    for (const scope of list(r.scopeSpans ?? []))
+      for (const raw of list(record(scope).spans ?? [])) {
+        if (++total > LIMITS.spans)
+          throw new AwiError("Maximum span count exceeded");
+        const s = record(raw);
+        const traceId = string(s.traceId), id = string(s.spanId);
+        if (!traceId || !/^[a-fA-F0-9]{32}$/.test(traceId) || /^0+$/.test(traceId) || !id || !/^[a-fA-F0-9]{16}$/.test(id) || /^0+$/.test(id))
+          throw new AwiError("Invalid OTLP trace/span identity");
+        const a = attributes(s.attributes);
+        const kind = textAttribute(s.attributes, "gen_ai.operation.name");
+        const tool = textAttribute(s.attributes, "gen_ai.tool.name") ?? textAttribute(s.attributes, "tool.name");
+        const type = tool || kind === "execute_tool" ? "tool" : kind === "invoke_agent" ? "agent" : [
+          "chat",
+          "generate_content",
+          "text_completion",
+          "embeddings"
+        ].includes(typeof kind === "string" ? kind : "") ? "model" : kind === "workflow" ? "workflow" : "generic";
+        const statusRecord = record(s.status);
+        const status = statusRecord.code;
+        const events = list(s.events ?? []).map(record);
+        const exception = events.find((e) => e.name === "exception");
+        if (exception) attributes(exception.attributes);
+        const exceptionType = textAttribute(
+          exception?.attributes,
+          "exception.type"
+        ), exceptionMessage = textAttribute(
+          exception?.attributes,
+          "exception.message"
+        );
+        const usage = {};
+        for (const [target, key2] of [
+          ["inputTokens", "gen_ai.usage.input_tokens"],
+          ["outputTokens", "gen_ai.usage.output_tokens"],
+          ["totalTokens", "gen_ai.usage.total_tokens"]
+        ]) {
+          const v = a[key2];
+          if (typeof v === "number" && Number.isSafeInteger(v) && v >= 0)
+            usage[target] = v;
+        }
+        let args = hasBinaryValue(
+          attributeEncoding(s.attributes, "gen_ai.tool.call.arguments")
+        ) ? void 0 : a["gen_ai.tool.call.arguments"];
+        if (typeof args === "string") {
+          try {
+            args = JSON.parse(args);
+          } catch {
+          }
+        }
+        const startTime = timestamp(s.startTimeUnixNano), endTime = timestamp(s.endTimeUnixNano);
+        const parent = string(s.parentSpanId);
+        if (s.parentSpanId !== void 0 && typeof s.parentSpanId !== "string")
+          throw new AwiError("Invalid OTLP parent identity");
+        if (parent && !/^[a-fA-F0-9]{16}$/.test(parent))
+          throw new AwiError("Invalid OTLP parent identity");
+        const op = {
+          id: id.toLowerCase(),
+          type,
+          name: string(s.name) || "unnamed",
+          status: status === 2 || status === "STATUS_CODE_ERROR" ? "error" : status === 1 || status === "STATUS_CODE_OK" ? "ok" : "unknown",
+          ...parent && !/^0+$/.test(parent) ? { parentId: parent.toLowerCase() } : {},
+          ...tool ? { toolName: tool } : {},
+          ...startTime ? { startTime } : {},
+          ...endTime ? { endTime } : {},
+          ...args !== void 0 ? { arguments: args } : {},
+          ...Object.keys(usage).length ? { usage } : {},
+          ...exception || (status === 2 || status === "STATUS_CODE_ERROR") && typeof statusRecord.message === "string" ? {
+            error: {
+              ...exceptionType !== void 0 ? { code: exceptionType } : {},
+              ...exceptionMessage !== void 0 ? { message: exceptionMessage } : typeof statusRecord.message === "string" ? { message: statusRecord.message } : {}
+            }
+          } : {},
+          metadata: {
+            "awi.operation_name_recorded": typeof s.name === "string" && s.name.length > 0,
+            attributes: a,
+            resource: resourceAttributes,
+            scope: record(scope).scope ?? {},
+            events: s.events ?? []
+          },
+          source: { format: "otel", index: total - 1 }
+        };
+        if (args !== void 0) validateValue(args);
+        const key = traceId.toLowerCase();
+        if (!grouped.has(key))
+          grouped.set(key, { version: 1, traceId: key, operations: [] });
+        grouped.get(key).operations.push(op);
+      }
+  }
+  const result = [...grouped.values()];
+  validateValue(result);
+  return result;
+}
+function ingest(value, format = "auto") {
+  validateValue(value);
+  const root = record(value);
+  const isOtel = "resourceSpans" in root;
+  const isAwi = "operations" in root || "traces" in root;
+  if (format === "auto") {
+    if (isOtel === isAwi)
+      throw new AwiError("Ambiguous or unsupported trace format");
+    format = isOtel ? "otel" : "awi";
+  }
+  if (format === "otel") return otel(value);
+  if (format !== "awi") throw new AwiError("Unsupported input format");
+  const collection = "traces" in root ? z.strictObject({
+    version: z.literal(1),
+    traces: z.array(traceSchema).max(LIMITS.traces)
+  }).safeParse(value) : null;
+  if (collection) {
+    if (!collection.success) throw new AwiError("Invalid AWI trace collection");
+    if (collection.data.traces.reduce((n, t) => n + t.operations.length, 0) > LIMITS.spans)
+      throw new AwiError("Maximum total span count exceeded");
+    return collection.data.traces.map((t) => ({
+      ...t,
+      operations: t.operations.map((op, index) => ({
+        ...op,
+        source: { format: "awi", index }
+      }))
+    }));
+  }
+  const parsed = traceSchema.safeParse(value);
+  if (!parsed.success)
+    throw new AwiError(
+      "Invalid AWI trace schema: " + parsed.error.issues.map((i) => i.path.join(".") + ": " + i.code).join("; ")
+    );
+  return [
+    {
+      ...parsed.data,
+      operations: parsed.data.operations.map((op, index) => ({
+        ...op,
+        source: { format: "awi", index }
+      }))
+    }
+  ];
+}
+
+// src/config/index.ts
+import { z as z2 } from "zod";
+var positive = z2.number().int().min(1);
+var repeat = (threshold) => z2.strictObject({
+  enabled: z2.boolean().default(true),
+  threshold: positive.min(2).max(LIMITS.repetitionWindow).default(threshold)
+});
+var configSchema = z2.strictObject({
+  version: z2.literal(1).default(1),
+  rules: z2.strictObject({
+    AWI001: repeat(4).default({ enabled: true, threshold: 4 }),
+    AWI002: repeat(3).default({ enabled: true, threshold: 3 }),
+    AWI003: z2.strictObject({
+      enabled: z2.boolean().default(true),
+      minRepetitions: positive.min(2).max(100).default(3),
+      maxCycleLength: positive.min(2).max(16).default(6)
+    }).default({ enabled: true, minRepetitions: 3, maxCycleLength: 6 }),
+    AWI004: z2.strictObject({
+      enabled: z2.boolean().default(true),
+      threshold: positive.min(2).max(LIMITS.repetitionWindow).default(5),
+      windowSeconds: positive.max(3600).default(30)
+    }).default({ enabled: true, threshold: 5, windowSeconds: 30 }),
+    AWI005: z2.strictObject({
+      enabled: z2.boolean().default(true),
+      maxOperations: positive.max(5e4).default(100),
+      maxDepth: positive.max(1e3).default(20)
+    }).default({ enabled: true, maxOperations: 100, maxDepth: 20 }),
+    AWI006: z2.strictObject({ enabled: z2.boolean().default(true) }).default({ enabled: true })
+  }).default({
+    AWI001: { enabled: true, threshold: 4 },
+    AWI002: { enabled: true, threshold: 3 },
+    AWI003: { enabled: true, minRepetitions: 3, maxCycleLength: 6 },
+    AWI004: { enabled: true, threshold: 5, windowSeconds: 30 },
+    AWI005: { enabled: true, maxOperations: 100, maxDepth: 20 },
+    AWI006: { enabled: true }
+  }),
+  fingerprint: z2.strictObject({
+    ignorePaths: z2.array(
+      z2.string().regex(/^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/).refine(
+        (p) => p.split(".").length <= LIMITS.depth && !p.split(".").some(
+          (k) => ["__proto__", "constructor", "prototype"].includes(k)
+        )
+      )
+    ).max(100).default([])
+  }).default({ ignorePaths: [] })
+});
+function resolveConfig(value = {}) {
+  validateValue(value);
+  const parsed = configSchema.safeParse(value);
+  if (!parsed.success)
+    throw new AwiError(
+      "Invalid configuration: " + parsed.error.issues.map((i) => i.path.join(".") + ": " + i.code).join("; ")
+    );
+  return parsed.data;
+}
+
+// src/core/fingerprinting.ts
+import { createHash } from "crypto";
+var ignoredPathCache = /* @__PURE__ */ new WeakMap();
+function compileIgnorePaths(paths) {
+  if (!Array.isArray(paths) || Object.getPrototypeOf(paths) !== Array.prototype || paths.length > 100)
+    throw new AwiError("Invalid fingerprint ignore paths");
+  const values = [];
+  if (Reflect.ownKeys(paths).length !== paths.length + 1)
+    throw new AwiError("Invalid fingerprint ignore paths");
+  for (let index = 0; index < paths.length; index++) {
+    const descriptor = Object.getOwnPropertyDescriptor(paths, String(index));
+    if (!descriptor || descriptor.get || descriptor.set || typeof descriptor.value !== "string")
+      throw new AwiError("Invalid fingerprint ignore paths");
+    values.push(descriptor.value);
+  }
+  const cached = ignoredPathCache.get(paths);
+  if (cached && cached.snapshot.length === values.length && values.every((value, index) => value === cached.snapshot[index]))
+    return cached.root;
+  validateIgnorePaths(values);
+  const root = values.length ? { ignored: false, children: /* @__PURE__ */ new Map() } : void 0;
+  for (const path of values) {
+    let node = root;
+    for (const part of path.split(".")) {
+      let child = node.children.get(part);
+      if (!child) {
+        child = { ignored: false, children: /* @__PURE__ */ new Map() };
+        node.children.set(part, child);
+      }
+      node = child;
+    }
+    node.ignored = true;
+  }
+  ignoredPathCache.set(paths, { snapshot: values, root });
+  return root;
+}
+function canonicalize(value, ignorePaths = []) {
+  validateValue(value);
+  const root = compileIgnorePaths(ignorePaths);
+  function encode(v, node) {
+    if (Array.isArray(v))
+      return "[" + v.map((item) => encode(item, void 0)).join(",") + "]";
+    if (v && typeof v === "object")
+      return "{" + Object.keys(v).sort().filter((key) => !node?.children.get(key)?.ignored).map(
+        (key) => JSON.stringify(key) + ":" + encode(
+          v[key],
+          node?.children.get(key)
+        )
+      ).join(",") + "}";
+    return JSON.stringify(v);
+  }
+  return encode(value, root);
+}
+function hash(value) {
+  return createHash("sha256").update(canonicalize(value)).digest("hex");
+}
+function fingerprint(op, ignorePaths = []) {
+  validateValue(op, true);
+  compileIgnorePaths(ignorePaths);
+  const tool = op.toolName ?? op.name;
+  if (typeof tool !== "string" || !["tool", "agent", "model", "workflow", "generic"].includes(op.type))
+    throw new AwiError("Invalid operation fingerprint identity");
+  const digest = createHash("sha256").update('{"arguments":');
+  if (op.arguments === void 0) digest.update('{"present":false}');
+  else
+    digest.update('{"present":true,"value":').update(JSON.stringify(canonicalize(op.arguments, ignorePaths))).update("}");
+  return digest.update(',"tool":').update(JSON.stringify(tool)).update(',"type":').update(JSON.stringify(op.type)).update(',"version":"awi-sha256-v1"}').digest("hex");
+}
+
+// src/core/normalization.ts
+function normalize(trace) {
+  if (trace.operations.length > LIMITS.spans)
+    throw new AwiError("Maximum span count exceeded");
+  const ids = /* @__PURE__ */ new Map();
+  const warnings = [];
+  for (const op of trace.operations) {
+    if (ids.has(op.id)) throw new AwiError("Duplicate operation identity");
+    ids.set(op.id, op);
+    if (op.startTime && op.endTime && timeNanoseconds(op.endTime) < timeNanoseconds(op.startTime))
+      throw new AwiError("End timestamp precedes start timestamp");
+  }
+  const depths = /* @__PURE__ */ new Map();
+  let depth = 0;
+  for (const op of trace.operations) {
+    const path = [];
+    const seen = /* @__PURE__ */ new Set();
+    let current = op;
+    while (current && !depths.has(current.id)) {
+      if (seen.has(current.id)) throw new AwiError("Cyclic parent references");
+      seen.add(current.id);
+      path.push(current);
+      const parent = current.parentId ? ids.get(current.parentId) : void 0;
+      if (current.parentId && !parent)
+        warnings.push(
+          "Missing parent reference; observed depth is a lower bound."
+        );
+      current = parent;
+    }
+    let d = current ? depths.get(current.id) : 0;
+    for (const item of path.reverse()) {
+      depths.set(item.id, ++d);
+      depth = Math.max(depth, d);
+    }
+  }
+  const children = /* @__PURE__ */ new Map();
+  for (const op of trace.operations) {
+    const key = op.parentId ?? "";
+    const group = children.get(key) ?? [];
+    group.push(op);
+    children.set(key, group);
+  }
+  return { trace, depth, warnings: [...new Set(warnings)], children };
+}
+function sequentialRuns(ops) {
+  if (ops.some(
+    (o) => !o.startTime || !o.endTime || timeNanoseconds(o.endTime) <= timeNanoseconds(o.startTime)
+  ))
+    return [];
+  const timed = ops.map((op) => ({
+    op,
+    start: timeNanoseconds(op.startTime),
+    end: timeNanoseconds(op.endTime)
+  })).sort(
+    (a, b) => a.start < b.start ? -1 : a.start > b.start ? 1 : a.op.id < b.op.id ? -1 : a.op.id > b.op.id ? 1 : 0
+  );
+  const runs = [];
+  let run = [];
+  let overlapEnd;
+  for (const item of timed) {
+    if (overlapEnd !== void 0) {
+      if (item.start < overlapEnd) {
+        if (item.end > overlapEnd) overlapEnd = item.end;
+        continue;
+      }
+      overlapEnd = void 0;
+    }
+    const previous = run.at(-1);
+    if (previous && item.start < previous.end) {
+      run.pop();
+      if (run.length) runs.push(run.map((value) => value.op));
+      run = [];
+      overlapEnd = previous.end > item.end ? previous.end : item.end;
+      continue;
+    }
+    run.push(item);
+  }
+  if (run.length) runs.push(run.map((value) => value.op));
+  return runs;
+}
+
+// src/core/analysis.ts
+var severityRank = {
+  low: 1,
+  medium: 2,
+  high: 3
+};
+var titles = {
+  AWI001: "Repeated identical tool call",
+  AWI002: "Repeated identical failing tool call",
+  AWI003: "Repeating execution cycle",
+  AWI004: "Retry storm",
+  AWI005: "Excessive execution steps or depth",
+  AWI006: "Recorded resource usage associated with suspicious execution"
+};
+function analyze(traces, configInput = {}, showContent = false) {
+  const config = resolveConfig(configInput);
+  validateValue(traces, true);
+  if (!Array.isArray(traces) || traces.length > LIMITS.traces)
+    throw new AwiError("Invalid or oversized trace collection");
+  const analysisTraceSchema = traceSchema.extend({
+    operations: z3.array(
+      traceSchema.shape.operations.element.extend({
+        source: z3.strictObject({
+          format: z3.enum(["awi", "otel"]),
+          index: z3.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER)
+        }).optional()
+      })
+    ).max(LIMITS.spans)
+  });
+  const validated = [];
+  let total = 0;
+  for (const trace of traces) {
+    if (!trace || !Array.isArray(trace.operations))
+      throw new AwiError("Invalid canonical trace supplied to analysis");
+    total += trace.operations.length;
+    if (total > LIMITS.spans)
+      throw new AwiError("Maximum total span count exceeded");
+    const result = analysisTraceSchema.safeParse({
+      ...trace,
+      operations: trace.operations.map(
+        (op) => op && typeof op === "object" ? Object.fromEntries(
+          Object.entries(op).filter(([, value]) => value !== void 0)
+        ) : op
+      )
+    });
+    if (!result.success)
+      throw new AwiError("Invalid canonical trace supplied to analysis");
+    if (result.data.metadata === void 0) delete result.data.metadata;
+    for (const op of result.data.operations) {
+      if (op.error)
+        op.error = Object.fromEntries(
+          Object.entries(op.error).filter(([, value]) => value !== void 0)
+        );
+      if (op.usage)
+        op.usage = Object.fromEntries(
+          Object.entries(op.usage).filter(([, value]) => value !== void 0)
+        );
+    }
+    validateValue(result.data);
+    validated.push(result.data);
+  }
+  const report = {
+    version: 1,
+    fingerprintVersion: "awi-sha256-v1",
+    complete: true,
+    summaries: [],
+    findings: [],
+    warnings: []
+  };
+  const grouped = /* @__PURE__ */ new Map();
+  for (const t of validated) {
+    const existing = grouped.get(t.traceId);
+    if (existing) for (const op of t.operations) existing.operations.push(op);
+    else grouped.set(t.traceId, { ...t, operations: [...t.operations] });
+  }
+  let capped = false;
+  function add(ruleId, traceId, ops, evidence, explanation, confidence = "moderate") {
+    if (report.findings.length >= LIMITS.findings) {
+      capped = true;
+      return;
+    }
+    report.findings.push({
+      ruleId,
+      traceId,
+      severity: ruleId === "AWI002" || ruleId === "AWI004" ? "high" : "medium",
+      confidence,
+      title: titles[ruleId],
+      description: "Heuristic finding based on recorded execution evidence; intentional behavior may match.",
+      explanation,
+      remediation: "Review the referenced operations and configured policy before changing the workflow.",
+      operationIds: ops.map((o) => o.id),
+      evidence: {
+        ...evidence,
+        references: ops.map((op) => ({
+          operationId: op.id,
+          ...op.source ? { source: { format: op.source.format, index: op.source.index } } : {}
+        }))
+      }
+    });
+  }
+  for (const trace of [...grouped.values()].sort(
+    (a, b) => a.traceId < b.traceId ? -1 : a.traceId > b.traceId ? 1 : 0
+  )) {
+    trace.operations.sort((a, b) => compare(a.id, b.id));
+    const normalized = normalize(trace);
+    report.warnings.push(...normalized.warnings);
+    const starts = trace.operations.flatMap(
+      (o) => o.startTime ? [timeNanoseconds(o.startTime)] : []
+    ), ends = trace.operations.flatMap(
+      (o) => o.endTime ? [timeNanoseconds(o.endTime)] : []
+    );
+    const leaves = trace.operations.filter(
+      (o) => !normalized.children.has(o.id)
+    );
+    const usage = {};
+    for (const key of ["inputTokens", "outputTokens", "totalTokens"]) {
+      const values = leaves.flatMap(
+        (o) => o.usage?.[key] !== void 0 ? [o.usage[key]] : []
+      );
+      if (values.length) {
+        const total2 = values.reduce((a, b) => a + b, 0);
+        if (!Number.isSafeInteger(total2))
+          throw new AwiError(
+            "Recorded token aggregate exceeds safe integer range"
+          );
+        usage[key] = total2;
+      }
+    }
+    report.summaries.push({
+      traceId: trace.traceId,
+      operations: trace.operations.length,
+      toolCalls: trace.operations.filter((o) => o.type === "tool").length,
+      maxDepth: normalized.depth,
+      ...starts.length === trace.operations.length && ends.length === trace.operations.length && starts.length ? {
+        durationMs: Number(
+          ends.reduce((a, b) => a > b ? a : b) - starts.reduce((a, b) => a < b ? a : b)
+        ) / 1e6
+      } : {},
+      ...Object.keys(usage).length ? { usage } : {}
+    });
+    if (trace.operations.some(
+      (o) => o.type === "tool" && o.arguments === void 0
+    ))
+      report.warnings.push(
+        "Tool calls without recorded arguments excluded from identity-based rules."
+      );
+    if (trace.operations.some((o) => o.type === "tool" && !toolIdentityKnown(o)))
+      report.warnings.push(
+        "Tool calls without recorded tool identity excluded from identity-based rules."
+      );
+    const before = report.findings.length;
+    const fps = new Map(
+      trace.operations.filter((o) => o.type === "tool" && toolIdentityKnown(o)).map((o) => [o.id, fingerprint(o, config.fingerprint.ignorePaths)])
+    );
+    for (const siblings of normalized.children.values()) {
+      if (siblings.some(
+        (o) => !o.startTime || !o.endTime || timeNanoseconds(o.endTime) <= timeNanoseconds(o.startTime)
+      ))
+        report.warnings.push(
+          "Sibling groups with missing or zero-duration timing excluded from sequence rules; recorded order does not establish sequential execution."
+        );
+      const runs = sequentialRuns(siblings);
+      if (runs.flat().length < siblings.length && siblings.every(
+        (o) => o.startTime && o.endTime && timeNanoseconds(o.endTime) > timeNanoseconds(o.startTime)
+      ))
+        report.warnings.push(
+          "Overlapping sibling operations excluded from sequence rules."
+        );
+      for (const run of runs) {
+        let segment = [];
+        const segments = [];
+        for (const op of run) {
+          if (op.type !== "tool") continue;
+          if (op.arguments !== void 0 && toolIdentityKnown(op))
+            segment.push(op);
+          else if (segment.length) {
+            segments.push(segment);
+            segment = [];
+          }
+        }
+        if (segment.length) segments.push(segment);
+        for (const tools of segments) {
+          const groups = /* @__PURE__ */ new Map();
+          for (let base = 0; base < tools.length; base += LIMITS.repetitionWindow) {
+            groups.clear();
+            for (const op of tools.slice(
+              base,
+              base + LIMITS.repetitionWindow
+            )) {
+              const fp = fps.get(op.id);
+              const group = groups.get(fp) ?? [];
+              group.push(op);
+              groups.set(fp, group);
+            }
+            for (const group of groups.values()) {
+              const failures = /* @__PURE__ */ new Map();
+              for (const op of group)
+                if (op.status === "error" && (!!op.error?.code?.trim() || !!op.error?.message?.trim())) {
+                  const key = hash(op.error);
+                  const bucket = failures.get(key) ?? [];
+                  bucket.push(op);
+                  failures.set(key, bucket);
+                }
+              const specific = /* @__PURE__ */ new Set();
+              if (config.rules.AWI002.enabled) {
+                for (const bucket of failures.values())
+                  if (bucket.length >= config.rules.AWI002.threshold) {
+                    add(
+                      "AWI002",
+                      trace.traceId,
+                      bucket,
+                      {
+                        occurrences: bucket.length,
+                        identicalArguments: true,
+                        equivalentFailureOutcomes: true
+                      },
+                      "Equivalent recorded tool calls failed with matching error evidence. This does not establish a defective retry policy.",
+                      "high"
+                    );
+                    bucket.forEach((o) => specific.add(o.id));
+                  }
+              }
+              const general = group.filter((o) => !specific.has(o.id));
+              if (config.rules.AWI001.enabled && general.length >= config.rules.AWI001.threshold)
+                add(
+                  "AWI001",
+                  trace.traceId,
+                  general,
+                  { occurrences: general.length, identicalArguments: true },
+                  "Identical calls occur in a bounded group of sequential sibling tool calls. Polling may be intentional.",
+                  "high"
+                );
+              if (config.rules.AWI004.enabled) {
+                let cursor = 0;
+                while (cursor < group.length) {
+                  const first = group[cursor];
+                  let end = cursor + 1;
+                  while (end < group.length && group[end - 1].status === "error" && timeNanoseconds(group[end].startTime) - timeNanoseconds(first.startTime) <= BigInt(config.rules.AWI004.windowSeconds) * 1000000000n)
+                    end++;
+                  const attempts = group.slice(cursor, end);
+                  if (attempts.length >= config.rules.AWI004.threshold && attempts.slice(0, -1).every((o) => o.status === "error")) {
+                    add(
+                      "AWI004",
+                      trace.traceId,
+                      attempts,
+                      {
+                        attempts: attempts.length,
+                        windowSeconds: config.rules.AWI004.windowSeconds,
+                        priorAttemptsExplicitlyFailed: true
+                      },
+                      "Rapid equivalent attempts follow explicit failures; retry intent remains inferred."
+                    );
+                    cursor = end;
+                  } else cursor++;
+                }
+              }
+            }
+          }
+          if (config.rules.AWI003.enabled) {
+            const { maxCycleLength, minRepetitions } = config.rules.AWI003;
+            for (let i = 0; i < tools.length; ) {
+              let consumed = 0;
+              for (let length = 2; length <= maxCycleLength && i + length * minRepetitions <= tools.length; length++) {
+                const pattern = tools.slice(i, i + length).map((o) => fps.get(o.id));
+                if (new Set(pattern).size < 2) continue;
+                let repeats = 1;
+                while (i + (repeats + 1) * length <= tools.length && tools.slice(i + repeats * length, i + (repeats + 1) * length).every((o, j) => fps.get(o.id) === pattern[j]))
+                  repeats++;
+                if (repeats >= minRepetitions) {
+                  consumed = length * repeats;
+                  add(
+                    "AWI003",
+                    trace.traceId,
+                    tools.slice(i, i + consumed),
+                    { cycleLength: length, repetitions: repeats },
+                    "A bounded tool fingerprint sequence repeats among timed, non-overlapping siblings. Intent and causality are unknown."
+                  );
+                  break;
+                }
+              }
+              i += consumed || 1;
+            }
+          }
+        }
+      }
+    }
+    const policy = config.rules.AWI005;
+    if (policy.enabled && (trace.operations.length > policy.maxOperations || normalized.depth > policy.maxDepth))
+      add(
+        "AWI005",
+        trace.traceId,
+        [],
+        {
+          operations: trace.operations.length,
+          maxDepth: normalized.depth,
+          limits: { operations: policy.maxOperations, depth: policy.maxDepth }
+        },
+        "Observed workflow size exceeds configured policy; complexity alone is not a defect.",
+        "high"
+      );
+    if (config.rules.AWI006.enabled) {
+      const related = report.findings.slice(before).filter((f) => f.ruleId !== "AWI005");
+      const implicated = new Set(related.flatMap((f) => f.operationIds));
+      const recorded = leaves.filter(
+        (o) => implicated.has(o.id) && (Object.keys(o.usage ?? {}).length > 0 || o.cost)
+      );
+      if (recorded.length) {
+        const tokens = {};
+        const costs = {};
+        for (const op of recorded) {
+          for (const [key, n] of Object.entries(op.usage ?? {}))
+            if (n !== void 0) tokens[key] = (tokens[key] ?? 0) + n;
+          if (op.cost)
+            costs[op.cost.currency] = (costs[op.cost.currency] ?? 0) + op.cost.amount;
+          if (Object.values(costs).some((n) => !Number.isFinite(n)))
+            throw new AwiError("Recorded cost aggregate exceeds numeric range");
+        }
+        add(
+          "AWI006",
+          trace.traceId,
+          recorded,
+          {
+            recordedUsage: tokens,
+            recordedCosts: costs,
+            coverage: "Only implicated leaf operations with recorded usage or cost",
+            relatedRules: [...new Set(related.map((f) => f.ruleId))]
+          },
+          "Recorded resources belong directly to operations in suspicious patterns. Association does not establish waste."
+        );
+      }
+    }
+  }
+  if (capped) {
+    report.complete = false;
+    report.warnings.push("Finding limit reached; report is truncated.");
+  }
+  report.findings.sort(
+    (a, b) => severityRank[b.severity] - severityRank[a.severity] || compare(a.traceId, b.traceId) || compare(a.ruleId, b.ruleId) || compare(a.operationIds.join("\0"), b.operationIds.join("\0"))
+  );
+  report.warnings = [...new Set(report.warnings)].sort();
+  try {
+    validateValue(report);
+  } catch (error) {
+    if (error instanceof AwiError)
+      throw new AwiError("Report exceeds resource limits");
+    throw error;
+  }
+  if (showContent)
+    report.content = [...grouped.values()].sort((a, b) => compare(a.traceId, b.traceId)).map((t) => ({
+      traceId: t.traceId,
+      operations: redact(t.operations)
+    }));
+  return report;
+}
+function compare(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function toolIdentityKnown(op) {
+  return op.source?.format !== "otel" || !!op.toolName || op.metadata?.["awi.operation_name_recorded"] !== false;
+}
+
+// src/core/reporting.ts
+function humanReport(report, options = {}) {
+  const paint = (text, severity) => options.color ? `\x1B[${severity === "high" ? 31 : 33}m${text}\x1B[0m` : text;
+  const lines = [
+    "Agent Workflow Inspector \u2014 Find loops, retries, and wasted work in AI agent traces."
+  ];
+  for (const t of report.summaries)
+    lines.push(
+      `Trace ${safeText(t.traceId)}: ${t.operations} operations, ${t.toolCalls} tool calls, depth ${t.maxDepth}; duration ${t.durationMs === void 0 ? "unknown" : t.durationMs + " ms"}; recorded leaf usage ${t.usage ? JSON.stringify(t.usage) : "unknown"}`
+    );
+  for (const f of report.findings)
+    lines.push(
+      `
+${paint("[" + f.severity.toUpperCase() + "]", f.severity)} ${safeText(f.ruleId)} ${safeText(f.title)} (${safeText(f.confidence)} evidence)`,
+      `  Trace: ${safeText(f.traceId)}; operations: ${f.operationIds.map(safeText).join(", ") || "trace-wide"}`,
+      `  ${safeText(f.explanation)}`,
+      `  Evidence: ${safeText(JSON.stringify(f.evidence))}`
+    );
+  for (const warning of report.warnings)
+    lines.push("Warning: " + safeText(warning));
+  if (report.content)
+    lines.push(
+      "Content (opt-in, key-based redaction): " + safeText(JSON.stringify(report.content))
+    );
+  lines.push(
+    `
+${report.findings.length} findings; analysis ${report.complete ? "complete" : "INCOMPLETE"}.`
+  );
+  return lines.join("\n") + "\n";
+}
+function jsonReport(report) {
+  return JSON.stringify(report, null, 2).replace(
+    /[\u007f-\u009f\p{Cf}\p{Zl}\p{Zp}]/gu,
+    (value) => value.split("").map((c) => "\\u" + c.charCodeAt(0).toString(16).padStart(4, "0")).join("")
+  ) + "\n";
+}
+
+// src/cli/index.ts
+async function noSymlinkComponents(path) {
+  const absolute = resolve(path), root = parsePath(absolute).root;
+  const parts = [];
+  let current = absolute;
+  while (current !== root) {
+    parts.push(current);
+    current = dirname(current);
+  }
+  for (const part of parts.reverse())
+    if ((await lstat(part)).isSymbolicLink())
+      throw new AwiError("Symlinks are not supported in paths");
+}
+async function readJson(path, maxBytes = LIMITS.fileBytes) {
+  await noSymlinkComponents(path);
+  const stat = await lstat(path);
+  if (!stat.isFile() || stat.isSymbolicLink())
+    throw new AwiError("Input must be a regular non-symlink file");
+  const limit = Math.min(LIMITS.fileBytes, maxBytes);
+  if (stat.size > limit)
+    throw new AwiError("Input exceeds maximum allowed file or aggregate size");
+  const file = await open(
+    path,
+    constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0)
+  );
+  try {
+    const after = await file.stat();
+    if (!after.isFile() || after.dev !== stat.dev || after.ino !== stat.ino || after.size > limit)
+      throw new AwiError("Invalid or changed input file");
+    const chunks = [];
+    let size = 0;
+    while (size <= limit) {
+      const chunk = Buffer.alloc(Math.min(65536, limit + 1 - size));
+      const result = await file.read(chunk, 0, chunk.length, null);
+      if (!result.bytesRead) break;
+      size += result.bytesRead;
+      if (size > limit)
+        throw new AwiError(
+          "Input exceeds maximum allowed file or aggregate size"
+        );
+      chunks.push(chunk.subarray(0, result.bytesRead));
+    }
+    let text;
+    try {
+      text = new TextDecoder("utf-8", { fatal: true }).decode(
+        Buffer.concat(chunks, size)
+      );
+    } catch {
+      throw new AwiError("Input is not valid UTF-8");
+    }
+    return { value: parseJson(text), bytes: size };
+  } finally {
+    await file.close();
+  }
+}
+async function collect(paths) {
+  const files = /* @__PURE__ */ new Set();
+  let entries = 0;
+  async function visit(path, depth) {
+    if (++entries > 2048 || depth > 16)
+      throw new AwiError("Directory traversal limit exceeded");
+    const stat = await lstat(path);
+    if (stat.isSymbolicLink()) throw new AwiError("Symlinks are not supported");
+    if (stat.isDirectory()) {
+      const directory = await opendir(path);
+      const names = [];
+      for await (const entry of directory) {
+        if (entries + names.length >= 2048)
+          throw new AwiError("Directory traversal limit exceeded");
+        names.push(entry.name);
+      }
+      if (!names.length) throw new AwiError("Empty input directory");
+      for (const name of names.sort()) await visit(join(path, name), depth + 1);
+    } else {
+      if (!stat.isFile() || !path.toLowerCase().endsWith(".json"))
+        throw new AwiError("Only regular .json input files are supported");
+      files.add(await realpath(path));
+      if (files.size > LIMITS.files)
+        throw new AwiError("Maximum input file count exceeded");
+    }
+  }
+  for (const path of paths) {
+    await noSymlinkComponents(path);
+    await visit(resolve(path), 0);
+  }
+  return [...files].sort();
+}
+async function writeReport(path, body) {
+  const target = resolve(path), temporary = join(dirname(target), ".awi-report-" + randomUUID() + ".tmp");
+  await noSymlinkComponents(dirname(target));
+  try {
+    const file = await open(temporary, "wx", 384);
+    try {
+      await file.writeFile(body, "utf8");
+      await file.sync();
+    } finally {
+      await file.close();
+    }
+    await link(temporary, target);
+  } finally {
+    await unlink(temporary).catch(() => {
+    });
+  }
+}
+process.stderr.on("error", () => {
+  process.exitCode = 1;
+});
+process.stdout.on("error", () => {
+  process.exitCode = 1;
+  process.stderr.write("awi: Unable to write report output\n");
+});
+var program = new Command().configureOutput({
+  writeErr: (text) => {
+    process.stderr.write(safeText(text) + "\n");
+  }
+}).name("awi").description("Find loops, retries, and wasted work in AI agent traces.").version("1.0.0");
+program.command("inspect").argument("<paths...>", "JSON files or directories (recursive; no symlinks)").addOption(
+  new Option("--format <format>").choices(["human", "json"]).default("human")
+).addOption(
+  new Option("--input-format <format>").choices(["auto", "awi", "otel"]).default("auto")
+).option("--config <path>", "Strict JSON configuration").addOption(
+  new Option("--fail-on <severity>", "Finding threshold; default: high").choices(["low", "medium", "high", "none"]).default("high")
+).option(
+  "--output <path>",
+  "Create a new report file; existing paths are refused"
+).option("--no-color", "Disable colors (output is plain text)").option(
+  "--show-content",
+  "Include recorded content with key-based redaction; may expose private data"
+).action(
+  async (paths, options) => {
+    const files = await collect(paths);
+    const config = resolveConfig(
+      options.config ? (await readJson(resolve(options.config))).value : {}
+    );
+    const traces = [];
+    let count2 = 0;
+    let totalBytes = 0;
+    for (const path of files) {
+      const input = await readJson(path, LIMITS.aggregateBytes - totalBytes);
+      totalBytes += input.bytes;
+      const imported = ingest(input.value, options.inputFormat);
+      count2 += imported.reduce((n, t) => n + t.operations.length, 0);
+      if (count2 > LIMITS.spans)
+        throw new AwiError("Maximum total span count exceeded");
+      if (traces.length + imported.length > LIMITS.traces)
+        throw new AwiError("Maximum trace count exceeded");
+      for (const trace of imported) traces.push(trace);
+    }
+    if (!traces.length) throw new AwiError("No traces found");
+    const report = analyze(traces, config, options.showContent);
+    const body = options.format === "json" ? jsonReport(report) : humanReport(report, {
+      color: !options.output && process.env.TERM !== "dumb" && options.color !== false && !!process.stdout.isTTY && !("NO_COLOR" in process.env)
+    });
+    if (options.output) await writeReport(options.output, body);
+    else process.stdout.write(body);
+    process.exitCode = !report.complete ? 1 : options.failOn !== "none" && report.findings.some(
+      (f) => severityRank[f.severity] >= severityRank[options.failOn]
+    ) ? 2 : 0;
+  }
+);
+program.parseAsync().catch((error) => {
+  const message = error instanceof AwiError ? error.message : "Filesystem or internal operation failed";
+  process.stderr.write("awi: " + safeText(message) + "\n");
+  process.exitCode = 1;
+});
+//# sourceMappingURL=index.js.map