agent-inspect 0.1.0

package/packages/cli/dist/index.cjs

@@ -0,0 +1,888 @@
+#!/usr/bin/env node
+'use strict';
+
+var fs = require('fs');
+var path = require('path');
+var url = require('url');
+var commander = require('commander');
+var promises = require('fs/promises');
+var os = require('os');
+var nanoid = require('nanoid');
+var async_hooks = require('async_hooks');
+var chalk = require('chalk');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var path__default = /*#__PURE__*/_interopDefault(path);
+var os__default = /*#__PURE__*/_interopDefault(os);
+var chalk__default = /*#__PURE__*/_interopDefault(chalk);
+
+var STEP_TYPES = [
+  "run",
+  "llm",
+  "tool",
+  "decision",
+  "logic",
+  "state",
+  "custom"
+];
+function isStepType(value) {
+  return typeof value === "string" && STEP_TYPES.includes(value);
+}
+var DEFAULT_TRACE_DIR_NAME = ".agent-inspect";
+var RUNS_DIR_NAME = "runs";
+var FALLBACK_TRACE_DIR = path__default.default.join(
+  os__default.default.tmpdir(),
+  "agent-inspect",
+  RUNS_DIR_NAME
+);
+var MAX_NAME_LENGTH = 100;
+function createStepId() {
+  return `step_${nanoid.nanoid(10)}`;
+}
+function formatDuration(ms) {
+  if (!Number.isFinite(ms) || ms < 0) {
+    return "0ms";
+  }
+  if (ms < 1e3) {
+    return `${Math.floor(ms)}ms`;
+  }
+  const seconds = ms / 1e3;
+  return `${(Math.round(seconds * 10) / 10).toFixed(1)}s`;
+}
+function formatTimestamp(timestamp) {
+  if (!Number.isFinite(timestamp)) {
+    return "Invalid date";
+  }
+  const d = new Date(timestamp);
+  if (Number.isNaN(d.getTime())) {
+    return "Invalid date";
+  }
+  const y = d.getFullYear();
+  const mo = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
+  const h = String(d.getHours()).padStart(2, "0");
+  const min = String(d.getMinutes()).padStart(2, "0");
+  const s = String(d.getSeconds()).padStart(2, "0");
+  return `${y}-${mo}-${day} ${h}:${min}:${s}`;
+}
+function getDefaultTraceDir() {
+  try {
+    const home = os__default.default.homedir();
+    if (typeof home !== "string" || home.trim() === "") {
+      return FALLBACK_TRACE_DIR;
+    }
+    return path__default.default.join(home, DEFAULT_TRACE_DIR_NAME, RUNS_DIR_NAME);
+  } catch {
+    return FALLBACK_TRACE_DIR;
+  }
+}
+function getTraceFilePath(runId, traceDir) {
+  const baseDir = traceDir ?? getDefaultTraceDir();
+  let safeId = typeof runId === "string" && runId.trim() !== "" ? runId.trim() : "run_unknown";
+  safeId = path__default.default.basename(safeId);
+  if (safeId === "" || safeId === "." || safeId === "..") {
+    safeId = "run_unknown";
+  }
+  return path__default.default.join(baseDir, `${safeId}.jsonl`);
+}
+async function ensureTraceDir(traceDir) {
+  const primary = path__default.default.resolve(traceDir);
+  try {
+    await promises.mkdir(primary, { recursive: true });
+    return primary;
+  } catch {
+    warn(`Failed to create trace directory: ${primary}`);
+    const fallback = path__default.default.resolve(FALLBACK_TRACE_DIR);
+    try {
+      await promises.mkdir(fallback, { recursive: true });
+      return fallback;
+    } catch {
+      warn(`Failed to create fallback trace directory: ${fallback}`);
+      return primary;
+    }
+  }
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    const out = { message: error.message };
+    if (typeof error.stack === "string" && error.stack.length > 0) {
+      out.stack = error.stack;
+    }
+    return out;
+  }
+  if (typeof error === "string") {
+    return { message: error };
+  }
+  if (error === null) {
+    return { message: "Unknown error: null" };
+  }
+  if (error === void 0) {
+    return { message: "Unknown error: undefined" };
+  }
+  if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") {
+    return { message: String(error) };
+  }
+  if (typeof error === "object") {
+    try {
+      return { message: JSON.stringify(error) };
+    } catch {
+      return { message: "Unknown error" };
+    }
+  }
+  return { message: "Unknown error" };
+}
+function truncateName(name, maxLength = MAX_NAME_LENGTH) {
+  if (typeof name !== "string" || name.trim() === "") {
+    return "unnamed";
+  }
+  const trimmed = name.trim();
+  if (trimmed.length <= maxLength) {
+    return trimmed;
+  }
+  const ellipsis = "...";
+  const head = Math.max(0, maxLength - ellipsis.length);
+  return `${trimmed.slice(0, head)}${ellipsis}`;
+}
+function warn(message, error) {
+  const base = `[AgentInspect] ${message}`;
+  if (error === void 0) {
+    console.warn(base);
+    return;
+  }
+  console.warn(`${base}: ${formatError(error).message}`);
+}
+var storage = new async_hooks.AsyncLocalStorage();
+function toPublicContext(ctx) {
+  return {
+    runId: ctx.runId,
+    runName: ctx.runName,
+    traceDir: ctx.traceDir,
+    silent: ctx.silent,
+    metadata: ctx.metadata
+  };
+}
+function invoke(fn) {
+  return new Promise((resolve, reject) => {
+    try {
+      Promise.resolve(fn()).then(resolve, reject);
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+function getCurrentContext() {
+  try {
+    const s = storage.getStore();
+    if (!s) return void 0;
+    return toPublicContext(s);
+  } catch {
+    return void 0;
+  }
+}
+function getCurrentStepId() {
+  try {
+    return storage.getStore()?.currentStepId;
+  } catch {
+    return void 0;
+  }
+}
+function getParentStepId() {
+  return getCurrentStepId();
+}
+function getCurrentDepth() {
+  try {
+    const d = storage.getStore()?.currentDepth;
+    return typeof d === "number" && Number.isFinite(d) ? d : 0;
+  } catch {
+    return 0;
+  }
+}
+function isSilentContext() {
+  try {
+    const s = storage.getStore();
+    return s ? s.silent : false;
+  } catch {
+    return false;
+  }
+}
+function runWithStepContext(stepId, fn) {
+  let parent;
+  try {
+    parent = storage.getStore();
+  } catch {
+    parent = void 0;
+  }
+  if (!parent) {
+    return invoke(fn);
+  }
+  const derived = {
+    runId: parent.runId,
+    runName: parent.runName,
+    traceDir: parent.traceDir,
+    silent: parent.silent,
+    metadata: parent.metadata,
+    currentStepId: stepId,
+    currentDepth: parent.currentDepth + 1
+  };
+  return new Promise((resolve, reject) => {
+    storage.run(derived, () => {
+      try {
+        Promise.resolve(fn()).then(resolve, reject);
+      } catch (e) {
+        reject(e);
+      }
+    });
+  });
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function finiteNumber(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function optionalErrorInfo(value) {
+  if (value === void 0) return true;
+  if (!isRecord2(value)) return false;
+  if (typeof value.message !== "string") return false;
+  if ("stack" in value && value.stack !== void 0) {
+    if (typeof value.stack !== "string") return false;
+  }
+  return true;
+}
+function validateEvent(event) {
+  if (!isRecord2(event)) return false;
+  if (event.schemaVersion !== "0.1") return false;
+  if (!finiteNumber(event.timestamp)) return false;
+  if (typeof event.event !== "string") return false;
+  switch (event.event) {
+    case "run_started": {
+      if (!nonEmptyString(event.runId) || !nonEmptyString(event.name) || !finiteNumber(event.startTime)) {
+        return false;
+      }
+      if (event.metadata !== void 0 && !isRecord2(event.metadata)) {
+        return false;
+      }
+      return true;
+    }
+    case "run_completed": {
+      return nonEmptyString(event.runId) && (event.status === "success" || event.status === "error") && finiteNumber(event.endTime) && finiteNumber(event.durationMs) && optionalErrorInfo(event.error);
+    }
+    case "step_started": {
+      if (!nonEmptyString(event.runId) || !nonEmptyString(event.stepId) || !nonEmptyString(event.name) || !isStepType(event.type) || !finiteNumber(event.startTime)) {
+        return false;
+      }
+      if (event.parentId !== void 0 && typeof event.parentId !== "string") {
+        return false;
+      }
+      if (event.metadata !== void 0 && !isRecord2(event.metadata)) {
+        return false;
+      }
+      return true;
+    }
+    case "step_completed": {
+      return nonEmptyString(event.runId) && nonEmptyString(event.stepId) && (event.status === "success" || event.status === "error") && finiteNumber(event.endTime) && finiteNumber(event.durationMs) && optionalErrorInfo(event.error);
+    }
+    default:
+      return false;
+  }
+}
+function serializeEvent(event) {
+  try {
+    return JSON.stringify(event);
+  } catch {
+    return "";
+  }
+}
+async function writeTraceEvent(event, traceDir) {
+  if (!validateEvent(event)) {
+    warn("Skipped invalid trace event (validation failed)");
+    return;
+  }
+  const line = serializeEvent(event);
+  if (line === "") {
+    warn("Skipped trace event (serialization failed)");
+    return;
+  }
+  const payload = `${line}
+`;
+  const tryAppend = async (dir) => {
+    try {
+      const usable = await ensureTraceDir(dir);
+      const filePath = getTraceFilePath(event.runId, usable);
+      await promises.appendFile(filePath, payload, "utf-8");
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  if (await tryAppend(traceDir)) {
+    return;
+  }
+  warn(`Failed to append trace event for run ${event.runId}`);
+  if (await tryAppend(FALLBACK_TRACE_DIR)) {
+    return;
+  }
+  warn("Failed to append trace event to fallback directory");
+}
+async function readTraceFile(runId, traceDir) {
+  try {
+    const filePath = getTraceFilePath(runId, traceDir);
+    return await promises.readFile(filePath, "utf-8");
+  } catch (e) {
+    if (e && typeof e === "object" && "code" in e && e.code === "ENOENT") {
+      return void 0;
+    }
+    warn("Unexpected error reading trace file", e);
+    return void 0;
+  }
+}
+async function readTraceEvents(runId, traceDir) {
+  const out = [];
+  try {
+    const raw = await readTraceFile(runId, traceDir);
+    if (raw === void 0) {
+      return out;
+    }
+    const lines = raw.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (trimmed === "") continue;
+      let parsed;
+      try {
+        parsed = JSON.parse(trimmed);
+      } catch {
+        warn("Skipped invalid JSON line in trace file");
+        continue;
+      }
+      if (validateEvent(parsed)) {
+        out.push(parsed);
+      } else {
+        warn("Skipped invalid trace event line in trace file");
+      }
+    }
+  } catch (e) {
+    warn("Failed to read trace events", e);
+  }
+  return out;
+}
+async function listTraceFiles(traceDir) {
+  try {
+    const usable = path__default.default.resolve(traceDir);
+    const names = await promises.readdir(usable);
+    const jsonl = names.filter((n) => n.endsWith(".jsonl"));
+    const withStat = await Promise.all(
+      jsonl.map(async (name) => {
+        try {
+          const st = await promises.stat(path__default.default.join(usable, name));
+          return { name, mtime: st.mtimeMs };
+        } catch {
+          return { name, mtime: 0 };
+        }
+      })
+    );
+    withStat.sort((a, b) => {
+      if (b.mtime !== a.mtime) return b.mtime - a.mtime;
+      return a.name.localeCompare(b.name);
+    });
+    return withStat.map((x) => x.name);
+  } catch {
+    return [];
+  }
+}
+function getRunIdFromTraceFileName(fileName) {
+  try {
+    const base = path__default.default.basename(fileName);
+    if (!base.endsWith(".jsonl")) return void 0;
+    const id = base.slice(0, -".jsonl".length);
+    return id === "" ? void 0 : id;
+  } catch {
+    return void 0;
+  }
+}
+var TERMINAL_INDENT = "  ";
+var MAX_TERMINAL_NAME_LENGTH = 80;
+var MAX_TERMINAL_DEPTH = 10;
+function normalizeDepth(depth) {
+  if (!Number.isFinite(depth) || depth < 0) {
+    return 0;
+  }
+  return Math.min(Math.floor(depth), MAX_TERMINAL_DEPTH);
+}
+function safePrint(line = "") {
+  try {
+    console.log(line);
+  } catch {
+  }
+}
+function getIndent(depth) {
+  return TERMINAL_INDENT.repeat(normalizeDepth(depth));
+}
+function formatTerminalName(name) {
+  if (typeof name !== "string" || name.trim() === "") {
+    return "unnamed";
+  }
+  return truncateName(name, MAX_TERMINAL_NAME_LENGTH);
+}
+function getStatusIcon(status) {
+  if (status === "success") return chalk__default.default.green("\u2714");
+  if (status === "error") return chalk__default.default.red("\u2716");
+  return chalk__default.default.yellow("\u23F3");
+}
+function renderStepLine(name, durationMs, status, depth) {
+  try {
+    const nm = formatTerminalName(name);
+    const ind = getIndent(depth ?? 0);
+    if (status === "running" && durationMs === void 0) {
+      return `${ind}${chalk__default.default.yellow("\u23F3")} ${nm}`;
+    }
+    const hasDur = durationMs !== void 0 && Number.isFinite(durationMs);
+    const dur = hasDur ? formatDuration(durationMs) : void 0;
+    if (status === "running") {
+      return dur !== void 0 ? `${ind}${chalk__default.default.yellow("\u23F3")} ${nm} (${dur})` : `${ind}${chalk__default.default.yellow("\u23F3")} ${nm}`;
+    }
+    if (!hasDur || dur === void 0) {
+      return `${ind}${chalk__default.default.yellow("\u23F3")} ${nm}`;
+    }
+    if (status === "success") {
+      return `${ind}${getStatusIcon("success")} ${nm} (${dur})`;
+    }
+    return `${ind}${getStatusIcon("error")} ${nm} (${dur})`;
+  } catch {
+    return "";
+  }
+}
+function renderErrorLine(error, depth) {
+  try {
+    const msg = typeof error.message === "string" ? error.message : "";
+    const ind = getIndent((depth ?? 0) + 1);
+    return `${ind}Error: ${msg}`;
+  } catch {
+    return "";
+  }
+}
+function printStepStart(name, depth = 0) {
+  if (isSilentContext()) return;
+  try {
+    safePrint(renderStepLine(name, void 0, "running", depth));
+  } catch {
+  }
+}
+function printStepComplete(name, durationMs, status, depth = 0) {
+  if (isSilentContext()) return;
+  try {
+    safePrint(renderStepLine(name, durationMs, status, depth));
+  } catch {
+  }
+}
+function printError(error, depth = 0) {
+  if (isSilentContext()) return;
+  try {
+    safePrint(renderErrorLine(error, depth));
+  } catch {
+  }
+}
+function printFailedAt(stepName) {
+  if (isSilentContext()) return;
+  try {
+    safePrint(`Failed at: ${formatTerminalName(stepName)}`);
+  } catch {
+  }
+}
+function normalizeStepName(name) {
+  if (typeof name !== "string" || name.trim() === "") {
+    return "unnamed-step";
+  }
+  return truncateName(name.trim(), 100);
+}
+async function safeInstrumentation2(label, op) {
+  try {
+    await Promise.resolve(op());
+  } catch (e) {
+    warn(`step: ${label}`, e);
+  }
+}
+async function stepImpl(name, fn, options) {
+  if (typeof fn !== "function") {
+    throw new TypeError("step requires `fn` to be a function");
+  }
+  const stepName = normalizeStepName(name);
+  const context = getCurrentContext();
+  if (!context) {
+    warn("step() called outside inspectRun(); executing without instrumentation");
+    return Promise.resolve(fn());
+  }
+  const stepId = createStepId();
+  const renderDepth = getCurrentDepth();
+  const parentId = getParentStepId();
+  const stepType = options?.type ?? "logic";
+  const metadata = options?.metadata;
+  const startTime = Date.now();
+  await safeInstrumentation2("writeTraceEvent(step_started)", async () => {
+    const started = {
+      schemaVersion: "0.1",
+      event: "step_started",
+      timestamp: startTime,
+      runId: context.runId,
+      stepId,
+      ...typeof parentId === "string" && parentId.trim() !== "" ? { parentId } : {},
+      name: stepName,
+      type: stepType,
+      startTime,
+      ...metadata !== void 0 ? { metadata } : {}
+    };
+    await writeTraceEvent(started, context.traceDir);
+  });
+  await safeInstrumentation2("printStepStart", () => {
+    printStepStart(stepName, renderDepth);
+  });
+  let result;
+  try {
+    result = await runWithStepContext(stepId, async () => {
+      return await Promise.resolve(fn());
+    });
+  } catch (userError) {
+    const endTime2 = Date.now();
+    const durationMs2 = endTime2 - startTime;
+    const formatted = formatError(userError);
+    await safeInstrumentation2("writeTraceEvent(step_completed error)", async () => {
+      const completed = {
+        schemaVersion: "0.1",
+        event: "step_completed",
+        timestamp: endTime2,
+        runId: context.runId,
+        stepId,
+        status: "error",
+        endTime: endTime2,
+        durationMs: durationMs2,
+        error: formatted
+      };
+      await writeTraceEvent(completed, context.traceDir);
+    });
+    await safeInstrumentation2("printStepComplete(error)", () => {
+      printStepComplete(stepName, durationMs2, "error", renderDepth);
+    });
+    await safeInstrumentation2("printError", () => {
+      printError(formatted, renderDepth);
+    });
+    await safeInstrumentation2("printFailedAt", () => {
+      printFailedAt(stepName);
+    });
+    throw userError;
+  }
+  const endTime = Date.now();
+  const durationMs = endTime - startTime;
+  await safeInstrumentation2("writeTraceEvent(step_completed success)", async () => {
+    const completed = {
+      schemaVersion: "0.1",
+      event: "step_completed",
+      timestamp: endTime,
+      runId: context.runId,
+      stepId,
+      status: "success",
+      endTime,
+      durationMs
+    };
+    await writeTraceEvent(completed, context.traceDir);
+  });
+  await safeInstrumentation2("printStepComplete(success)", () => {
+    printStepComplete(stepName, durationMs, "success", renderDepth);
+  });
+  return result;
+}
+async function stepLlm(model, fn) {
+  const modelName = typeof model === "string" && model.trim() !== "" ? model.trim() : "unknown-model";
+  return stepImpl(`llm:${modelName}`, fn, {
+    type: "llm",
+    metadata: { model: modelName }
+  });
+}
+async function stepTool(toolName, fn) {
+  const normalized = typeof toolName === "string" && toolName.trim() !== "" ? toolName.trim() : "unknown-tool";
+  return stepImpl(`tool:${normalized}`, fn, {
+    type: "tool",
+    metadata: { toolName: normalized }
+  });
+}
+Object.assign(stepImpl, {
+  llm: stepLlm,
+  tool: stepTool
+});
+
+// packages/cli/src/list.ts
+function parseLimit(raw) {
+  const fallback = 20;
+  if (raw === void 0 || raw.trim() === "") return fallback;
+  const n = Number.parseInt(raw, 10);
+  if (!Number.isFinite(n) || n <= 0) return fallback;
+  return Math.min(n, 100);
+}
+function isStatusFilter(value) {
+  return value === "running" || value === "success" || value === "error";
+}
+function buildRunSummary(runId, events) {
+  const started = events.find(
+    (e) => e.event === "run_started"
+  );
+  if (!started) return void 0;
+  const completed = events.filter(
+    (e) => e.event === "run_completed"
+  );
+  const last = completed[completed.length - 1];
+  const status = last ? last.status : "running";
+  const startTime = Number.isFinite(started.startTime) ? started.startTime : Number.isFinite(started.timestamp) ? started.timestamp : 0;
+  const name = typeof started.name === "string" && started.name.trim() !== "" ? started.name.trim() : "unknown-run";
+  return {
+    runId,
+    name,
+    status,
+    durationMs: last !== void 0 ? last.durationMs : void 0,
+    startTime
+  };
+}
+function statusIcon(status) {
+  if (status === "success") return "\u2713";
+  if (status === "error") return "\u2717";
+  return "\u23F3";
+}
+function durationCell(status, durationMs) {
+  if (status === "running") return "-";
+  if (durationMs !== void 0 && Number.isFinite(durationMs)) {
+    return formatDuration(durationMs);
+  }
+  return "-";
+}
+function timestampCell(startTime) {
+  if (!Number.isFinite(startTime) || startTime <= 0) return "Invalid date";
+  const s = formatTimestamp(startTime);
+  return s === "Invalid date" ? "Invalid date" : s;
+}
+async function list(options = {}) {
+  try {
+    const traceDir = typeof options.dir === "string" && options.dir.trim() !== "" ? options.dir.trim() : getDefaultTraceDir();
+    const files = await listTraceFiles(traceDir);
+    if (files.length === 0) {
+      console.log("No AgentInspect runs found");
+      console.log(`Trace directory: ${traceDir}`);
+      return;
+    }
+    const summaries = [];
+    for (const fileName of files) {
+      try {
+        const runId = getRunIdFromTraceFileName(fileName);
+        if (runId === void 0) continue;
+        const events = await readTraceEvents(runId, traceDir);
+        const row = buildRunSummary(runId, events);
+        if (row !== void 0) summaries.push(row);
+      } catch {
+      }
+    }
+    if (summaries.length === 0) {
+      console.log("No AgentInspect runs found");
+      console.log(`Trace directory: ${traceDir}`);
+      return;
+    }
+    summaries.sort((a, b) => b.startTime - a.startTime);
+    const statusFilter = isStatusFilter(options.status) ? options.status : void 0;
+    const filtered = statusFilter === void 0 ? summaries : summaries.filter((s) => s.status === statusFilter);
+    const limit = parseLimit(options.limit);
+    const shown = filtered.slice(0, limit);
+    console.log("Recent AgentInspect Runs");
+    for (const s of shown) {
+      const icon = statusIcon(s.status);
+      const dur = durationCell(s.status, s.durationMs);
+      const ts = timestampCell(s.startTime);
+      const nm = truncateName(s.name, 80);
+      console.log(`${icon} ${s.runId} | ${nm} | ${dur} | ${ts}`);
+    }
+    console.log("");
+    console.log(`Showing ${shown.length} of ${filtered.length} runs`);
+    console.log(`Trace directory: ${traceDir}`);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`[AgentInspect] list failed: ${msg}`);
+    process.exitCode = 1;
+  }
+}
+
+// packages/cli/src/view.ts
+function buildStepTree(events) {
+  const nodes = /* @__PURE__ */ new Map();
+  for (const e of events) {
+    if (e.event === "step_started") {
+      const s = e;
+      nodes.set(s.stepId, {
+        id: s.stepId,
+        parentId: s.parentId,
+        name: s.name,
+        type: s.type,
+        status: "running",
+        startedAt: s.startTime,
+        metadata: s.metadata,
+        children: []
+      });
+    }
+  }
+  for (const e of events) {
+    if (e.event !== "step_completed") continue;
+    const c = e;
+    const node = nodes.get(c.stepId);
+    if (!node) continue;
+    node.status = c.status;
+    node.durationMs = c.durationMs;
+    node.error = c.error;
+  }
+  const roots = [];
+  for (const n of nodes.values()) {
+    if (n.parentId !== void 0 && nodes.has(n.parentId)) {
+      nodes.get(n.parentId).children.push(n);
+    } else {
+      roots.push(n);
+    }
+  }
+  const sortByStarted = (a, b) => a.startedAt - b.startedAt;
+  roots.sort(sortByStarted);
+  for (const n of nodes.values()) {
+    n.children.sort(sortByStarted);
+  }
+  return roots;
+}
+function printStepTree(nodes, depth, verbose) {
+  for (const node of nodes) {
+    console.log(
+      renderStepLine(node.name, node.durationMs, node.status, depth)
+    );
+    if (node.error !== void 0) {
+      if (verbose) {
+        console.log(renderErrorLine(node.error, depth + 1));
+        if (typeof node.error.stack === "string" && node.error.stack.trim() !== "") {
+          console.log(node.error.stack);
+        }
+      } else {
+        console.log(
+          renderErrorLine({ message: node.error.message }, depth + 1)
+        );
+      }
+    }
+    if (verbose) {
+      console.log(`${getIndent(depth + 1)}type: ${node.type}`);
+      if (node.metadata !== void 0 && Object.keys(node.metadata).length > 0) {
+        try {
+          console.log(
+            `${getIndent(depth + 1)}metadata: ${JSON.stringify(node.metadata)}`
+          );
+        } catch {
+        }
+      }
+    }
+    printStepTree(node.children, depth + 1, verbose);
+  }
+}
+async function view(runId, options = {}) {
+  try {
+    const id = typeof runId === "string" && runId.trim() !== "" ? runId.trim() : "";
+    if (id === "") {
+      console.error("Run id is required");
+      process.exitCode = 1;
+      return;
+    }
+    const traceDir = typeof options.dir === "string" && options.dir.trim() !== "" ? options.dir.trim() : getDefaultTraceDir();
+    const events = await readTraceEvents(id, traceDir);
+    if (events.length === 0) {
+      console.log(`Run not found: ${id}`);
+      console.log(`Trace directory: ${traceDir}`);
+      process.exitCode = 1;
+      return;
+    }
+    if (options.json) {
+      console.log(JSON.stringify(events, null, 2));
+      return;
+    }
+    const started = events.find(
+      (e) => e.event === "run_started"
+    );
+    if (!started) {
+      console.error("Invalid trace: missing run_started");
+      process.exitCode = 1;
+      return;
+    }
+    const completed = events.filter(
+      (e) => e.event === "run_completed"
+    );
+    const last = completed[completed.length - 1];
+    const status = last ? last.status : "running";
+    const durationLine = last !== void 0 && Number.isFinite(last.durationMs) ? formatDuration(last.durationMs) : "-";
+    const startedTs = Number.isFinite(started.startTime) ? started.startTime : started.timestamp;
+    const startedLabel = formatTimestamp(startedTs);
+    console.log(`AgentInspect Run: ${started.name}`);
+    console.log(`ID: ${id}`);
+    console.log(`Status: ${status}`);
+    console.log(`Duration: ${durationLine}`);
+    console.log(`Started: ${startedLabel}`);
+    console.log("");
+    const tree = buildStepTree(events);
+    console.log("Execution Tree:");
+    if (tree.length === 0) {
+      console.log("No steps recorded");
+    } else {
+      printStepTree(tree, 0, options.verbose === true);
+    }
+    console.log("");
+    console.log(`Trace file: ${getTraceFilePath(id, traceDir)}`);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    console.error(`[AgentInspect] view failed: ${msg}`);
+    process.exitCode = 1;
+  }
+}
+
+// packages/cli/src/index.ts
+function runCommand(action) {
+  void action().catch((error) => {
+    const msg = error instanceof Error ? error.message : String(error);
+    console.error(`[AgentInspect] ${msg}`);
+    process.exitCode = 1;
+  });
+}
+function createCliProgram() {
+  const program = new commander.Command("agent-inspect").description("Local-first execution-tree debugger for AI agents").version("0.1.0");
+  program.command("list").description("List recent AgentInspect runs").option("--dir <path>", "trace directory").option("--limit <number>", "max runs to show (default 20, max 100)").addOption(
+    new commander.Option("--status <status>", "filter by run status").choices([
+      "running",
+      "success",
+      "error"
+    ])
+  ).action(
+    (opts) => {
+      runCommand(() => list(opts));
+    }
+  );
+  program.command("view").description("View a single run trace").argument("<run-id>", "run id (e.g. from list output)").option("--dir <path>", "trace directory").option("--verbose", "show extra detail (types, metadata, error stacks)").option("--json", "print raw trace events as JSON").action(
+    (runId, opts) => {
+      runCommand(() => view(runId, opts));
+    }
+  );
+  return program;
+}
+function isPrimaryModule() {
+  const entry = process.argv[1];
+  if (!entry) return false;
+  const selfPath = url.fileURLToPath((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.cjs', document.baseURI).href)));
+  try {
+    return fs.realpathSync(path__default.default.resolve(entry)) === fs.realpathSync(path__default.default.resolve(selfPath));
+  } catch {
+    return path__default.default.resolve(entry) === path__default.default.resolve(selfPath);
+  }
+}
+if (isPrimaryModule()) {
+  createCliProgram().parse(process.argv);
+}
+
+exports.createCliProgram = createCliProgram;
+exports.runCommand = runCommand;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map