@tangle-network/traces 0.8.16 → 0.8.17

package/dist/{chunk-EOQY2RIK.js → chunk-QM4QAG3V.js}

@@ -2726,7 +2726,9 @@ function hashId(value, chars = 16) {
 }
 function isoTime(value) {
   if (typeof value === "string") {
-    const ms = Date.parse(value);
+    const trimmed = value.trim();
+    const normalized = /^\d{4}-\d{2}-\d{2}[ T]\d{2}:\d{2}:\d{2}(?:\.\d+)?$/.test(trimmed) ? `${trimmed.replace(" ", "T")}Z` : trimmed;
+    const ms = Date.parse(normalized);
     return Number.isFinite(ms) ? new Date(ms).toISOString() : void 0;
   }
   if (typeof value === "number" && Number.isFinite(value)) {
@@ -2768,14 +2770,19 @@ function parseJsonRows(text) {
   const trimmed = text.trim();
   if (!trimmed) throw new Error("input file is empty");
   if (trimmed.startsWith("[") || trimmed.startsWith("{")) {
-    const parsed = JSON.parse(trimmed);
-    if (Array.isArray(parsed)) return { rows: parsed };
-    if (isObject(parsed)) {
-      const events = parsed.events;
-      if (Array.isArray(events)) return { rows: events, wrapper: parsed };
-      return { rows: [parsed] };
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (Array.isArray(parsed)) return { rows: parsed };
+      if (isObject(parsed)) {
+        const events = parsed.events;
+        if (Array.isArray(events)) return { rows: events, wrapper: parsed };
+        return { rows: [parsed] };
+      }
+      throw new Error("input JSON must be an object, array, or JSONL rows");
+    } catch (error) {
+      const hasMultipleRows = /\r?\n/.test(trimmed);
+      if (!hasMultipleRows) throw error;
     }
-    throw new Error("input JSON must be an object, array, or JSONL rows");
   }
   return {
     rows: trimmed.split(/\r?\n/).filter((line) => line.trim().length > 0).map((line) => JSON.parse(line))
@@ -2788,6 +2795,10 @@ function isOpenInferenceRow(row) {
   if (!isObject(row)) return false;
   return typeof row.trace_id === "string" && typeof row.span_id === "string" && typeof row.name === "string" && typeof row.start_time === "string" && typeof row.end_time === "string" && isObject(row.status) && isObject(row.attributes) && isObject(row.resource) && isObject(row.scope);
 }
+function isIntelligenceSpanRow(row) {
+  if (!isObject(row)) return false;
+  return typeof row.trace_id === "string" && typeof row.name === "string" && isObject(row.attributes) && (row.start_unix_nano != null || row.start_time != null || row.received_at != null);
+}
 function eventType(row) {
   return stringValue(row.type) ?? stringValue(row.event) ?? stringValue(row.name) ?? stringValue(row.kind);
 }
@@ -2801,8 +2812,9 @@ function detectFormat(rows, requested) {
   if (rows.length === 0) throw new Error("input contains no rows");
   if (rows.every(isPolicyEvidenceRow)) return "policy-evidence";
   if (rows.every(isOpenInferenceRow)) return "openinference";
+  if (rows.every(isIntelligenceSpanRow)) return "intelligence-spans";
   if (rows.some(looksLikeSandboxEvent)) return "sandbox-events";
-  throw new Error("could not detect input format; use --format policy-evidence, sandbox-events, or openinference");
+  throw new Error("could not detect input format; use --format policy-evidence, sandbox-events, openinference, or intelligence-spans");
 }
 function requirePolicyEvidenceRows(rows) {
   if (!rows.every(isPolicyEvidenceRow)) throw new Error("policy-evidence input must contain only traces.policy_evidence.session rows");
@@ -2812,6 +2824,10 @@ function requireOpenInferenceRows(rows) {
   if (!rows.every(isOpenInferenceRow)) throw new Error("openinference input must contain only complete OpenInference span rows");
   return rows;
 }
+function requireIntelligenceSpanRows(rows) {
+  if (!rows.every(isIntelligenceSpanRow)) throw new Error("intelligence-spans input must contain only Intelligence span rows");
+  return rows;
+}
 function requireObjectRows(rows) {
   if (!rows.every(isObject)) throw new Error("sandbox-events input must contain only JSON object events");
   return rows;
@@ -3008,6 +3024,112 @@ function sandboxEventsToSpans(rows, wrapper) {
 function statusCode(value) {
   return value === "OK" || value === "ERROR" || value === "UNSET" ? value : "UNSET";
 }
+function numberValue(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 unixNanoTime(value) {
+  if (value == null) return void 0;
+  try {
+    const ns = typeof value === "bigint" ? value : BigInt(String(value));
+    return new Date(Number(ns / 1000000n)).toISOString();
+  } catch {
+    return void 0;
+  }
+}
+function firstNumber(row, attrs, keys) {
+  for (const key of keys) {
+    const value = numberValue(row[key]) ?? numberValue(attrs[key]);
+    if (value != null) return value;
+  }
+  return void 0;
+}
+var COMPUTED_SPAN_ATTRIBUTES = /* @__PURE__ */ new Set([
+  "openinference.span.kind",
+  "service.name",
+  "agent.name",
+  "llm.model_name",
+  "tool.name",
+  "llm.input_tokens",
+  "llm.output_tokens",
+  "step",
+  "content"
+]);
+function preserveRawAttributes(attrs) {
+  const preserved = {};
+  for (const [key, value] of Object.entries(attrs)) {
+    if (COMPUTED_SPAN_ATTRIBUTES.has(key)) {
+      preserved[`traces.raw_attribute.${key}`] = value;
+    } else {
+      preserved[key] = value;
+    }
+  }
+  return preserved;
+}
+function intelligenceSpanKind(name, attrs) {
+  const lowered = name.toLowerCase();
+  const spanType = stringValue(attrs["span.type"])?.toLowerCase();
+  if (spanType === "llm_request" || lowered.includes("llm")) return "LLM";
+  if (spanType === "tool" || lowered.includes("tool") || attrs["tool.name"] != null || attrs.tool_name != null || attrs["mcp.tool.name"] != null || attrs["tool.input"] != null || attrs["tool.output"] != null) {
+    return "TOOL";
+  }
+  if (spanType === "interaction" || lowered.includes("interaction") || lowered.includes("agent")) return "AGENT";
+  return "CHAIN";
+}
+function intelligenceSpansToSpans(rows) {
+  return rows.map((row, index) => {
+    const attrs = { ...objectValue(row.attributes) ?? {} };
+    const name = stringValue(row.name) ?? "intelligence.span";
+    const startTime = unixNanoTime(row.start_unix_nano) ?? isoTime(row.start_time) ?? stringValue(row.start_time) ?? isoTime(row.received_at) ?? (/* @__PURE__ */ new Date(0)).toISOString();
+    const endTime = unixNanoTime(row.end_unix_nano) ?? isoTime(row.end_time) ?? stringValue(row.end_time) ?? startTime;
+    const model = stringValue(row.model) ?? stringValue(attrs["llm.model_name"]) ?? stringValue(attrs.model) ?? stringValue(attrs["gen_ai.request.model"]);
+    const tool = stringValue(attrs["tool.name"]) ?? stringValue(attrs.tool_name) ?? stringValue(attrs["mcp.tool.name"]);
+    const sessionId = stringValue(row.session_id) ?? stringValue(attrs["session.id"]);
+    const extra = {
+      ...preserveRawAttributes(attrs),
+      "traces.source_format": "intelligence-spans",
+      "traces.row.index": index
+    };
+    copyDefined(extra, {
+      "traces.row.id": stringValue(row.id),
+      [ATTR.SESSION_ID]: sessionId,
+      "session.id": sessionId,
+      "run.id": stringValue(row.run_id),
+      "thread.id": stringValue(row.thread_id),
+      "scenario.id": stringValue(row.scenario_id),
+      "generation.id": stringValue(row.generation),
+      "cell.id": stringValue(row.cell_id),
+      "project.key": stringValue(row.project_key),
+      "llm.cost_usd": numberValue(row.cost_usd),
+      "redaction.version": stringValue(row.redaction_version),
+      "traces.received_at": isoTime(row.received_at)
+    });
+    return span({
+      traceId: stringValue(row.trace_id) ?? hashId(row, 32),
+      spanId: stringValue(row.id) ?? hashId({ row, field: "span" }),
+      parentSpanId: stringValue(row.parent_span_id) ?? null,
+      name,
+      kind: intelligenceSpanKind(name, attrs),
+      startTime,
+      endTime,
+      status: statusCode(row.status_code),
+      statusMessage: stringValue(row.status_message),
+      service: stringValue(attrs["service.name"]) ?? stringValue(attrs.service_name) ?? "tangle-intelligence",
+      agent: stringValue(attrs["agent.name"]) ?? stringValue(attrs["service.name"]) ?? null,
+      model,
+      tool,
+      inputTokens: firstNumber(row, attrs, ["input_tokens", "llm.input_tokens"]),
+      outputTokens: firstNumber(row, attrs, ["output_tokens", "llm.output_tokens"]),
+      step: numberValue(attrs["interaction.sequence"]) ?? index,
+      content: stringValue(attrs.user_prompt) ?? stringValue(attrs["gen_ai.prompt.messages"]) ?? stringValue(attrs["log.content.task"]) ?? null,
+      extra
+    });
+  });
+}
 function openInferenceToSpans(rows) {
   return rows.map((row) => {
     const attrs = isObject(row.attributes) ? { ...row.attributes } : {};
@@ -3053,7 +3175,7 @@ function withExportAttributes(spans, attributes) {
 }
 function exportTraceEvidenceRows(rows, opts = {}, wrapper) {
   const format = detectFormat(rows, opts.format ?? "auto");
-  const converted = format === "policy-evidence" ? policyEvidenceToSpans(requirePolicyEvidenceRows(rows)) : format === "openinference" ? openInferenceToSpans(requireOpenInferenceRows(rows)) : sandboxEventsToSpans(requireObjectRows(rows), wrapper);
+  const converted = format === "policy-evidence" ? policyEvidenceToSpans(requirePolicyEvidenceRows(rows)) : format === "openinference" ? openInferenceToSpans(requireOpenInferenceRows(rows)) : format === "intelligence-spans" ? intelligenceSpansToSpans(requireIntelligenceSpanRows(rows)) : sandboxEventsToSpans(requireObjectRows(rows), wrapper);
   const spans = withExportAttributes(converted, opts.attributes);
   if (spans.length === 0) throw new Error(`no spans exported from ${format} input`);
   const redacted = redactSpans(spans);

package/dist/cli.js

@@ -40,7 +40,7 @@ import {
   writePolicyEvidenceFile,
   writeSessionIndexFile,
   writeTraceEvidenceExportFile
-} from "./chunk-EOQY2RIK.js";
+} from "./chunk-QM4QAG3V.js";
 
 // src/cli.ts
 import { readFileSync } from "fs";
@@ -326,10 +326,7 @@ async function cmdInspect(args) {
 }
 async function cmdExport(args) {
   if (!args.input) throw new Error("export needs an input file; run `traces export --help` for examples");
-  const format = args.format ?? "auto";
-  if (format !== "auto" && format !== "policy-evidence" && format !== "sandbox-events" && format !== "openinference") {
-    throw new Error("--format must be auto, policy-evidence, sandbox-events, or openinference");
-  }
+  const format = traceEvidenceFormat(args.format);
   const attributes = await loadExportAttributes(args);
   const outPath = args.out ?? args.otlp;
   if (outPath) {
@@ -342,6 +339,13 @@ async function cmdExport(args) {
   const result = await exportTraceEvidenceFile(args.input, { format, attributes });
   process.stdout.write(serializeSpans(result.spans));
 }
+function traceEvidenceFormat(raw) {
+  const format = raw ?? "auto";
+  if (format !== "auto" && format !== "policy-evidence" && format !== "sandbox-events" && format !== "openinference" && format !== "intelligence-spans") {
+    throw new Error("--format must be auto, policy-evidence, sandbox-events, openinference, or intelligence-spans");
+  }
+  return format;
+}
 function parseAttributeValue(raw) {
   if (raw === "true") return true;
   if (raw === "false") return false;
@@ -368,7 +372,7 @@ async function loadExportAttributes(args) {
   return attributes;
 }
 async function cmdAnalyze(args) {
-  const { spans, harness, sessionCount, cwds } = await collectSpans(args);
+  const { spans, harness, sessionCount, cwds } = args.input ? await collectImportedSpans(args) : await collectSpans(args);
   if (spans.length === 0) throw new Error("no spans found for the given selection");
   const ai = args.llm ? await buildAxService() : void 0;
   const { otlpPath, result } = await analyzeSpans(spans, {
@@ -405,6 +409,21 @@ ${r.ok ? r.output || "(no output)" : `failed: ${r.error}`}`;
     console.log(report);
   }
 }
+async function collectImportedSpans(args) {
+  if (!args.input) throw new Error("analyze input missing");
+  const attributes = await loadExportAttributes(args);
+  const result = await exportTraceEvidenceFile(args.input, {
+    format: traceEvidenceFormat(args.format),
+    attributes
+  });
+  const traceIds = new Set(result.spans.map((s) => s.trace_id).filter(Boolean));
+  return {
+    spans: result.spans,
+    harness: result.format,
+    sessionCount: traceIds.size || 1,
+    cwds: []
+  };
+}
 function externalAnalyzersFromArgs(args) {
   return args.analyzers.map(
     (spec) => spec === "halo" ? haloAnalyzer({ defaultPrompt: args.analyzerPrompt, model: args.model }) : commandAnalyzer({ name: spec, command: spec, args: (p, prompt) => prompt ? [p, prompt] : [p] })
@@ -560,12 +579,14 @@ Input formats:
   policy-evidence  Compact JSONL rows from \`traces evidence --out policy-evidence.jsonl\`
   sandbox-events   Sandbox/OpenCode event arrays with start/raw/result/done/error events
   openinference    Existing OpenInference JSONL; rewrites through traces redaction
+  intelligence-spans  JSONL rows exported from Tangle Intelligence trace spans
   auto             Detect the format from the file contents (default)
 
 Examples:
   traces evidence --all --since 24h --out policy-evidence.jsonl
   traces export policy-evidence.jsonl --out spans.openinference.jsonl
   traces export sandbox-events.json --format sandbox-events --out spans.openinference.jsonl
+  traces export intelligence-spans.jsonl --out spans.openinference.jsonl
   traces export sandbox-events.json --attr task.id=aec-001 --attr outcome.score=1 --out spans.openinference.jsonl
   halo spans.openinference.jsonl --prompt "Analyze this trace slice" --max-turns 1
 
@@ -578,7 +599,7 @@ function usage() {
 
 Commands:
   list      List discovered sessions
-  analyze   Run analyst suite + loop/waste pipelines, write a markdown report
+  analyze   Run analyst suite + loop/waste pipelines over sessions or an input file
   investigate Run typed investigation flow, including BYO config + recommendations
   improve   Write a full improvement artifact directory for review/apply/rerun
   convert   Emit OTLP-JSONL only (HALO: use analyze --analyzer halo)
@@ -599,9 +620,9 @@ Options:
   --out <path>     Write report to a file
   --dir <path>     improve: write artifacts to this directory
   --otlp <path>    OTLP artifact path (also evidence provenance / dry-run upload preview)
-  --format <kind>  export: auto | policy-evidence | sandbox-events | openinference
-  --metadata <json> export: attach JSON object fields as span attributes
-  --attr <k=v>     export: attach one span attribute (repeatable)
+  --format <kind>  analyze/export file: auto | policy-evidence | sandbox-events | openinference | intelligence-spans
+  --metadata <json> analyze/export file: attach JSON object fields as span attributes
+  --attr <k=v>     analyze/export file: attach one span attribute (repeatable)
   --llm            Enable agentic RLM analysts (needs OPENAI_API_KEY / OPENAI_BASE_URL)
   --model <id>     --llm model id (e.g. a router model like glm-5.2); default is agent-eval's
   --config <path>  investigate/improve: JS config with analysts, external analyzers, or proposal adapter

package/dist/index.d.ts

@@ -998,7 +998,7 @@ declare function readSessionIndexFile(path: string): Promise<TraceSessionIndex>;
 declare function writeInspectionReportFile(report: TraceInspectionReport, outPath?: string): Promise<string>;
 
 type JsonObject = Record<string, unknown>;
-type TraceEvidenceInputFormat = 'policy-evidence' | 'sandbox-events' | 'openinference';
+type TraceEvidenceInputFormat = 'policy-evidence' | 'sandbox-events' | 'openinference' | 'intelligence-spans';
 type TraceEvidenceFormatOption = TraceEvidenceInputFormat | 'auto';
 interface TraceEvidenceExportOptions {
     readonly format?: TraceEvidenceFormatOption;

package/dist/index.js

@@ -89,7 +89,7 @@ import {
   writeSessionIndexFile,
   writeTraceEvidenceExportFile,
   writeTraceImprovementArtifacts
-} from "./chunk-EOQY2RIK.js";
+} from "./chunk-QM4QAG3V.js";
 
 // src/collect.ts
 async function collectSessions(opts = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tangle-network/traces",
-  "version": "0.8.16",
+  "version": "0.8.17",
   "description": "Point it at your coding-agent session traces (Claude Code, Codex, OpenCode, Gemini, Pi, …) and get failure-mode + efficiency findings. CLI + SDK over the @tangle-network/agent-eval analyst suite — observe live sessions, run your own analysts, redact, and upload to the Tangle Intelligence Platform.",
   "type": "module",
   "license": "MIT",