@sentrial/sdk 0.4.4 → 0.5.0

package/dist/cli.js

@@ -0,0 +1,1108 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { spawn } from "child_process";
+import os from "os";
+import path from "path";
+import process from "process";
+import readline from "readline/promises";
+
+// src/constants.ts
+var DEFAULT_API_URL = "https://api.sentrial.com";
+
+// package.json
+var version = "0.5.0";
+
+// src/cli.ts
+var CONFIG_DIR = path.join(os.homedir(), ".sentrial");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+var TIME_RANGES = /* @__PURE__ */ new Set(["24h", "3d", "7d", "30d"]);
+var CliError = class extends Error {
+  exitCode;
+  constructor(message, exitCode = 1) {
+    super(message);
+    this.name = "CliError";
+    this.exitCode = exitCode;
+  }
+};
+var SHORT_FLAGS = {
+  a: "agent",
+  f: "force",
+  h: "help",
+  j: "json",
+  l: "last",
+  s: "status",
+  t: "type",
+  v: "version",
+  y: "yes"
+};
+var BOOLEAN_FLAGS = /* @__PURE__ */ new Set([
+  "force",
+  "help",
+  "include-api-key",
+  "json",
+  "dry-run",
+  "version",
+  "yes"
+]);
+var HELP = `Sentrial CLI
+
+Usage:
+  sentrial <command> [options]
+
+Commands:
+  install                      Install the SDK package and scaffold integration files
+  init                         Scaffold a safe example integration in this repo
+  login                        Save an API key for future CLI calls
+  sessions list                List recent sessions
+  sessions get <id>            Show a session and its events
+  events list <session-id>      List events for a session
+  signals list                 List detected signals
+  diagnose <session-id>        Print a terminal diagnosis from session events
+  evaluate <experiment-id>     Run the /api/v1/evaluate CI gate (API key needs the metrics:read scope)
+  fix <session-id>             Reserved for the upcoming Fixer API
+  replay <session-id>          Reserved for the upcoming replay API
+
+Global options:
+  --api-key <key>              API key, otherwise SENTRIAL_API_KEY or ~/.sentrial/config.json
+  --api-url <url>              API URL, otherwise SENTRIAL_API_URL or ${DEFAULT_API_URL}
+  --json                       Emit machine-readable JSON
+  --no-color                   Disable ANSI color
+  -h, --help                   Show help
+  -v, --version                Show version
+
+Examples:
+  sentrial login --api-key sentrial_live_xxx
+  sentrial install
+  sentrial init
+  sentrial sessions list --last 7d --status failed --agent support
+  sentrial sessions get 00000000-0000-0000-0000-000000000000
+  sentrial events list 00000000-0000-0000-0000-000000000000 --type tool_call
+  sentrial signals list --type negative --last 30d
+  sentrial diagnose 00000000-0000-0000-0000-000000000000
+  sentrial evaluate 00000000-0000-0000-0000-000000000000 --min-score 80
+`;
+function parseArgs(argv) {
+  const flags = {};
+  const positionals = [];
+  for (let i = 0; i < argv.length; i++) {
+    const token = argv[i];
+    if (token === "--") {
+      positionals.push(...argv.slice(i + 1));
+      break;
+    }
+    if (token.startsWith("--no-")) {
+      flags[token.slice(5)] = false;
+      continue;
+    }
+    if (token.startsWith("--")) {
+      const [rawName, inlineValue] = token.slice(2).split("=", 2);
+      if (inlineValue !== void 0) {
+        flags[rawName] = inlineValue;
+      } else if (BOOLEAN_FLAGS.has(rawName)) {
+        flags[rawName] = true;
+      } else {
+        const next = argv[i + 1];
+        if (next && !next.startsWith("-")) {
+          flags[rawName] = next;
+          i++;
+        } else {
+          flags[rawName] = true;
+        }
+      }
+      continue;
+    }
+    if (token.startsWith("-") && token.length === 2) {
+      const mapped = SHORT_FLAGS[token.slice(1)];
+      if (!mapped) {
+        throw new CliError(`Unknown flag: ${token}`);
+      }
+      if (BOOLEAN_FLAGS.has(mapped)) {
+        flags[mapped] = true;
+      } else {
+        const next = argv[i + 1];
+        if (!next || next.startsWith("-")) {
+          throw new CliError(`Flag ${token} requires a value`);
+        }
+        flags[mapped] = next;
+        i++;
+      }
+      continue;
+    }
+    positionals.push(token);
+  }
+  return { flags, positionals };
+}
+function getFlag(flags, ...names) {
+  for (const name of names) {
+    if (flags[name] !== void 0) return flags[name];
+  }
+  return void 0;
+}
+function getStringFlag(flags, ...names) {
+  const value = getFlag(flags, ...names);
+  if (typeof value === "string") return value;
+  return void 0;
+}
+function getBooleanFlag(flags, name) {
+  return flags[name] === true;
+}
+function readConfig() {
+  if (!existsSync(CONFIG_FILE)) return {};
+  try {
+    const parsed = JSON.parse(readFileSync(CONFIG_FILE, "utf8"));
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function writeConfig(config) {
+  mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  writeFileSync(CONFIG_FILE, `${JSON.stringify(config, null, 2)}
+`, { mode: 384 });
+  try {
+    chmodSync(CONFIG_FILE, 384);
+  } catch {
+  }
+}
+function createContext(flags) {
+  const config = readConfig();
+  const apiKey = getStringFlag(flags, "api-key") ?? process.env.SENTRIAL_API_KEY ?? config.apiKey;
+  const apiUrl = (getStringFlag(flags, "api-url") ?? process.env.SENTRIAL_API_URL ?? config.apiUrl ?? DEFAULT_API_URL).replace(/\/$/, "");
+  return {
+    apiKey,
+    apiUrl,
+    json: getBooleanFlag(flags, "json"),
+    color: flags.color !== false && process.stdout.isTTY && !process.env.NO_COLOR
+  };
+}
+function requireApiKey(ctx) {
+  if (!ctx.apiKey) {
+    throw new CliError(
+      "Missing API key. Run `sentrial login --api-key sentrial_live_xxx` or set SENTRIAL_API_KEY."
+    );
+  }
+  return ctx.apiKey;
+}
+async function apiRequest(ctx, apiPath, options = {}) {
+  const apiKey = requireApiKey(ctx);
+  const url = new URL(apiPath, `${ctx.apiUrl}/`);
+  for (const [key, value] of Object.entries(options.query ?? {})) {
+    if (value !== void 0) {
+      url.searchParams.set(key, String(value));
+    }
+  }
+  const headers = {
+    Authorization: `Bearer ${apiKey}`,
+    Accept: "application/json"
+  };
+  if (options.body !== void 0) {
+    headers["Content-Type"] = "application/json";
+  }
+  let response;
+  try {
+    response = await fetch(url, {
+      method: options.method ?? "GET",
+      headers,
+      body: options.body === void 0 ? void 0 : JSON.stringify(options.body)
+    });
+  } catch (error) {
+    throw new CliError(
+      `Could not reach ${ctx.apiUrl}. ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  const text = await response.text();
+  const parsed = parseResponseBody(text);
+  if (!response.ok) {
+    throw new CliError(
+      `${options.method ?? "GET"} ${url.pathname} failed (${response.status}): ${formatApiError(
+        parsed
+      )}`,
+      response.status === 404 ? 4 : 1
+    );
+  }
+  return parsed;
+}
+function parseResponseBody(text) {
+  if (!text.trim()) return {};
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+function formatApiError(value) {
+  if (value && typeof value === "object") {
+    const record = value;
+    if (typeof record.error === "string") return record.error;
+    if (record.error && typeof record.error === "object") {
+      const error = record.error;
+      if (typeof error.message === "string") return error.message;
+    }
+  }
+  return typeof value === "string" ? value : "Unexpected API response";
+}
+async function commandLogin(ctx, flags) {
+  let apiKey = getStringFlag(flags, "api-key") ?? process.env.SENTRIAL_API_KEY;
+  const apiUrl = getStringFlag(flags, "api-url") ?? process.env.SENTRIAL_API_URL ?? ctx.apiUrl;
+  if (!apiKey) {
+    if (!process.stdin.isTTY) {
+      throw new CliError("Pass --api-key or set SENTRIAL_API_KEY when stdin is not interactive.");
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    apiKey = (await rl.question("Sentrial API key: ")).trim();
+    rl.close();
+  }
+  if (!apiKey.startsWith("sentrial_")) {
+    throw new CliError("API keys should look like sentrial_live_xxx or sentrial_test_xxx.");
+  }
+  writeConfig({ apiKey, apiUrl });
+  if (ctx.json) {
+    printJson({ ok: true, configPath: CONFIG_FILE, apiUrl });
+    return;
+  }
+  process.stdout.write(`Saved credentials to ${CONFIG_FILE}
+`);
+}
+async function commandInstall(ctx, flags) {
+  const projectRoot = process.cwd();
+  const requestedLanguage = getStringFlag(flags, "language");
+  const pythonCommand = getStringFlag(flags, "python");
+  const packageOverride = getStringFlag(flags, "sdk-package") ?? process.env.SENTRIAL_SDK_PACKAGE;
+  const plan = buildInstallPlan(projectRoot, requestedLanguage, pythonCommand, packageOverride);
+  const dryRun = getBooleanFlag(flags, "dry-run");
+  if (ctx.json) {
+    if (!dryRun) {
+      throw new CliError("Use --dry-run with --json; real installs stream package-manager output.");
+    }
+    printJson({ dryRun: true, plan, wouldWrite: plannedScaffoldFiles(projectRoot, plan.language) });
+    return;
+  }
+  process.stdout.write(`Detected: ${plan.framework ?? plan.language}
+`);
+  process.stdout.write(`Install:  ${formatCommand(plan.command, plan.args)}
+`);
+  if (dryRun) {
+    process.stdout.write("Dry run only. No files were changed.\n");
+    return;
+  }
+  await runSubprocess(plan.command, plan.args, projectRoot);
+  await commandInit(ctx, flags);
+}
+async function commandInit(ctx, flags) {
+  const projectRoot = process.cwd();
+  const detected = detectProject(projectRoot);
+  const requestedLanguage = getStringFlag(flags, "language");
+  const language = requestedLanguage ?? detected.language ?? "typescript";
+  const force = getBooleanFlag(flags, "force");
+  const includeApiKey = getBooleanFlag(flags, "include-api-key");
+  if (language !== "typescript" && language !== "python") {
+    throw new CliError('Supported init languages are "typescript" and "python".');
+  }
+  const files = language === "python" ? [
+    {
+      path: path.join(projectRoot, "sentrial.example.py"),
+      content: pythonExample()
+    }
+  ] : [
+    {
+      path: path.join(projectRoot, "sentrial.example.ts"),
+      content: typescriptExample()
+    }
+  ];
+  files.push({
+    path: path.join(projectRoot, ".env.sentrial.example"),
+    content: `SENTRIAL_API_KEY=sentrial_live_xxx
+SENTRIAL_API_URL=${ctx.apiUrl}
+`
+  });
+  if (includeApiKey && ctx.apiKey) {
+    files.push({
+      path: path.join(projectRoot, ".env.sentrial"),
+      content: `SENTRIAL_API_KEY=${ctx.apiKey}
+SENTRIAL_API_URL=${ctx.apiUrl}
+`
+    });
+  }
+  const written = [];
+  const skipped = [];
+  for (const file of files) {
+    if (existsSync(file.path) && !force) {
+      skipped.push(file.path);
+      continue;
+    }
+    writeFileSync(file.path, file.content);
+    written.push(file.path);
+  }
+  const installCommand = language === "python" ? "pip install sentrial" : `${detectPackageManager(projectRoot)} add @sentrial/sdk`;
+  if (ctx.json) {
+    printJson({
+      detected,
+      language,
+      installCommand,
+      written,
+      skipped
+    });
+    return;
+  }
+  process.stdout.write(`Detected: ${detected.framework ?? language}
+`);
+  process.stdout.write(`Install:  ${installCommand}
+`);
+  if (written.length > 0) {
+    process.stdout.write(
+      `Written:
+${written.map((file) => `  ${path.relative(projectRoot, file)}`).join("\n")}
+`
+    );
+  }
+  if (skipped.length > 0) {
+    process.stdout.write(
+      `Skipped existing files:
+${skipped.map((file) => `  ${path.relative(projectRoot, file)}`).join("\n")}
+`
+    );
+  }
+}
+async function commandSessions(ctx, flags, rest) {
+  const subcommand = rest[0];
+  if (subcommand === "list") {
+    await commandSessionsList(ctx, flags);
+    return;
+  }
+  if (subcommand === "get") {
+    const sessionId = rest[1];
+    if (!sessionId) throw new CliError("Usage: sentrial sessions get <id>");
+    await commandSessionsGet(ctx, flags, sessionId);
+    return;
+  }
+  throw new CliError("Usage: sentrial sessions <list|get>");
+}
+async function commandSessionsList(ctx, flags) {
+  const query = buildTimeQuery(flags);
+  const agentFilter = getStringFlag(flags, "agent")?.toLowerCase();
+  const hasExplicitLimit = getStringFlag(flags, "limit") !== void 0;
+  query.status = getStringFlag(flags, "status") ?? "all";
+  query.limit = parseIntegerFlag(flags, "limit", agentFilter && !hasExplicitLimit ? 500 : 50);
+  query.offset = parseIntegerFlag(flags, "offset", 0);
+  const response = await apiRequest(ctx, "/api/v1/sessions", {
+    query
+  });
+  const sessions = agentFilter ? response.data.filter(
+    (session) => `${session.agentName ?? ""} ${session.agentSlug ?? ""}`.toLowerCase().includes(agentFilter)
+  ) : response.data;
+  if (ctx.json) {
+    printJson({ data: sessions, meta: response.meta });
+    return;
+  }
+  if (sessions.length === 0) {
+    process.stdout.write("No sessions found.\n");
+    return;
+  }
+  printTable(sessions, [
+    { header: "ID", render: (s) => s.id, maxWidth: 36 },
+    { header: "Agent", render: (s) => s.agentName ?? s.agentSlug ?? "-", maxWidth: 18 },
+    { header: "Status", render: (s) => s.status ?? "-", maxWidth: 10 },
+    { header: "Result", render: (s) => formatResult(s.success), maxWidth: 8 },
+    { header: "Score", render: (s) => formatNullableNumber(s.score), maxWidth: 6 },
+    { header: "Dur", render: (s) => formatDuration(s.durationMs), maxWidth: 8 },
+    { header: "Cost", render: (s) => formatCost(s.estimatedCost), maxWidth: 10 },
+    { header: "Created", render: (s) => formatDate(s.createdAt), maxWidth: 16 },
+    { header: "Name", render: (s) => s.name ?? "-", maxWidth: 28 }
+  ]);
+  if (agentFilter) {
+    process.stdout.write(`
+Filtered locally by agent: ${agentFilter}
+`);
+  }
+}
+async function commandSessionsGet(ctx, flags, sessionId) {
+  const sessionResponse = await apiRequest(
+    ctx,
+    `/api/v1/sessions/${sessionId}`
+  );
+  const includeEvents = flags.events !== false;
+  const events = includeEvents ? await fetchSessionEvents(ctx, flags, sessionId) : [];
+  if (ctx.json) {
+    printJson({ data: sessionResponse.data, events });
+    return;
+  }
+  printSession(sessionResponse.data, events, ctx);
+}
+async function fetchSessionEvents(ctx, flags, sessionId) {
+  const eventType = getStringFlag(flags, "event-type") ?? "all";
+  const response = await apiRequest(
+    ctx,
+    `/api/v1/sessions/${sessionId}/events`,
+    {
+      query: {
+        limit: parseIntegerFlag(flags, "events-limit", 100),
+        offset: parseIntegerFlag(flags, "events-offset", 0),
+        eventType
+      }
+    }
+  );
+  return response.data;
+}
+async function commandEvents(ctx, flags, rest) {
+  const subcommand = rest[0] ?? "list";
+  if (subcommand !== "list") {
+    throw new CliError("Usage: sentrial events list <session-id>");
+  }
+  const sessionId = rest[1] ?? getStringFlag(flags, "session", "session-id");
+  if (!sessionId) {
+    throw new CliError("Usage: sentrial events list <session-id>");
+  }
+  const eventType = getStringFlag(flags, "type", "event-type") ?? "all";
+  const response = await apiRequest(
+    ctx,
+    `/api/v1/sessions/${sessionId}/events`,
+    {
+      query: {
+        limit: parseIntegerFlag(flags, "limit", 100),
+        offset: parseIntegerFlag(flags, "offset", 0),
+        eventType
+      }
+    }
+  );
+  if (ctx.json) {
+    printJson(response);
+    return;
+  }
+  if (response.data.length === 0) {
+    process.stdout.write("No events found.\n");
+    return;
+  }
+  process.stdout.write(`${bold(ctx, "Events")} ${sessionId}
+`);
+  for (const event of response.data) {
+    printEvent(event, ctx);
+  }
+}
+async function commandSignals(ctx, flags, rest) {
+  const subcommand = rest[0] ?? "list";
+  if (subcommand !== "list") {
+    throw new CliError("Usage: sentrial signals list");
+  }
+  const query = buildTimeQuery(flags);
+  query.type = getStringFlag(flags, "type") ?? "all";
+  query.source = getStringFlag(flags, "source") ?? "all";
+  const response = await apiRequest(ctx, "/api/v1/signals", {
+    query
+  });
+  if (ctx.json) {
+    printJson(response);
+    return;
+  }
+  if (response.data.length === 0) {
+    process.stdout.write("No signals found.\n");
+    return;
+  }
+  printTable(response.data, [
+    { header: "Name", render: (s) => s.name, maxWidth: 28 },
+    { header: "Type", render: (s) => s.type, maxWidth: 10 },
+    { header: "Source", render: (s) => s.source ?? "-", maxWidth: 12 },
+    { header: "Count", render: (s) => String(s.count), maxWidth: 8 },
+    { header: "Sessions", render: (s) => String(s.affectedSessions), maxWidth: 10 },
+    { header: "Users", render: (s) => String(s.affectedUsers), maxWidth: 8 },
+    { header: "Created", render: (s) => formatDate(s.createdAt), maxWidth: 16 },
+    { header: "Description", render: (s) => s.description ?? "-", maxWidth: 36 }
+  ]);
+}
+async function commandDiagnose(ctx, flags, sessionId) {
+  if (!sessionId) throw new CliError("Usage: sentrial diagnose <session-id>");
+  const sessionResponse = await apiRequest(
+    ctx,
+    `/api/v1/sessions/${sessionId}`
+  );
+  const events = await fetchSessionEvents(ctx, flags, sessionId);
+  const findings = diagnoseSession(sessionResponse.data, events);
+  if (ctx.json) {
+    printJson({ session: sessionResponse.data, findings });
+    return;
+  }
+  process.stdout.write(`${bold(ctx, "Diagnosis")}
+`);
+  process.stdout.write(`Session: ${sessionResponse.data.id}
+`);
+  process.stdout.write(
+    `Agent:   ${sessionResponse.data.agentName ?? sessionResponse.data.agentSlug ?? "-"}
+`
+  );
+  process.stdout.write(
+    `Status:  ${sessionResponse.data.status ?? "-"} (${formatResult(sessionResponse.data.success)})
+`
+  );
+  if (sessionResponse.data.failureReason) {
+    process.stdout.write(`Failure: ${sessionResponse.data.failureReason}
+`);
+  }
+  process.stdout.write("\n");
+  if (findings.length === 0) {
+    process.stdout.write("No obvious terminal-level issues found in the session events.\n");
+    return;
+  }
+  for (const finding of findings) {
+    process.stdout.write(`${severityLabel(ctx, finding.severity)} ${finding.title}
+`);
+    process.stdout.write(`  ${finding.detail}
+`);
+  }
+}
+async function commandEvaluate(ctx, flags, experimentId) {
+  const resolvedExperimentId = experimentId ?? getStringFlag(flags, "experiment", "experiment-id");
+  if (!resolvedExperimentId) {
+    throw new CliError("Usage: sentrial evaluate <experiment-id> [--min-score 80]");
+  }
+  const body = {
+    experimentId: resolvedExperimentId,
+    baselineExperimentId: getStringFlag(flags, "baseline", "baseline-experiment-id"),
+    thresholds: {
+      minScore: parseOptionalNumberFlag(flags, "min-score"),
+      failOnRegression: flags["fail-on-regression"] === false ? false : void 0,
+      maxRegressionPercent: parseOptionalNumberFlag(flags, "max-regression-percent")
+    }
+  };
+  const response = await apiRequest(ctx, "/api/v1/evaluate", {
+    method: "POST",
+    body
+  });
+  if (ctx.json) {
+    printJson(response);
+  } else {
+    const passed = response.passed === true;
+    process.stdout.write(`${passed ? color(ctx, "green", "PASS") : color(ctx, "red", "FAIL")}
+`);
+    if (Array.isArray(response.failures) && response.failures.length > 0) {
+      process.stdout.write(
+        `Failures:
+${response.failures.map((f) => `  - ${String(f)}`).join("\n")}
+`
+      );
+    }
+    if (response.summary && typeof response.summary === "object") {
+      printKeyValues(response.summary);
+    }
+    if (response.regression && typeof response.regression === "object") {
+      process.stdout.write("\nRegression:\n");
+      printKeyValues(response.regression);
+    }
+  }
+  if (response.passed === false) {
+    process.exitCode = 1;
+  }
+}
+function commandReserved(command) {
+  const messages = {
+    fix: "The Fixer CLI is reserved for the upcoming scriptable Fixer API.",
+    replay: "The replay CLI is reserved for the upcoming replay API."
+  };
+  throw new CliError(messages[command] ?? `${command} is not available yet.`, 2);
+}
+function buildTimeQuery(flags) {
+  const query = {};
+  const last = getStringFlag(flags, "last", "time-range") ?? "7d";
+  const from = getStringFlag(flags, "from");
+  const to = getStringFlag(flags, "to");
+  if (from) {
+    query.from = from;
+  } else if (TIME_RANGES.has(last)) {
+    query.timeRange = last;
+  } else {
+    throw new CliError(`--last must be one of: ${Array.from(TIME_RANGES).join(", ")}`);
+  }
+  if (to) query.to = to;
+  return query;
+}
+function parseIntegerFlag(flags, name, fallback) {
+  const raw = getStringFlag(flags, name);
+  if (raw === void 0) return fallback;
+  const parsed = Number.parseInt(raw, 10);
+  if (!Number.isFinite(parsed)) throw new CliError(`--${name} must be an integer`);
+  return parsed;
+}
+function parseOptionalNumberFlag(flags, name) {
+  const raw = getStringFlag(flags, name);
+  if (raw === void 0) return void 0;
+  const parsed = Number.parseFloat(raw);
+  if (!Number.isFinite(parsed)) throw new CliError(`--${name} must be a number`);
+  return parsed;
+}
+function diagnoseSession(session, events) {
+  const findings = [];
+  const toolErrors = events.filter((event) => hasMeaningfulValue(event.toolError));
+  const explicitErrors = events.filter((event) => event.eventType === "error");
+  const lowConfidence = events.filter(
+    (event) => typeof event.confidence === "number" && event.confidence < 0.5
+  );
+  if (session.success === false || session.status === "failed") {
+    findings.push({
+      severity: "high",
+      title: "Session ended unsuccessfully",
+      detail: session.failureReason ?? "The session is marked failed without a failure reason."
+    });
+  }
+  if (toolErrors.length > 0) {
+    const grouped = groupBy(toolErrors, (event) => event.toolName ?? "unknown_tool");
+    const top = Array.from(grouped.entries()).map(([tool, group]) => `${tool} (${group.length})`).join(", ");
+    findings.push({
+      severity: "high",
+      title: "Tool errors occurred",
+      detail: `${toolErrors.length} tool error event(s): ${top}. First error: ${formatCompactJson(
+        toolErrors[0].toolError
+      )}`
+    });
+  }
+  if (explicitErrors.length > 0) {
+    findings.push({
+      severity: "high",
+      title: "Error events were recorded",
+      detail: `${explicitErrors.length} error event(s). First event: ${summarizeEvent(
+        explicitErrors[0]
+      )}`
+    });
+  }
+  const repeatedCalls = findRepeatedToolCalls(events);
+  if (repeatedCalls.length > 0) {
+    findings.push({
+      severity: "medium",
+      title: "Repeated identical tool calls",
+      detail: repeatedCalls.slice(0, 3).map((call) => `${call.toolName} repeated ${call.count} times`).join("; ")
+    });
+  }
+  if (lowConfidence.length > 0) {
+    findings.push({
+      severity: "medium",
+      title: "Low-confidence decisions",
+      detail: `${lowConfidence.length} decision event(s) had confidence below 0.5.`
+    });
+  }
+  if (session.totalTokens && session.totalTokens > 1e5) {
+    findings.push({
+      severity: "low",
+      title: "High token usage",
+      detail: `This session used ${session.totalTokens.toLocaleString()} tokens.`
+    });
+  }
+  if (session.durationMs && session.durationMs > 12e4) {
+    findings.push({
+      severity: "low",
+      title: "Long-running session",
+      detail: `Duration was ${formatDuration(session.durationMs)}.`
+    });
+  }
+  if (session.status === "completed" && !session.assistantOutput) {
+    findings.push({
+      severity: "info",
+      title: "No assistant output stored",
+      detail: "The session completed, but assistantOutput is empty. Confirm finish({ output }) is wired."
+    });
+  }
+  return findings;
+}
+function findRepeatedToolCalls(events) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    if (event.eventType !== "tool_call" || !event.toolName) continue;
+    const key = `${event.toolName}:${formatCompactJson(event.toolInput)}`;
+    const current = counts.get(key) ?? { toolName: event.toolName, count: 0 };
+    current.count++;
+    counts.set(key, current);
+  }
+  return Array.from(counts.values()).filter((entry) => entry.count >= 3);
+}
+function groupBy(items, keyFor) {
+  const result = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyFor(item);
+    const existing = result.get(key) ?? [];
+    existing.push(item);
+    result.set(key, existing);
+  }
+  return result;
+}
+function hasMeaningfulValue(value) {
+  if (value === null || value === void 0) return false;
+  if (typeof value === "string") return value.trim().length > 0;
+  if (Array.isArray(value)) return value.length > 0;
+  if (typeof value === "object") return Object.keys(value).length > 0;
+  return true;
+}
+function detectProject(projectRoot) {
+  const packageJsonPath = path.join(projectRoot, "package.json");
+  if (existsSync(packageJsonPath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+      if (deps.next) return { language: "typescript", framework: "Next.js" };
+      if (deps.ai || deps["@ai-sdk/openai"])
+        return { language: "typescript", framework: "Vercel AI SDK" };
+      if (deps.langchain || deps["@langchain/core"])
+        return { language: "typescript", framework: "LangChain" };
+      if (deps.openai) return { language: "typescript", framework: "OpenAI Node" };
+      return { language: "typescript", framework: "Node.js" };
+    } catch {
+      return { language: "typescript", framework: "Node.js" };
+    }
+  }
+  const requirementsPath = path.join(projectRoot, "requirements.txt");
+  const pyprojectPath = path.join(projectRoot, "pyproject.toml");
+  if (existsSync(requirementsPath) || existsSync(pyprojectPath)) {
+    const text = [requirementsPath, pyprojectPath].filter((file) => existsSync(file)).map((file) => readFileSync(file, "utf8").toLowerCase()).join("\n");
+    if (text.includes("fastapi")) return { language: "python", framework: "FastAPI" };
+    if (text.includes("langchain")) return { language: "python", framework: "LangChain" };
+    if (text.includes("crewai")) return { language: "python", framework: "CrewAI" };
+    if (text.includes("openai")) return { language: "python", framework: "OpenAI Python" };
+    return { language: "python", framework: "Python" };
+  }
+  return {};
+}
+function buildInstallPlan(projectRoot, languageOverride, pythonCommand, packageOverride) {
+  const detected = detectProject(projectRoot);
+  const language = languageOverride ?? detected.language ?? "typescript";
+  if (language !== "typescript" && language !== "python") {
+    throw new CliError('Supported install languages are "typescript" and "python".');
+  }
+  if (language === "python") {
+    const command = pythonCommand ?? (process.platform === "win32" ? "python" : "python3");
+    const packageName2 = packageOverride ?? "sentrial";
+    return {
+      language,
+      framework: detected.framework,
+      command,
+      args: ["-m", "pip", "install", packageName2],
+      packageName: packageName2
+    };
+  }
+  const packageManager = detectPackageManager(projectRoot);
+  const packageName = packageOverride ?? "@sentrial/sdk";
+  return {
+    language,
+    framework: detected.framework,
+    command: packageManager,
+    args: packageManager === "npm" ? ["install", packageName] : ["add", packageName],
+    packageName
+  };
+}
+function detectPackageManager(projectRoot) {
+  if (existsSync(path.join(projectRoot, "pnpm-lock.yaml"))) return "pnpm";
+  if (existsSync(path.join(projectRoot, "yarn.lock"))) return "yarn";
+  return "npm";
+}
+function plannedScaffoldFiles(projectRoot, language) {
+  const sampleFile = language === "python" ? "sentrial.example.py" : "sentrial.example.ts";
+  return [path.join(projectRoot, sampleFile), path.join(projectRoot, ".env.sentrial.example")];
+}
+function runSubprocess(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      cwd,
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("error", (error) => {
+      reject(new CliError(`Failed to run ${formatCommand(command, args)}: ${error.message}`));
+    });
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+      reject(
+        new CliError(`${formatCommand(command, args)} failed with exit code ${code ?? "unknown"}`)
+      );
+    });
+  });
+}
+function formatCommand(command, args) {
+  return [command, ...args].join(" ");
+}
+function typescriptExample() {
+  return `import { configure, withSession } from '@sentrial/sdk';
+
+configure({
+  apiKey: process.env.SENTRIAL_API_KEY,
+  apiUrl: process.env.SENTRIAL_API_URL,
+});
+
+export const runAgent = withSession('my-agent', async (userId: string, input: string) => {
+  // Replace this with your real agent call. LLM/tool wrappers can be added around it.
+  const output = \`Echo: \${input}\`;
+  return output;
+});
+
+await runAgent('user_123', 'Hello from Sentrial');
+`;
+}
+function pythonExample() {
+  return `from sentrial import SentrialClient
+
+client = SentrialClient()
+
+interaction = client.begin(
+    user_id="user_123",
+    event="my-agent",
+    input="Hello from Sentrial",
+)
+
+try:
+    # Replace this with your real agent call.
+    output = "Echo: Hello from Sentrial"
+    interaction.finish(output=output, success=True)
+except Exception as exc:
+    interaction.finish(success=False, failure_reason=str(exc))
+    raise
+`;
+}
+function printSession(session, events, ctx) {
+  process.stdout.write(`${bold(ctx, "Session")} ${session.id}
+`);
+  printKeyValues({
+    name: session.name ?? "-",
+    agent: session.agentName ?? session.agentSlug ?? "-",
+    userId: session.userId ?? "-",
+    status: `${session.status ?? "-"} (${formatResult(session.success)})`,
+    score: formatNullableNumber(session.score),
+    duration: formatDuration(session.durationMs),
+    cost: formatCost(session.estimatedCost),
+    tokens: session.totalTokens ?? "-",
+    events: session.totalEvents ?? events.length,
+    createdAt: formatDate(session.createdAt),
+    completedAt: formatDate(session.completedAt)
+  });
+  if (session.failureReason) {
+    process.stdout.write(`
+Failure reason:
+${indent(wrap(session.failureReason))}
+`);
+  }
+  if (session.userInput) {
+    process.stdout.write(`
+Input:
+${indent(wrap(session.userInput))}
+`);
+  }
+  if (session.assistantOutput) {
+    process.stdout.write(`
+Output:
+${indent(wrap(session.assistantOutput))}
+`);
+  }
+  if (events.length > 0) {
+    process.stdout.write(`
+${bold(ctx, "Events")}
+`);
+    for (const event of events) {
+      printEvent(event, ctx);
+    }
+  }
+}
+function printEvent(event, ctx) {
+  const prefix = `#${event.sequenceNumber ?? "-"} ${event.eventType}`;
+  const label = event.eventType === "error" || hasMeaningfulValue(event.toolError) ? color(ctx, "red", prefix) : color(ctx, "cyan", prefix);
+  process.stdout.write(`${label} ${formatDate(event.timestamp)}`);
+  if (event.toolName) process.stdout.write(` tool=${event.toolName}`);
+  if (event.estimatedCost) process.stdout.write(` cost=${formatCost(event.estimatedCost)}`);
+  if (event.tokenCount) process.stdout.write(` tokens=${event.tokenCount}`);
+  process.stdout.write("\n");
+  const summary = summarizeEvent(event);
+  if (summary) process.stdout.write(`${indent(wrap(summary, 88))}
+`);
+}
+function summarizeEvent(event) {
+  if (hasMeaningfulValue(event.toolError)) {
+    return `Error: ${formatCompactJson(event.toolError)}`;
+  }
+  if (event.reasoning) {
+    return event.reasoning;
+  }
+  if (hasMeaningfulValue(event.toolOutput)) {
+    return `Output: ${formatCompactJson(event.toolOutput)}`;
+  }
+  if (hasMeaningfulValue(event.toolInput)) {
+    return `Input: ${formatCompactJson(event.toolInput)}`;
+  }
+  return "";
+}
+function printKeyValues(values) {
+  const entries = Object.entries(values);
+  const width = entries.reduce((max, [key]) => Math.max(max, key.length), 0);
+  for (const [key, value] of entries) {
+    process.stdout.write(`${key.padEnd(width)}  ${String(value)}
+`);
+  }
+}
+function printJson(value) {
+  process.stdout.write(`${JSON.stringify(value, null, 2)}
+`);
+}
+function printTable(rows, columns) {
+  const widths = columns.map((column) => {
+    const max = Math.max(column.header.length, ...rows.map((row) => column.render(row).length));
+    return Math.min(max, column.maxWidth);
+  });
+  const header = columns.map((column, index) => pad(truncate(column.header, widths[index]), widths[index])).join("  ");
+  const divider = widths.map((width) => "-".repeat(width)).join("  ");
+  process.stdout.write(`${header}
+${divider}
+`);
+  for (const row of rows) {
+    const line = columns.map((column, index) => pad(truncate(column.render(row), widths[index]), widths[index])).join("  ");
+    process.stdout.write(`${line}
+`);
+  }
+}
+function truncate(value, width) {
+  if (value.length <= width) return value;
+  if (width <= 1) return value.slice(0, width);
+  return `${value.slice(0, width - 1)}...`.slice(0, width);
+}
+function pad(value, width) {
+  return `${value}${" ".repeat(Math.max(0, width - value.length))}`;
+}
+function color(ctx, name, value) {
+  if (!ctx.color) return value;
+  const codes = {
+    cyan: 36,
+    green: 32,
+    red: 31,
+    yellow: 33
+  };
+  return `\x1B[${codes[name]}m${value}\x1B[0m`;
+}
+function bold(ctx, value) {
+  return ctx.color ? `\x1B[1m${value}\x1B[0m` : value;
+}
+function severityLabel(ctx, severity) {
+  if (severity === "high") return color(ctx, "red", "[high]");
+  if (severity === "medium") return color(ctx, "yellow", "[medium]");
+  if (severity === "low") return color(ctx, "cyan", "[low]");
+  return "[info]";
+}
+function formatResult(success) {
+  if (success === true) return "pass";
+  if (success === false) return "fail";
+  return "-";
+}
+function formatNullableNumber(value) {
+  return typeof value === "number" ? String(Math.round(value * 10) / 10) : "-";
+}
+function formatDuration(ms) {
+  if (typeof ms !== "number") return "-";
+  if (ms < 1e3) return `${ms}ms`;
+  if (ms < 6e4) return `${(ms / 1e3).toFixed(1)}s`;
+  return `${(ms / 6e4).toFixed(1)}m`;
+}
+function formatCost(cost) {
+  return typeof cost === "number" ? `$${cost.toFixed(4)}` : "-";
+}
+function formatDate(value) {
+  if (!value) return "-";
+  const date = new Date(value);
+  if (Number.isNaN(date.getTime())) return value;
+  return date.toISOString().replace("T", " ").slice(0, 16);
+}
+function formatCompactJson(value) {
+  if (value === void 0) return "";
+  if (typeof value === "string") return value;
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
+function wrap(text, width = 92) {
+  const words = text.replace(/\s+/g, " ").trim().split(" ");
+  const lines = [];
+  let current = "";
+  for (const word of words) {
+    if (`${current} ${word}`.trim().length > width && current) {
+      lines.push(current);
+      current = word;
+    } else {
+      current = `${current} ${word}`.trim();
+    }
+  }
+  if (current) lines.push(current);
+  return lines.join("\n");
+}
+function indent(text, spaces = 2) {
+  const prefix = " ".repeat(spaces);
+  return text.split("\n").map((line) => `${prefix}${line}`).join("\n");
+}
+async function run(argv) {
+  const parsed = parseArgs(argv);
+  const ctx = createContext(parsed.flags);
+  const [command, ...rest] = parsed.positionals;
+  if (getBooleanFlag(parsed.flags, "version")) {
+    process.stdout.write(`${version}
+`);
+    return;
+  }
+  if (!command || getBooleanFlag(parsed.flags, "help")) {
+    process.stdout.write(HELP);
+    return;
+  }
+  switch (command) {
+    case "install":
+      await commandInstall(ctx, parsed.flags);
+      break;
+    case "init":
+      await commandInit(ctx, parsed.flags);
+      break;
+    case "login":
+      await commandLogin(ctx, parsed.flags);
+      break;
+    case "sessions":
+      await commandSessions(ctx, parsed.flags, rest);
+      break;
+    case "events":
+      await commandEvents(ctx, parsed.flags, rest);
+      break;
+    case "signals":
+      await commandSignals(ctx, parsed.flags, rest);
+      break;
+    case "diagnose":
+      await commandDiagnose(ctx, parsed.flags, rest[0]);
+      break;
+    case "evaluate":
+      await commandEvaluate(ctx, parsed.flags, rest[0]);
+      break;
+    case "fix":
+    case "replay":
+      commandReserved(command);
+      break;
+    default:
+      throw new CliError(`Unknown command: ${command}. Run sentrial --help.`);
+  }
+}
+if (process.env.SENTRIAL_CLI_SKIP_AUTO_RUN !== "1") {
+  run(process.argv.slice(2)).catch((error) => {
+    if (error instanceof CliError) {
+      if (process.env.SENTRIAL_CLI_DEBUG) {
+        process.stderr.write(`${error.stack ?? error.message}
+`);
+      } else {
+        process.stderr.write(`Error: ${error.message}
+`);
+      }
+      process.exitCode = error.exitCode;
+      return;
+    }
+    process.stderr.write(
+      `${error instanceof Error ? error.stack ?? error.message : String(error)}
+`
+    );
+    process.exitCode = 1;
+  });
+}
+export {
+  CliError,
+  buildInstallPlan,
+  detectProject,
+  diagnoseSession,
+  parseArgs,
+  run
+};
+//# sourceMappingURL=cli.js.map