trodo-cli 0.0.0-stage → 0.2.0

package/README.md

@@ -1,3 +1,25 @@
-# Temporary Holding Version
+# trodo-cli
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Trodo from the terminal, a script, CI or a coding agent: pull traces by what
+your evals said about them, keep whole runs with their span trees, build and
+label datasets, run agents, and export fine-tuning files.
+
+```bash
+npm i -g trodo-cli
+trodo login                        # opens the app to connect this terminal
+trodo evals list --table
+trodo traces count --kind runs --since 30d --eval "any:passed" --eval "any:not-failed"
+trodo traces export --kind spans --since 30d --eval any:passed --format openai --target output -o sft.jsonl
+trodo datasets create "Good refunds" --kind runs --eval "Refund policy:passed" --include-trace
+trodo datasets export "Good refunds" --rows passed --format openai --target output -o train.jsonl
+```
+
+`trodo help` lists every command and filter. Output is JSON (add `--table`
+for a table). Exit codes: 0 ok, 1 API error, 2 usage.
+
+Auth: `trodo login` (browser), `trodo login --key trodo_mk_…`, or
+`TRODO_API_KEY` / `TRODO_API_URL`. Keys live in Settings → MCP; one acts as
+the person who made it, on its team, with its scopes.
+
+Coding agents: the `trodo-datasets` skill (skills/trodo-datasets/SKILL.md in
+the Trodo repo) teaches the whole loop.

package/bin/trodo.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+'use strict';
+
+// `trodo … | head` closes the pipe early: that is done, not an error.
+process.stdout.on('error', (e) => { if (e && e.code === 'EPIPE') process.exit(0); throw e; });
+
+require('../lib/main').main(process.argv.slice(2)).then((code) => { process.exitCode = code; });

package/lib/args.js

@@ -0,0 +1,45 @@
+'use strict';
+
+/**
+ * Flags: `--name value`, `--name=value`, `--flag` (true), `-o file`, `-f file`.
+ * A flag given twice collects into an array (`--where a --where b`).
+ * `--` ends flags. Everything else is positional.
+ */
+const SHORT = { o: 'out', f: 'file', h: 'help', n: 'limit' };
+const BOOLEAN = new Set(['help', 'json', 'table', 'live', 'include-trace', 'wait', 'yes', 'no-trace', 'no-browser', 'any-span']);
+
+function parse(argv) {
+  const flags = {};
+  const positional = [];
+  const put = (k, v) => {
+    if (flags[k] === undefined) flags[k] = v;
+    else flags[k] = [].concat(flags[k], v);
+  };
+  for (let i = 0; i < argv.length; i += 1) {
+    const a = argv[i];
+    if (a === '--') { positional.push(...argv.slice(i + 1)); break; }
+    if (a.startsWith('--')) {
+      const eq = a.indexOf('=');
+      const key = eq > 0 ? a.slice(2, eq) : a.slice(2);
+      if (eq > 0) { put(key, a.slice(eq + 1)); continue; }
+      if (BOOLEAN.has(key)) { put(key, true); continue; }
+      const next = argv[i + 1];
+      if (next === undefined || (next.startsWith('--') && next.length > 2)) { put(key, true); continue; }
+      put(key, next); i += 1;
+      continue;
+    }
+    if (/^-[a-zA-Z]$/.test(a)) {
+      const key = SHORT[a[1]] || a[1];
+      if (BOOLEAN.has(key)) { put(key, true); continue; }
+      put(key, argv[i + 1]); i += 1;
+      continue;
+    }
+    positional.push(a);
+  }
+  return { flags, positional };
+}
+
+/** A flag as a list (absent → []). */
+const list = (v) => (v === undefined || v === true ? [] : [].concat(v)).map(String);
+
+module.exports = { parse, list };

package/lib/commands/agents.js

@@ -0,0 +1,56 @@
+'use strict';
+
+const config = require('../config');
+const { client } = require('../http');
+const { print } = require('../output');
+
+const usage = (msg) => { const e = new Error(msg); e.exitCode = 2; return e; };
+const DONE = new Set(['succeeded', 'failed', 'cancelled', 'canceled', 'stopped']);
+
+async function resolveAgent(api, ref) {
+  if (!ref) throw usage('Name the agent (its name or id).');
+  const { workflows } = await api.get('/agents');
+  const all = workflows || [];
+  const hit = all.find((w) => w.id === ref) || all.find((w) => w.name === ref) || all.find((w) => w.name.toLowerCase() === String(ref).toLowerCase());
+  if (!hit) throw usage(`No agent "${ref}". \`trodo agents list\` shows them.`);
+  return hit;
+}
+
+async function listAgents(_a, flags) {
+  const { workflows } = await client(config.resolve(flags)).get('/agents');
+  print(workflows || [], flags, [['name', 'Agent', 44], ['status', 'Status', 10], ['id', 'Id', 36], ['updated_at', 'Updated', 24]]);
+}
+
+/** trodo agents run AGENT [--input JSON] [--wait]: start its published version, as Run manually does. */
+async function run([ref], flags) {
+  const api = client(config.resolve(flags));
+  const a = await resolveAgent(api, ref);
+  let input = null;
+  if (flags.input) { try { input = JSON.parse(String(flags.input)); } catch (e) { throw usage(`--input is not JSON: ${e.message}`); } }
+  const { execution } = await api.post(`/agents/${a.id}/executions`, { input });
+  if (!flags.wait) return print({ agent: a.name, execution }, flags);
+  let exec = execution;
+  const deadline = Date.now() + (Number(flags.timeout) || 900) * 1000;
+  while (!DONE.has(String(exec.status)) && Date.now() < deadline) {
+    // eslint-disable-next-line no-await-in-loop
+    await new Promise((r) => setTimeout(r, 2000));
+    // eslint-disable-next-line no-await-in-loop
+    exec = (await api.get(`/agents/executions/${exec.id}`, { lite: 1 })).execution;
+  }
+  print({ agent: a.name, execution: exec }, flags);
+  if (exec.status === 'failed') process.exitCode = 1;
+}
+
+async function executions([ref], flags) {
+  const api = client(config.resolve(flags));
+  const a = await resolveAgent(api, ref);
+  const out = await api.get(`/agents/${a.id}/executions`, { limit: flags.limit || 20 });
+  print(out.executions || out, flags, [['id', 'Execution', 36], ['status', 'Status', 10], ['started_at', 'Started', 24], ['finished_at', 'Finished', 24]]);
+}
+
+async function execution([id], flags) {
+  if (!id) throw usage('Usage: trodo agents execution EXECUTION_ID');
+  print(await client(config.resolve(flags)).get(`/agents/executions/${encodeURIComponent(id)}`), flags);
+}
+
+module.exports = { list: listAgents, run, executions, execution };

package/lib/commands/auth.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const config = require('../config');
+const { client } = require('../http');
+const { print } = require('../output');
+
+async function readHidden(prompt) {
+  if (!process.stdin.isTTY) {
+    const chunks = [];
+    for await (const c of process.stdin) chunks.push(c);
+    return Buffer.concat(chunks).toString('utf8').trim();
+  }
+  process.stdout.write(prompt);
+  return new Promise((resolve) => {
+    let v = '';
+    process.stdin.setRawMode(true); process.stdin.resume();
+    const onData = (b) => {
+      const s = b.toString('utf8');
+      if (s === '\r' || s === '\n' || s === '\u0004') { process.stdin.setRawMode(false); process.stdin.pause(); process.stdin.off('data', onData); process.stdout.write('\n'); resolve(v.trim()); }
+      else if (s === '\u0003') { process.stdout.write('\n'); process.exit(130); }
+      else if (s === '\u007f') v = v.slice(0, -1);
+      else v += s;
+    };
+    process.stdin.on('data', onData);
+  });
+}
+
+/** Open a URL in the default browser; false when there is none to open. */
+function openBrowser(url) {
+  // eslint-disable-next-line global-require
+  const { spawn } = require('child_process');
+  const cmd = process.platform === 'darwin' ? ['open', [url]] : process.platform === 'win32' ? ['cmd', ['/c', 'start', '', url]] : ['xdg-open', [url]];
+  try {
+    const p = spawn(cmd[0], cmd[1], { stdio: 'ignore', detached: true });
+    p.on('error', () => {});
+    p.unref();
+    return true;
+  } catch { return false; }
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/** The browser sign-in: a code here, Connect in the app, a key back. */
+async function browserLogin(url, flags) {
+  // eslint-disable-next-line global-require
+  const os = require('os');
+  // eslint-disable-next-line global-require
+  const pkg = require('../../package.json');
+  const fetchImpl = globalThis.fetch;
+  const post = async (p, body) => {
+    const res = await fetchImpl(`${url}/api/v1${p}`, { method: 'POST', headers: { 'Content-Type': 'application/json', 'User-Agent': `trodo-cli/${pkg.version}` }, body: JSON.stringify(body) });
+    const data = await res.json().catch(() => ({}));
+    if (!res.ok) { const e = new Error(data.message || data.error || `HTTP ${res.status} from ${url}`); e.status = res.status; throw e; }
+    return data;
+  };
+  const start = await post('/auth/device', { host: os.hostname().replace(/\.local$/, ''), client: `trodo-cli ${pkg.version}` });
+  process.stderr.write(`\nYour code: ${start.user_code}\n`);
+  const opened = !flags['no-browser'] && openBrowser(start.verification_url);
+  process.stderr.write(`${opened ? 'Opened' : 'Open'} ${start.verification_url}\n${opened ? 'Check the code there and press Connect.' : 'Sign in there, check the code and press Connect.'} Waiting…\n`);
+  const deadline = Date.now() + (start.expires_in || 600) * 1000;
+  while (Date.now() < deadline) {
+    // eslint-disable-next-line no-await-in-loop
+    await sleep((start.interval || 2) * 1000);
+    // eslint-disable-next-line no-await-in-loop
+    const out = await post('/auth/device/token', { device_code: start.device_code });
+    if (out.status === 'approved') return out.api_key;
+    if (out.status === 'denied') { const e = new Error('Sign-in was refused in the browser.'); e.exitCode = 1; throw e; }
+    if (out.status === 'expired') break;
+  }
+  const e = new Error('The sign-in code expired. Run `trodo login` again.');
+  e.exitCode = 1;
+  throw e;
+}
+
+/**
+ * trodo login [--url URL] [--no-browser]: sign in through the app (a code, Connect, done).
+ * trodo login --key trodo_mk_…: use a key you made in Settings → MCP (CI, no browser).
+ * Saved to ~/.trodo/config.json, mode 600.
+ */
+async function login(_args, flags) {
+  const url = config.resolve(flags).url;
+  let key;
+  // --key K uses that key; --key alone (or --key -) reads it from the terminal or stdin.
+  if (flags.key === true || flags.key === '-') key = await readHidden('API key (trodo_mk_…, Settings → MCP): ');
+  else if (flags.key) key = String(flags.key);
+  else key = await browserLogin(url, flags);
+  if (!key.startsWith('trodo_mk_')) { const e = new Error('That is not a Trodo API key (they start with trodo_mk_).'); e.exitCode = 2; throw e; }
+  const me = await client({ url, key }).get('/me');
+  const cfg = config.read();
+  const file = config.write({ ...cfg, api_key: key, api_url: url });
+  process.stderr.write(`Signed in to ${me.team.name} as ${me.user.email}. Saved to ${file}.\n`);
+  print({ team: me.team, scopes: me.key.scopes }, flags);
+}
+
+async function whoami(_args, flags) {
+  print(await client(config.resolve(flags)).get('/me'), flags);
+}
+
+async function logout(_args, flags) {
+  const cfg = config.read();
+  delete cfg.api_key;
+  config.write(cfg);
+  process.stderr.write('Removed the saved key.\n');
+  print({ ok: true }, flags);
+}
+
+module.exports = { login, whoami, logout };

package/lib/commands/datasets.js

@@ -0,0 +1,174 @@
+'use strict';
+
+const config = require('../config');
+const { client } = require('../http');
+const { print, sink, readRows } = require('../output');
+const { buildSpec } = require('./traces');
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const usage = (msg) => { const e = new Error(msg); e.exitCode = 2; return e; };
+
+async function resolveDataset(api, ref) {
+  if (!ref) throw usage('Name the dataset (its name or id).');
+  const { datasets } = await api.get('/datasets');
+  const all = datasets || [];
+  const hit = all.find((d) => d.id === ref) || all.find((d) => d.name === ref) || all.find((d) => d.name.toLowerCase() === String(ref).toLowerCase());
+  if (!hit) throw usage(`No dataset "${ref}". \`trodo datasets list\` shows them.`);
+  return hit;
+}
+
+async function listDatasets(_a, flags) {
+  const { datasets } = await client(config.resolve(flags)).get('/datasets');
+  print(datasets || [], flags, [['name', 'Dataset', 40], ['item_count', 'Rows', 8], ['expected_count', 'With Expected', 14], ['id', 'Id', 36], ['updated_at', 'Updated', 24]]);
+}
+
+async function getDataset([ref], flags) {
+  const api = client(config.resolve(flags));
+  const d = await resolveDataset(api, ref);
+  const [sources, versions] = await Promise.all([
+    api.get(`/datasets/${d.id}/sources`).catch(() => ({ sources: [] })),
+    api.get(`/datasets/${d.id}/versions`).catch(() => ({ versions: [] })),
+  ]);
+  print({ ...d, sources: sources.sources || sources, versions: (versions.versions || versions || []).slice(0, 20) }, flags);
+}
+
+/**
+ * trodo datasets create NAME [--description D]
+ *   [--kind spans|runs|conversations|verdicts <filter flags> [--live] [--include-trace]]
+ * With --kind, the dataset starts with a source: what the filter matches is copied now
+ * (and, with --live, every 15 minutes after).
+ */
+async function create([name], flags) {
+  if (!name) throw usage('Usage: trodo datasets create NAME [--kind runs --eval "Grounded:passed" --include-trace]');
+  const api = client(config.resolve(flags));
+  // The filter is checked before anything is made: a typo never leaves an empty dataset behind.
+  const spec = flags.kind ? await buildSpec(api, flags, String(flags.kind)) : null;
+  const { dataset } = await api.post('/datasets', { name, ...(flags.description ? { description: String(flags.description) } : {}) });
+  let source = null;
+  if (spec) source = await api.post(`/datasets/${dataset.id}/sources`, { ...spec, live: Boolean(flags.live) });
+  print({ dataset: { id: dataset.id, name: dataset.name }, ...(source ? { source: source.source, run: source.feed } : {}) }, flags);
+}
+
+/** trodo datasets add DATASET --kind KIND <filter flags> [--live] [--include-trace]: another source. */
+async function addSource([ref], flags) {
+  const api = client(config.resolve(flags));
+  const d = await resolveDataset(api, ref);
+  const spec = await buildSpec(api, flags, String(flags.kind || 'runs'));
+  const out = await api.post(`/datasets/${d.id}/sources`, { ...spec, live: Boolean(flags.live) });
+  print({ dataset: d.name, source: out.source, run: out.feed }, flags);
+}
+
+/**
+ * trodo datasets append DATASET [-f rows.jsonl | stdin] [--include-trace]
+ * A line is a plain row { input | messages, output?, expected?, metadata? } or a
+ * reference to traffic ({ run_id } / { span_id } / { conversation_id } / { eval_run_id }),
+ * which the server fills with Input, Output and the evaluations. Rows already held are skipped.
+ */
+async function append([ref], flags) {
+  const api = client(config.resolve(flags));
+  const d = await resolveDataset(api, ref);
+  const rows = await readRows(flags.file);
+  const REF = new Set(['run_id', 'span_id', 'conversation_id', 'eval_run_id']);
+  const refs = { run_ids: [], span_ids: [], conversation_ids: [], eval_run_ids: [] };
+  const plain = [];
+  for (const r of rows) {
+    const keys = r && typeof r === 'object' ? Object.keys(r) : [];
+    if (keys.length && keys.every((k) => REF.has(k))) {
+      if (r.eval_run_id) refs.eval_run_ids.push(String(r.eval_run_id));
+      else if (r.span_id) refs.span_ids.push(String(r.span_id));
+      else if (r.run_id) refs.run_ids.push(String(r.run_id));
+      else refs.conversation_ids.push(String(r.conversation_id));
+    } else if (r && typeof r === 'object') {
+      const { expected, ...rest } = r;
+      plain.push(expected !== undefined && rest.expected_output === undefined ? { ...rest, expected_output: expected } : rest);
+    }
+  }
+  let written = 0; let skipped = 0;
+  const chunk = (arr, n) => Array.from({ length: Math.ceil(arr.length / n) }, (_, i) => arr.slice(i * n, i * n + n));
+  for (const [key, ids] of Object.entries(refs)) {
+    for (const part of chunk(ids, 200)) {
+      // eslint-disable-next-line no-await-in-loop
+      const out = await api.post(`/datasets/${d.id}/items`, { [key]: part, ...(flags['include-trace'] ? { include_trace: true } : {}) });
+      written += Number(out.written ?? out.added ?? 0); skipped += Number(out.skipped ?? 0);
+    }
+  }
+  for (const part of chunk(plain, 500)) {
+    // eslint-disable-next-line no-await-in-loop
+    const out = await api.post(`/datasets/${d.id}/items`, { items: part });
+    written += Number(out.written ?? out.added ?? (Array.isArray(out.items) ? out.items.length : part.length)); skipped += Number(out.skipped ?? 0);
+  }
+  print({ dataset: d.name, written, skipped }, flags);
+}
+
+/**
+ * trodo datasets update DATASET [-f updates.jsonl | stdin] [--label person|derived] [--name "version name"]
+ * Lines: { id, expected?, output?, metadata? } — the row ids an export or `rows` gave you.
+ * One version for the whole call. Expected counts as a person's unless --label derived.
+ */
+async function update([ref], flags) {
+  const api = client(config.resolve(flags));
+  const d = await resolveDataset(api, ref);
+  const rows = (await readRows(flags.file)).filter((r) => r && r.id);
+  if (!rows.length) throw usage('No updates: give lines like {"id": "…", "expected": "…"}.');
+  let updated = 0; let unchanged = 0; const missing = []; let version = null;
+  for (let i = 0; i < rows.length; i += 5000) {
+    // eslint-disable-next-line no-await-in-loop
+    const out = await api.post(`/datasets/${d.id}/items/update`, {
+      updates: rows.slice(i, i + 5000),
+      label: flags.label === 'derived' ? 'derived' : 'person',
+      ...(flags.name ? { version_name: String(flags.name) } : {}),
+    });
+    updated += out.updated; unchanged += out.unchanged; missing.push(...(out.missing || [])); version = out.version || version;
+  }
+  print({ dataset: d.name, updated, unchanged, missing: missing.slice(0, 50), version }, flags);
+}
+
+/**
+ * trodo datasets export DATASET [--rows all|expected|no-expected|passed|failed|marked-wrong]
+ *   [--eval NAME] [--min-score N] [--format trodo|openai|dpo] [--target expected|output|expected-else-output]
+ *   [--version N] [-o file]
+ * `--rows passed --format openai --target output` is a supervised fine-tuning file
+ * made of what went well, no labeling needed.
+ */
+async function exportDataset([ref], flags) {
+  const api = client(config.resolve(flags));
+  const d = await resolveDataset(api, ref);
+  const query = {
+    rows: flags.rows ? String(flags.rows).replace(/-/g, '_') : undefined,
+    eval: flags.eval ? String(flags.eval) : undefined,
+    min_score: flags['min-score'],
+    format: flags.format ? String(flags.format) : undefined,
+    target: flags.target ? String(flags.target).replace(/-/g, '_') : undefined,
+    version: flags.version === true ? undefined : flags.version,
+  };
+  const res = await api.raw('GET', `/datasets/${d.id}/export`, { query });
+  if (!res.ok) {
+    const t = await res.text(); let body; try { body = JSON.parse(t); } catch { body = { message: t }; }
+    const e = new Error(body.message || body.error || `HTTP ${res.status}`); e.exitCode = 1; throw e;
+  }
+  const out = sink(flags.out && flags.out !== true ? String(flags.out) : null);
+  const decoder = new TextDecoder();
+  let buf = '';
+  for await (const c of res.body) {
+    buf += decoder.decode(c, { stream: true });
+    let i;
+    while ((i = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, i).trim(); buf = buf.slice(i + 1);
+      // eslint-disable-next-line no-await-in-loop
+      if (line) await out.write(JSON.parse(line));
+    }
+  }
+  if (buf.trim()) await out.write(JSON.parse(buf.trim()));
+  await out.close();
+  const n = res.headers.get('x-trodo-export-rows'); const skipped = res.headers.get('x-trodo-export-skipped');
+  process.stderr.write(`${n} rows from ${d.name}${skipped ? `, ${skipped} skipped (no input or no target)` : ''}${flags.out ? ` → ${flags.out}` : ''}\n`);
+}
+
+async function versions([ref], flags) {
+  const api = client(config.resolve(flags));
+  const d = await resolveDataset(api, ref);
+  const out = await api.get(`/datasets/${d.id}/versions`);
+  print(out.versions || out, flags, [['version_no', 'v', 4], ['name', 'Name', 40], ['item_count', 'Rows', 8], ['created_at', 'At', 24]]);
+}
+
+module.exports = { list: listDatasets, get: getDataset, create, add: addSource, append, update, export: exportDataset, rows: exportDataset, versions, resolveDataset, UUID };

package/lib/commands/evals.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const config = require('../config');
+const { client } = require('../http');
+const { print } = require('../output');
+
+/** trodo evals list: the names --eval takes, and each eval's steps (STEP.FIELD). */
+async function listEvals(_args, flags) {
+  const { evals } = await client(config.resolve(flags)).get('/evals');
+  const rows = (evals || []).map((e) => ({
+    ...e,
+    step_fields: (e.steps || []).flatMap((s) => (s.fields || []).map((f) => `${s.name}.${f.name} (${f.type === 'enum' ? (f.values || []).join('|') : f.type})`)).join('; '),
+  }));
+  print(flags.table ? rows : evals, flags, [['name', 'Eval', 44], ['target', 'Target', 12], ['enabled', 'On', 5], ['step_fields', 'Steps (STEP.FIELD)', 70]]);
+}
+
+module.exports = { list: listEvals };

package/lib/commands/runs.js

@@ -0,0 +1,41 @@
+'use strict';
+
+const config = require('../config');
+const { client } = require('../http');
+const { print } = require('../output');
+const { buildSpec } = require('./traces');
+
+const DAY = 86400e3;
+/** A filter's time → { time_start, time_end } for the runs list. */
+function windowOf(time, now = Date.now()) {
+  if (time.from || time.to) return { time_start: time.from || new Date(now - 7 * DAY).toISOString(), time_end: time.to || new Date(now).toISOString() };
+  const p = String(time.preset || '7d');
+  const start = new Date(now); start.setHours(0, 0, 0, 0);
+  if (p === 'today') return { time_start: start.toISOString(), time_end: new Date(now).toISOString() };
+  if (p === 'yesterday') return { time_start: new Date(start.getTime() - DAY).toISOString(), time_end: new Date(start.getTime() - 1).toISOString() };
+  const m = /^(\d+)([mhd])$/.exec(p);
+  const n = m ? Number(m[1]) : 7;
+  const unit = !m ? DAY : m[2] === 'h' ? 3600e3 : m[2] === 'd' ? DAY : (['3m', '6m', '12m'].includes(p) ? 30 * DAY : 60e3);
+  return { time_start: new Date(now - n * unit).toISOString(), time_end: new Date(now).toISOString() };
+}
+
+/** trodo runs list [filter flags] [--limit 50] */
+async function listRuns(_args, flags) {
+  const api = client(config.resolve(flags));
+  const spec = await buildSpec(api, flags, 'runs');
+  const mf = [...spec.filter.modularFilters];
+  if (spec.filter.eval_conditions) mf.push({ category: 'evals', field: 'eval_conditions', operator: 'is', value: spec.filter.eval_conditions });
+  const query = { ...windowOf(spec.filter.time), limit: spec.options.limit || 50 };
+  // The runs list decodes this once more (decodeURIComponent then JSON), as the app sends it.
+  if (mf.length) query.modularFilters = encodeURIComponent(JSON.stringify(mf));
+  const out = await api.get('/runs', query);
+  print(out.runs || out, flags, [['run_id', 'Run', 36], ['agent_name', 'Agent', 30], ['status', 'Status', 8], ['started_at', 'Started', 24], ['duration_ms', 'ms', 8]]);
+}
+
+/** trodo runs get RUN_ID: the run and its spans. */
+async function getRun([id], flags) {
+  if (!id) { const e = new Error('Usage: trodo runs get RUN_ID'); e.exitCode = 2; throw e; }
+  print(await client(config.resolve(flags)).get(`/runs/${encodeURIComponent(id)}`, { include: 'spans,messages' }), flags);
+}
+
+module.exports = { list: listRuns, get: getRun, windowOf };

package/lib/commands/traces.js

@@ -0,0 +1,46 @@
+'use strict';
+
+const config = require('../config');
+const { client } = require('../http');
+const { print, sink } = require('../output');
+const { specFromFlags, needsEvals } = require('../filters');
+
+async function evalsIfNeeded(api, flags) {
+  return needsEvals(flags) ? (await api.get('/evals')).evals || [] : [];
+}
+
+async function buildSpec(api, flags, kind) {
+  return specFromFlags(flags, { kind, evals: await evalsIfNeeded(api, flags) });
+}
+
+/** trodo traces count [filter flags] */
+async function count(_args, flags) {
+  const api = client(config.resolve(flags));
+  const spec = await buildSpec(api, flags, flags.kind || 'runs');
+  const out = await api.post('/traces/count', spec);
+  print({ kind: spec.kind, matched: out.matched, capped: out.capped, window: out.window, sample: out.sample }, flags);
+}
+
+/**
+ * trodo traces export [filter flags] [--include-trace] [--format trodo|openai|dpo] [--target output|expected] [-o file]
+ * One JSON line per unit (the row a dataset would hold, with its evaluations),
+ * or one fine-tuning example per line. The summary goes to stderr.
+ */
+async function exportTraces(_args, flags) {
+  const api = client(config.resolve(flags));
+  const spec = await buildSpec(api, flags, flags.kind || 'runs');
+  const body = { ...spec };
+  if (flags.format) body.format = String(flags.format);
+  if (flags.target) body.target = String(flags.target);
+  const out = sink(flags.out && flags.out !== true ? String(flags.out) : null);
+  let summary = null;
+  for await (const line of api.lines('POST', '/traces/export', { body })) {
+    if (line && line._trodo) { summary = line._trodo; continue; }
+    // eslint-disable-next-line no-await-in-loop
+    await out.write(line);
+  }
+  await out.close();
+  if (summary) process.stderr.write(`${summary.rows} ${spec.kind}${summary.skipped ? `, ${summary.skipped} skipped (no input or no target)` : ''}${flags.out ? ` → ${flags.out}` : ''}\n`);
+}
+
+module.exports = { count, export: exportTraces, buildSpec };

package/lib/config.js

@@ -0,0 +1,37 @@
+'use strict';
+
+/**
+ * Where the CLI finds its key and server: TRODO_API_KEY / TRODO_API_URL, else
+ * ~/.trodo/config.json (written by `trodo login`, mode 600). A key is a Trodo
+ * API key (trodo_mk_…, Settings → MCP); it acts as the person who made
+ * it, on its team, with its scopes.
+ */
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const DEFAULT_URL = 'https://api.trodo.ai';
+
+function file() {
+  return process.env.TRODO_CONFIG || path.join(os.homedir(), '.trodo', 'config.json');
+}
+
+function read() {
+  try { return JSON.parse(fs.readFileSync(file(), 'utf8')); } catch { return {}; }
+}
+
+function write(cfg) {
+  const f = file();
+  fs.mkdirSync(path.dirname(f), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(f, `${JSON.stringify(cfg, null, 2)}\n`, { mode: 0o600 });
+  return f;
+}
+
+function resolve(flags = {}) {
+  const cfg = read();
+  const key = flags.key || process.env.TRODO_API_KEY || cfg.api_key || null;
+  const url = String(flags.url || process.env.TRODO_API_URL || cfg.api_url || DEFAULT_URL).replace(/\/+$/, '');
+  return { key, url };
+}
+
+module.exports = { read, write, resolve, file, DEFAULT_URL };

package/lib/filters.js

@@ -0,0 +1,157 @@
+'use strict';
+
+/**
+ * Filter flags → the filter the Traces page and dataset sources use
+ * ({ modularFilters, time, eval_conditions }), so `trodo traces export`, a
+ * dataset source and the Traces page all mean the same thing.
+ *
+ *   --since 7d | 24h | 30d | 3m | today | 90d     (default 7d)
+ *   --from ISO --to ISO
+ *   --agent NAME                                  (repeatable)
+ *   --where "status=error"   = != ~ (contains) > >= < <=   e.g. total_cost>0.05,
+ *            span.model~gpt-4o, metadata.tier=pro, attributes.region!=eu
+ *   --eval "NAME:COND"       COND: failed | passed | not-failed | marked-wrong |
+ *            not-marked-wrong | marked-right | score<0.5 | reason=A,B |
+ *            "STEP.FIELD=value" | "STEP.FIELD<3"     NAME may be "any"
+ *   --sample PCT, --limit N
+ */
+
+const { list } = require('./args');
+
+const OPS = [
+  ['>=', 'greater_than_equal'], ['<=', 'less_than_equal'], ['!=', 'is_not'],
+  ['>', 'greater_than'], ['<', 'less_than'], ['~', 'contains'], ['=', 'is'],
+];
+const NUM = { '<': 'lt', '<=': 'lte', '>': 'gt', '>=': 'gte', '=': 'eq' };
+
+function fail(msg) { const e = new Error(msg); e.exitCode = 2; throw e; }
+
+function timeOf(flags) {
+  if (flags.from || flags.to) {
+    const from = flags.from ? new Date(flags.from) : null;
+    const to = flags.to ? new Date(flags.to) : null;
+    if ((from && Number.isNaN(from.getTime())) || (to && Number.isNaN(to.getTime()))) fail('--from / --to must be dates (2026-10-01 or ISO)');
+    return { preset: 'custom', ...(from ? { from: from.toISOString() } : {}), ...(to ? { to: to.toISOString() } : {}) };
+  }
+  const since = String(flags.since || '7d');
+  if (!/^(\d+[mhd]|today|yesterday|\d+m)$/.test(since)) fail('--since takes 24h, 7d, 30d, 3m, 6m, 12m, today or yesterday');
+  return { preset: since };
+}
+
+/** "status=error" → a Traces filter chip. */
+function whereChip(expr) {
+  const s = String(expr);
+  for (const [sym, operator] of OPS) {
+    const i = s.indexOf(sym);
+    if (i > 0) {
+      const field = s.slice(0, i).trim();
+      const raw = s.slice(i + sym.length).trim();
+      if (!field || raw === '') fail(`--where "${s}": write it as field${sym}value`);
+      const isNum = /^-?\d+(\.\d+)?$/.test(raw);
+      let value = raw;
+      if (operator === 'is' || operator === 'is_not') value = raw.split(',').map((x) => x.trim()).filter(Boolean);
+      else if (operator.startsWith('greater') || operator.startsWith('less')) {
+        if (!isNum) fail(`--where "${s}": ${sym} needs a number`);
+        value = Number(raw);
+      }
+      return { field, operator, value, category: 'global' };
+    }
+  }
+  return fail(`--where "${s}": use =, !=, ~ (contains), >, >=, < or <=`);
+}
+
+function findEval(evals, name) {
+  if (/^any$/i.test(name)) return null;
+  const n = name.toLowerCase();
+  const exact = evals.filter((e) => e.id === name || e.name.toLowerCase() === n);
+  if (exact.length === 1) return exact[0];
+  const part = evals.filter((e) => e.name.toLowerCase().includes(n));
+  if (part.length === 1) return part[0];
+  if (!part.length) fail(`No eval called "${name}". \`trodo evals list\` shows them.`);
+  return fail(`"${name}" matches ${part.length} evals: ${part.map((e) => e.name).join(', ')}. Use more of the name.`);
+}
+
+/** "Grounded:failed", "any:score<0.4", "Router:route.choice=billing" → an eval condition. */
+function evalCondition(expr, evals) {
+  const s = String(expr);
+  const colon = s.indexOf(':');
+  if (colon <= 0) fail(`--eval "${s}": write it as NAME:CONDITION (e.g. "Grounded:failed")`);
+  const ev = findEval(evals, s.slice(0, colon).trim());
+  const base = ev ? { lineage_id: ev.id } : {};
+  const cond = s.slice(colon + 1).trim();
+  const words = {
+    failed: { verdict: 'fail' }, passed: { verdict: 'pass' }, 'not-failed': { verdict: 'fail', negate: true },
+    'marked-wrong': { marked: 'wrong' }, 'not-marked-wrong': { marked: 'wrong', negate: true }, 'marked-right': { marked: 'right' },
+  };
+  if (words[cond]) return { ...base, ...words[cond] };
+  let m = /^score\s*(<=|>=|<|>|=)\s*(-?\d+(\.\d+)?)$/.exec(cond);
+  if (m) return { ...base, score: { op: NUM[m[1]], value: Number(m[2]) } };
+  m = /^reason\s*=\s*(.+)$/.exec(cond);
+  if (m) return { ...base, reason_codes: m[1].split(',').map((x) => x.trim()).filter(Boolean) };
+  m = /^(.+?)\.([A-Za-z_][\w]*)\s*(<=|>=|<|>|!=|=)\s*(.+)$/.exec(cond);
+  if (m) {
+    if (!ev) fail(`--eval "${s}": a step needs a named eval, not "any"`);
+    const [, stepRef, field, op, rawVal] = m;
+    const steps = ev.steps || [];
+    const ref = stepRef.trim().toLowerCase();
+    const byStart = steps.filter((st) => st.name.toLowerCase().startsWith(ref));
+    const step = steps.find((st) => st.id === stepRef || st.name.toLowerCase() === ref) || (byStart.length === 1 ? byStart[0] : null);
+    if (!step) fail(`--eval "${s}": "${ev.name}" has no step "${stepRef}". Its steps: ${(ev.steps || []).map((st) => st.name).join(', ') || 'none that answer'}`);
+    const f = (step.fields || []).find((x) => x.name === field);
+    if (!f) fail(`--eval "${s}": step "${step.name}" answers ${(step.fields || []).map((x) => x.name).join(', ')}, not ${field}`);
+    const val = rawVal.trim();
+    if (f.type === 'boolean') {
+      const yes = /^(true|yes|1)$/i.test(val); const no = /^(false|no|0)$/i.test(val);
+      if (!yes && !no) fail(`--eval "${s}": ${field} is yes/no`);
+      return { ...base, step: { node_id: step.id, field, op: op === '!=' ? 'neq' : 'eq', value: yes } };
+    }
+    if (f.type === 'number') {
+      if (!/^-?\d+(\.\d+)?$/.test(val)) fail(`--eval "${s}": ${field} is a number`);
+      return { ...base, step: { node_id: step.id, field, op: op === '!=' ? 'neq' : NUM[op], value: Number(val) } };
+    }
+    if (f.type === 'enum') {
+      return { ...base, step: { node_id: step.id, field, op: op === '!=' ? 'not_in' : 'in', value: val.split(',').map((x) => x.trim()) } };
+    }
+    return { ...base, step: { node_id: step.id, field, op: op === '!=' ? 'neq' : 'eq', value: val } };
+  }
+  return fail(`--eval "${s}": unknown condition "${cond}". Use failed, passed, not-failed, marked-wrong, not-marked-wrong, marked-right, score<0.5, reason=CODE or STEP.FIELD=value`);
+}
+
+/**
+ * The flags → { kind, filter, options }. `evals` is GET /evals's list,
+ * needed only when --eval names one.
+ */
+function specFromFlags(flags, { kind = flags.kind || 'runs', evals = [] } = {}) {
+  if (!['spans', 'runs', 'conversations', 'verdicts'].includes(kind)) fail('--kind is spans, runs, conversations or verdicts');
+  const time = timeOf(flags);
+  const agents = list(flags.agent);
+  const where = list(flags.where).map(whereChip);
+  const conds = list(flags.eval).map((e) => evalCondition(e, evals));
+  const options = {};
+  if (flags.limit !== undefined) {
+    const n = parseInt(flags.limit, 10);
+    if (!(n > 0)) fail('--limit must be a positive number');
+    options.limit = n;
+  }
+  if (flags.sample !== undefined) options.sample_pct = Number(flags.sample);
+  if (flags['include-trace']) options.include_trace = true;
+
+  if (kind === 'verdicts') {
+    const outcomes = list(flags.outcome).flatMap((o) => o.split(',')).map((o) => o.trim().replace(/-/g, '_')).filter(Boolean);
+    const ids = conds.map((c) => c.lineage_id).filter(Boolean);
+    const filter = { lineage_ids: ids, outcomes: outcomes.length ? outcomes : ['failed'], time };
+    if (flags.step) options.node_id = String(flags.step);
+    return { kind, filter, options };
+  }
+  const modularFilters = [];
+  if (agents.length) modularFilters.push({ field: 'agent_name', operator: 'is', value: agents, category: kind === 'spans' ? 'global' : 'agents' });
+  modularFilters.push(...where);
+  const filter = { modularFilters, time };
+  if (conds.length) filter.eval_conditions = conds;
+  if (kind === 'spans' && flags['any-span']) filter.span_kind = 'any';
+  return { kind, filter, options };
+}
+
+const needsEvals = (flags) => list(flags.eval).some((e) => !/^any:/i.test(e));
+
+module.exports = { specFromFlags, whereChip, evalCondition, timeOf, needsEvals };

package/lib/http.js

@@ -0,0 +1,73 @@
+'use strict';
+
+/** The API, over fetch (Node 18+). Every call goes to {url}/api/v1. */
+
+class ApiError extends Error {
+  constructor(status, body) {
+    const msg = (body && (body.message || body.error)) || `HTTP ${status}`;
+    super(typeof msg === 'string' ? msg : JSON.stringify(msg));
+    this.status = status;
+    this.body = body;
+  }
+}
+
+function client({ url, key, fetchImpl = globalThis.fetch }) {
+  if (!key) {
+    const e = new Error('No API key. Run `trodo login`, or set TRODO_API_KEY (a trodo_mk_ key from Settings → MCP).');
+    e.exitCode = 2;
+    throw e;
+  }
+  const base = `${url}/api/v1`;
+  const headers = { Authorization: `Bearer ${key}`, 'User-Agent': 'trodo-cli/0.2', Accept: 'application/json' };
+
+  async function request(method, p, { query, body } = {}) {
+    const qs = query ? `?${new URLSearchParams(Object.entries(query).filter(([, v]) => v !== undefined && v !== null && v !== '').map(([k, v]) => [k, String(v)]))}` : '';
+    const res = await fetchImpl(`${base}${p}${qs}`, {
+      method,
+      headers: body !== undefined ? { ...headers, 'Content-Type': 'application/json' } : headers,
+      body: body !== undefined ? JSON.stringify(body) : undefined,
+    });
+    return res;
+  }
+
+  async function json(method, p, opts) {
+    const res = await request(method, p, opts);
+    const text = await res.text();
+    let data = null;
+    try { data = text ? JSON.parse(text) : null; } catch { data = { message: text.slice(0, 300) }; }
+    if (!res.ok) throw new ApiError(res.status, data);
+    return data;
+  }
+
+  /** NDJSON lines from a response, one parsed object at a time. */
+  async function* lines(method, p, opts) {
+    const res = await request(method, p, opts);
+    if (!res.ok) {
+      const text = await res.text();
+      let data; try { data = JSON.parse(text); } catch { data = { message: text.slice(0, 300) }; }
+      throw new ApiError(res.status, data);
+    }
+    const decoder = new TextDecoder();
+    let buf = '';
+    for await (const chunk of res.body) {
+      buf += decoder.decode(chunk, { stream: true });
+      let i;
+      while ((i = buf.indexOf('\n')) >= 0) {
+        const line = buf.slice(0, i).trim();
+        buf = buf.slice(i + 1);
+        if (line) yield JSON.parse(line);
+      }
+    }
+    if (buf.trim()) yield JSON.parse(buf.trim());
+  }
+
+  return {
+    get: (p, query) => json('GET', p, { query }),
+    post: (p, body, query) => json('POST', p, { body, query }),
+    patch: (p, body) => json('PATCH', p, { body }),
+    lines,
+    raw: request,
+  };
+}
+
+module.exports = { client, ApiError };

package/lib/main.js

@@ -0,0 +1,96 @@
+'use strict';
+
+/**
+ * trodo — Trodo from a terminal, a script, CI or a coding agent.
+ * Every command prints JSON (pretty on a terminal) unless --table is given.
+ */
+const { parse } = require('./args');
+const { ApiError } = require('./http');
+
+const pkg = require('../package.json');
+
+const HELP = `trodo ${pkg.version} — traces, datasets and agents from the terminal
+
+  trodo login [--url https://api.trodo.ai] [--no-browser]   sign in through the app
+  trodo login --key trodo_mk_…                             or with a key (CI)
+  trodo whoami | logout
+
+  trodo evals list                                  eval names and their steps, for --eval
+  trodo traces count  [filter]
+  trodo traces export [filter] [--include-trace] [--format trodo|openai|dpo] [--target output|expected] [-o file]
+  trodo runs list [filter] [--limit 50]
+  trodo runs get RUN_ID
+
+  trodo datasets list | get DATASET | versions DATASET
+  trodo datasets create NAME [--kind runs|spans|conversations|verdicts [filter] [--live] [--include-trace]]
+  trodo datasets add DATASET --kind KIND [filter] [--live] [--include-trace]
+  trodo datasets append DATASET [-f rows.jsonl]     rows, or {run_id}/{span_id}/{conversation_id} lines
+  trodo datasets update DATASET [-f updates.jsonl]  {id, expected?, output?, metadata?} lines, one version
+  trodo datasets export DATASET [--rows passed|failed|expected|no-expected|marked-wrong|all]
+                        [--eval NAME] [--min-score N] [--format trodo|openai|dpo] [--target ...] [--version N] [-o file]
+
+  trodo agents list | executions AGENT | execution ID
+  trodo agents run AGENT [--input JSON] [--wait]
+
+Filter (traces, runs, datasets create/add):
+  --kind spans|runs|conversations|verdicts   (default runs)
+  --since 24h|7d|30d|3m|today  or  --from DATE --to DATE      (default 7d)
+  --agent NAME                               repeatable
+  --where "status=error"                     = != ~ > >= < <= on any Traces property:
+                                             total_cost>0.05  span.model~gpt-4o  metadata.tier=pro
+  --eval "NAME:COND"                         failed | passed | not-failed | marked-wrong | not-marked-wrong |
+                                             marked-right | score<0.5 | reason=CODE | STEP.FIELD=value | STEP.FIELD<3
+                                             NAME may be "any". Conditions AND together.
+  --outcome failed,passed,marked-wrong       (verdicts)   --step STEP_ID (verdicts, one step per row)
+  --limit N   --sample PCT
+
+Training data:
+  trodo traces export --kind spans --eval "any:passed" --eval "any:not-failed" --format openai --target output -o sft.jsonl
+  trodo datasets create "Good refunds" --kind runs --eval "Refund policy:passed" --include-trace
+  trodo datasets export "Good refunds" --rows passed --format openai --target output -o train.jsonl
+  firectl dataset create good-refunds train.jsonl
+
+Auth: TRODO_API_KEY / TRODO_API_URL, or \`trodo login\` (~/.trodo/config.json).
+A key is a Trodo API key (Settings → MCP); it acts as the person who made it, on its team, with its scopes.
+Output: JSON by default; --table for a table. Exit codes: 0 ok, 1 API error, 2 usage.
+`;
+
+const COMMANDS = {
+  login: ['auth', 'login'], whoami: ['auth', 'whoami'], logout: ['auth', 'logout'],
+};
+const GROUPS = {
+  evals: ['list'],
+  traces: ['count', 'export'],
+  runs: ['list', 'get'],
+  datasets: ['list', 'get', 'create', 'add', 'append', 'update', 'export', 'rows', 'versions'],
+  agents: ['list', 'run', 'executions', 'execution'],
+};
+
+async function main(argv) {
+  const { flags, positional } = parse(argv);
+  const [cmd, sub, ...rest] = positional;
+  // `trodo --version` alone is the CLI's version; `datasets export X --version 3` is a dataset's.
+  if (flags.version === true && !cmd) { process.stdout.write(`${pkg.version}\n`); return 0; }
+  if (!cmd || flags.help || cmd === 'help') { process.stdout.write(HELP); return 0; }
+  try {
+    if (COMMANDS[cmd]) {
+      const [mod, fn] = COMMANDS[cmd];
+      // eslint-disable-next-line global-require, import/no-dynamic-require
+      await require(`./commands/${mod}`)[fn]([sub, ...rest].filter(Boolean), flags);
+      return process.exitCode || 0;
+    }
+    if (!GROUPS[cmd]) throw Object.assign(new Error(`Unknown command "${cmd}". \`trodo help\` lists them.`), { exitCode: 2 });
+    const action = sub || 'list';
+    if (!GROUPS[cmd].includes(action)) throw Object.assign(new Error(`Unknown: trodo ${cmd} ${action}. Try: ${GROUPS[cmd].map((a) => `trodo ${cmd} ${a}`).join(', ')}`), { exitCode: 2 });
+    // eslint-disable-next-line global-require, import/no-dynamic-require
+    await require(`./commands/${cmd}`)[action](rest, flags);
+    return process.exitCode || 0;
+  } catch (e) {
+    const msg = e instanceof ApiError ? `${e.message}${e.status ? ` (HTTP ${e.status})` : ''}` : e.message;
+    process.stderr.write(`trodo: ${msg}\n`);
+    if (flags.json) process.stdout.write(`${JSON.stringify({ error: msg, status: e.status || null, detail: e.body || null })}\n`);
+    return e.exitCode || 1;
+  }
+}
+
+module.exports = { main, HELP };

package/lib/output.js

@@ -0,0 +1,50 @@
+'use strict';
+
+/**
+ * JSON by default (pretty on a terminal, one line when piped) so a coding
+ * agent can read every command; --table for a person.
+ */
+const fs = require('fs');
+
+function print(data, flags = {}, columns = null) {
+  if (flags.table && columns && Array.isArray(data)) return process.stdout.write(table(data, columns));
+  const pretty = process.stdout.isTTY && !flags.json;
+  return process.stdout.write(`${JSON.stringify(data, null, pretty ? 2 : 0)}\n`);
+}
+
+function table(rows, columns) {
+  const cell = (v) => (v == null ? '' : typeof v === 'object' ? JSON.stringify(v) : String(v)).replace(/\s+/g, ' ');
+  const cut = (s, w) => (s.length > w ? `${s.slice(0, w - 1)}…` : s);
+  const widths = columns.map(([key, label, max = 40]) => Math.min(max, Math.max(label.length, ...rows.map((r) => cell(r[key]).length))));
+  const line = (vals) => vals.map((v, i) => cut(v, widths[i]).padEnd(widths[i])).join('  ').trimEnd();
+  return `${[line(columns.map(([, label]) => label)), ...rows.map((r) => line(columns.map(([key]) => cell(r[key]))))].join('\n')}\n`;
+}
+
+/** Write lines to --out or stdout; returns { write(obj), close() }. */
+function sink(out) {
+  const stream = out ? fs.createWriteStream(out) : process.stdout;
+  return {
+    write: (obj) => new Promise((resolve) => { if (stream.write(`${JSON.stringify(obj)}\n`)) resolve(); else stream.once('drain', resolve); }),
+    close: () => new Promise((resolve) => { if (out) stream.end(resolve); else resolve(); }),
+  };
+}
+
+/** Read JSON lines (or one JSON array) from a file or stdin. */
+async function readRows(file) {
+  let text;
+  if (file && file !== '-') text = fs.readFileSync(file, 'utf8');
+  else {
+    if (process.stdin.isTTY) { const e = new Error('Give rows with -f rows.jsonl, or pipe them in.'); e.exitCode = 2; throw e; }
+    const chunks = [];
+    for await (const c of process.stdin) chunks.push(c);
+    text = Buffer.concat(chunks).toString('utf8');
+  }
+  const t = text.trim();
+  if (!t) return [];
+  if (t.startsWith('[')) return JSON.parse(t);
+  return t.split('\n').map((l) => l.trim()).filter(Boolean).map((l, i) => {
+    try { return JSON.parse(l); } catch (e) { const err = new Error(`line ${i + 1} is not JSON: ${e.message}`); err.exitCode = 2; throw err; }
+  });
+}
+
+module.exports = { print, table, sink, readRows };

package/package.json

@@ -1,6 +1,30 @@
 {
   "name": "trodo-cli",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.2.0",
+  "description": "Trodo from the terminal: pull traces by their eval results, build datasets, run labeling agents, export fine-tuning data",
+  "bin": {
+    "trodo": "bin/trodo.js"
+  },
+  "main": "./lib/main.js",
+  "files": [
+    "bin/",
+    "lib/",
+    "README.md"
+  ],
+  "scripts": {
+    "test": "node --test test/"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "keywords": [
+    "trodo",
+    "traces",
+    "datasets",
+    "fine-tuning",
+    "evals",
+    "cli",
+    "agents"
+  ],
+  "license": "ISC"
+}