trodo-cli 0.2.0 → 0.3.0

package/README.md

@@ -1,25 +1,34 @@
 # trodo-cli
 
-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.
+Trodo from the terminal, a script, CI or a coding agent: read and measure your
+agents' traces, see which eval step failed, triage and close issues, pull and
+push prompts, 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 setup claude                 # give Claude Code the Trodo skills
+
+trodo traces stats --since 7d --compare
+trodo runs list --since 24h --eval "any:failed" --table
+trodo runs tree RUN_ID
+trodo evals verdicts --run RUN_ID --table
+trodo conversations get CONVERSATION_ID --messages
+trodo issues list --status open,regression --table
+trodo prompts pull support-triage --label production -o prompt.json
+trodo prompts push support-triage -f prompt.json --message "why" --label staging
+
 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.
+`trodo help` lists every command and filter. Output is JSON (`--table` for a
+table, `--csv` for CSV; lists take `--all`). Exit codes: 0 ok, 1 API error, 2 usage.
+`trodo api GET /path` reaches any route of the CLI's API.
 
 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.
+Docs: https://docs.trodo.ai/platform/cli

package/lib/args.js

@@ -6,7 +6,7 @@
  * `--` 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']);
+const BOOLEAN = new Set(['help', 'json', 'table', 'live', 'include-trace', 'wait', 'yes', 'no-trace', 'no-browser', 'any-span', 'tree', 'messages', 'failed', 'passed', 'right', 'wrong', 'remove', 'compare', 'all', 'csv', 'global']);
 
 function parse(argv) {
   const flags = {};

package/lib/commands/agents.js

@@ -16,6 +16,13 @@ async function resolveAgent(api, ref) {
   return hit;
 }
 
+/** trodo agents get AGENT: the agent with its steps, trigger and published version. */
+async function getAgent([ref], flags) {
+  const api = client(config.resolve(flags));
+  const a = await resolveAgent(api, ref);
+  print(await api.get(`/agents/${a.id}`), flags);
+}
+
 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]]);
@@ -53,4 +60,4 @@ async function execution([id], flags) {
   print(await client(config.resolve(flags)).get(`/agents/executions/${encodeURIComponent(id)}`), flags);
 }
 
-module.exports = { list: listAgents, run, executions, execution };
+module.exports = { get: getAgent, list: listAgents, run, executions, execution };

package/lib/commands/api.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const fs = require('fs');
+const config = require('../config');
+const { client } = require('../http');
+const { print } = require('../output');
+const { usage } = require('../common');
+const { list: flagList } = require('../args');
+
+/**
+ * trodo api METHOD PATH [--param k=v …] [--data JSON | -f body.json]
+ * Any /api/v1 route with the signed-in key, for what no command covers yet.
+ * Reads are open; the server refuses any write that deletes, archives or replaces:
+ *   trodo api GET /runs/conversations --param q=alice
+ *   trodo api POST /datasets --data '{"name":"Scratch"}'
+ */
+async function call([method, path], flags) {
+  const m = String(method || '').toUpperCase();
+  if (!['GET', 'POST', 'PATCH', 'PUT', 'DELETE'].includes(m) || !path) throw usage('Usage: trodo api GET|POST|PATCH|PUT|DELETE /path [--param k=v] [--data JSON | -f body.json]');
+  const query = {};
+  for (const kv of flagList(flags.param)) {
+    const i = kv.indexOf('=');
+    if (i < 1) throw usage(`--param takes k=v, got "${kv}".`);
+    query[kv.slice(0, i)] = kv.slice(i + 1);
+  }
+  let body;
+  const raw = flags.data !== undefined && flags.data !== true ? String(flags.data) : (flags.file && flags.file !== true ? fs.readFileSync(String(flags.file), 'utf8') : null);
+  if (raw != null) { try { body = JSON.parse(raw); } catch (e) { throw usage(`The body is not JSON: ${e.message}`); } }
+  const p = String(path).startsWith('/') ? String(path) : `/${path}`;
+  const res = await client(config.resolve(flags)).raw(m, p, { query, body });
+  const text = await res.text();
+  let data; try { data = text ? JSON.parse(text) : null; } catch { data = text; }
+  if (!res.ok) { process.exitCode = 1; process.stderr.write(`trodo: HTTP ${res.status}\n`); }
+  if (typeof data === 'string') process.stdout.write(`${data}\n`); else print(data, flags);
+}
+
+module.exports = { call };

package/lib/commands/auth.js

@@ -86,22 +86,80 @@ async function login(_args, flags) {
   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`);
+  await adoptOldKey();
+  const before = config.teams().filter((t) => String(t.id) !== String(me.team.id));
+  const file = config.saveTeam({ id: me.team.id, name: me.team.name || String(me.team.id), key, url });
+  process.stderr.write(`Signed in to ${me.team.name} as ${me.user.email}. Saved to ${file}.${before.length ? ` Also signed in to ${before.map((t) => t.name).join(', ')}: \`trodo switch\` moves between them.` : ''}\n`);
   print({ team: me.team, scopes: me.key.scopes }, flags);
 }
 
+/**
+ * A 0.2 config held one key and no team: ask the server whose it is and put it
+ * in the list, so signing in to a second team keeps the first. Silent when the
+ * key no longer works (it is then simply dropped by the next login).
+ */
+async function adoptOldKey(keepCurrent = true) {
+  const cfg = config.read();
+  if (!cfg.api_key || (cfg.teams && Object.keys(cfg.teams).length)) return;
+  const url = String(cfg.api_url || config.DEFAULT_URL).replace(/\/+$/, '');
+  try {
+    const me = await client({ url, key: cfg.api_key }).get('/me');
+    const teams = { [String(me.team.id)]: { name: me.team.name || String(me.team.id), api_key: cfg.api_key, api_url: url } };
+    config.write({ api_url: url, current_team: keepCurrent ? String(me.team.id) : null, teams });
+  } catch { /* an old key that no longer works is not worth keeping */ }
+}
+
+/** trodo teams: the teams this terminal is signed in to; the current one is marked. */
+async function teams(_args, flags) {
+  await adoptOldKey();
+  const rows = config.teams().map(({ api_key: k, ...t }) => ({ ...t, current: t.current ? '*' : '' }));
+  if (!rows.length) {
+    const legacy = config.read().api_key;
+    process.stderr.write(legacy ? 'Signed in with one key from an older trodo; `trodo login` adds teams by name.\n' : 'Not signed in. `trodo login` adds a team.\n');
+  }
+  print(flags.table ? rows : rows.map((r) => ({ ...r, current: r.current === '*' })), flags, [['current', '', 1], ['name', 'Team', 40], ['id', 'Id', 8], ['api_url', 'Server', 30]]);
+}
+
+/** trodo switch TEAM: the team every command uses from now on (`--team` picks one for a single command). */
+async function switchTeam([ref], flags) {
+  if (!ref) { const e = new Error('Usage: trodo switch TEAM   (`trodo teams` lists them)'); e.exitCode = 2; throw e; }
+  await adoptOldKey();
+  const cfg = config.read();
+  const t = config.findTeam(cfg, ref);
+  if (!t) { const e = new Error(`Not signed in to a team called "${ref}". \`trodo teams\` lists yours; \`trodo login\` adds one.`); e.exitCode = 2; throw e; }
+  config.write({ ...cfg, current_team: t.id });
+  process.stderr.write(`Now on ${t.name}.\n`);
+  print({ team: { id: t.id, name: t.name } }, flags);
+}
+
 async function whoami(_args, flags) {
   print(await client(config.resolve(flags)).get('/me'), flags);
 }
 
-async function logout(_args, flags) {
+/**
+ * trodo logout [TEAM] [--all]: forget the current team's key (or TEAM's, or
+ * every one). The key itself stays valid until revoked in Settings → MCP.
+ */
+async function logout([ref], flags) {
   const cfg = config.read();
-  delete cfg.api_key;
-  config.write(cfg);
-  process.stderr.write('Removed the saved key.\n');
-  print({ ok: true }, flags);
+  const all = config.teams(cfg);
+  let removed = [];
+  if (flags.all || !all.length) {
+    removed = all.map((t) => t.name);
+    config.write({ api_url: cfg.api_url });
+  } else {
+    const t = ref ? config.findTeam(cfg, ref) : all.find((x) => x.current) || all[0];
+    if (!t) { const e = new Error(`Not signed in to a team called "${ref}".`); e.exitCode = 2; throw e; }
+    const rest = { ...cfg.teams };
+    delete rest[t.id];
+    const left = Object.keys(rest);
+    const current = String(cfg.current_team) === t.id ? (left[0] || null) : cfg.current_team;
+    config.write({ api_url: cfg.api_url, current_team: current, teams: rest });
+    removed = [t.name];
+    if (current && current !== cfg.current_team) process.stderr.write(`Now on ${rest[current].name || current}.\n`);
+  }
+  process.stderr.write(removed.length ? `Forgot the key for ${removed.join(', ')}.\n` : 'Removed the saved key.\n');
+  print({ ok: true, removed }, flags);
 }
 
-module.exports = { login, whoami, logout };
+module.exports = { login, whoami, logout, teams, switch: switchTeam };

package/lib/commands/conversations.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const config = require('../config');
+const { client } = require('../http');
+const { print } = require('../output');
+const { buildSpec } = require('./traces');
+const { windowOf } = require('./runs');
+const { usage, listQuery, pages, unitVerdicts } = require('../common');
+
+/**
+ * trodo conversations list [filter flags] [--search TEXT] [--limit 50] [--offset N]
+ * A conversation (a thread) matches when any of its runs does; eval conditions
+ * are decided for the whole conversation. --search matches the id or the user.
+ */
+async function list(_args, flags) {
+  const api = client(config.resolve(flags));
+  const spec = await buildSpec(api, flags, 'runs');
+  const q = listQuery(spec, windowOf);
+  if (flags.search && flags.search !== true) q.q = String(flags.search);
+  const rows = await pages(flags, async (limit, offset) => { const out = await api.get('/runs/conversations', { ...q, limit, offset }); return out.conversations || []; });
+  print(rows, flags, [['conversation_id', 'Conversation', 40], ['distinct_id', 'User', 26], ['run_count', 'Runs', 5], ['error_count', 'Errors', 6], ['last_run_at', 'Last run', 24]]);
+}
+
+/**
+ * trodo conversations get ID [--messages]: the thread, every run in it in order,
+ * and its evaluations. --messages prints the thread as user / assistant turns.
+ */
+async function get([id], flags) {
+  if (!id) throw usage('Usage: trodo conversations get CONVERSATION_ID [--messages]');
+  const api = client(config.resolve(flags));
+  const [detail, verdicts] = await Promise.all([
+    api.get(`/runs/conversations/${encodeURIComponent(id)}`),
+    api.get(`/eval3/units/conversation/${encodeURIComponent(id)}/verdicts`).catch(() => null),
+  ]);
+  if (flags.messages) {
+    const turns = [];
+    for (const r of detail.runs || []) {
+      const input = r.input ?? r.input_preview ?? null;
+      const output = r.output ?? r.output_preview ?? null;
+      if (input != null) turns.push({ role: 'user', content: input, run_id: r.run_id, at: r.started_at });
+      if (output != null) turns.push({ role: 'assistant', content: output, run_id: r.run_id, at: r.ended_at || r.started_at });
+    }
+    print({ conversation_id: id, messages: turns }, flags);
+    return;
+  }
+  print({ ...detail, evaluations: unitVerdicts(verdicts) }, flags);
+}
+
+module.exports = { list, get };

package/lib/commands/datasets.js

@@ -33,7 +33,7 @@ async function getDataset([ref], flags) {
 }
 
 /**
- * trodo datasets create NAME [--description D]
+ * trodo datasets create NAME [--description D] [-f rows.jsonl]
  *   [--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).
@@ -43,10 +43,13 @@ async function create([name], flags) {
   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;
+  // So is the file: read and parsed before the dataset exists.
+  const rows = flags.file && flags.file !== true ? await readRows(String(flags.file)) : 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);
+  const added = rows && rows.length ? await appendRows(api, dataset, rows, flags) : null;
+  print({ dataset: { id: dataset.id, name: dataset.name }, ...(source ? { source: source.source, run: source.feed } : {}), ...(added ? { rows: added } : {}) }, flags);
 }
 
 /** trodo datasets add DATASET --kind KIND <filter flags> [--live] [--include-trace]: another source. */
@@ -68,6 +71,11 @@ async function append([ref], flags) {
   const api = client(config.resolve(flags));
   const d = await resolveDataset(api, ref);
   const rows = await readRows(flags.file);
+  print({ dataset: d.name, ...(await appendRows(api, d, rows, flags)) }, flags);
+}
+
+/** Rows (plain or references to traffic) into dataset `d`; returns { written, skipped }. */
+async function appendRows(api, d, rows, flags) {
   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 = [];
@@ -97,7 +105,7 @@ async function append([ref], flags) {
     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);
+  return { written, skipped };
 }
 
 /**
@@ -171,4 +179,4 @@ async function versions([ref], flags) {
   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 };
+module.exports = { list: listDatasets, get: getDataset, create, add: addSource, append, update, export: exportDataset, rows: exportDataset, download: exportDataset, versions, resolveDataset, UUID };

package/lib/commands/evals.js

@@ -3,6 +3,7 @@
 const config = require('../config');
 const { client } = require('../http');
 const { print } = require('../output');
+const { usage, pick, int, unitVerdicts } = require('../common');
 
 /** trodo evals list: the names --eval takes, and each eval's steps (STEP.FIELD). */
 async function listEvals(_args, flags) {
@@ -14,4 +15,124 @@ async function listEvals(_args, flags) {
   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 };
+async function resolveEval(api, ref) {
+  const { evals } = await api.get('/evals');
+  return pick(evals || [], ref, { kind: 'eval', listCmd: 'trodo evals list' });
+}
+
+/** trodo evals get EVAL: the eval, its production version's graph and its 30-day stats. */
+async function getEval([ref], flags) {
+  const api = client(config.resolve(flags));
+  const e = await resolveEval(api, ref);
+  const [lineage, stats] = await Promise.all([
+    api.get(`/eval3/definitions/${e.id}`),
+    api.get(`/eval3/definitions/${e.id}/stats`).catch(() => null),
+  ]);
+  print({ ...lineage, steps: e.steps, stats: stats || undefined }, flags);
+}
+
+/** "7d" / "48h" / "30" → whole days for the verdict list (1-365). */
+function daysOf(since) {
+  if (since == null || since === true) return undefined;
+  const m = /^(\d+)\s*([hd]?)$/.exec(String(since).trim());
+  if (!m) throw usage('--since takes days or hours here: 7d, 48h, 30.');
+  const n = Number(m[1]);
+  return Math.min(365, Math.max(1, m[2] === 'h' ? Math.ceil(n / 24) : n));
+}
+
+/**
+ * trodo evals verdicts EVAL [--failed | --passed] [--since 7d] [--version N] [--limit 50] [--offset N]
+ * trodo evals verdicts --run RUN_ID | --span SPAN_ID | --conversation ID
+ * The eval's verdicts, newest first; or every eval's newest verdict on one unit.
+ */
+async function verdicts([ref], flags) {
+  const api = client(config.resolve(flags));
+  const unit = ['run', 'span', 'conversation'].find((k) => flags[k] && flags[k] !== true);
+  const cols = [['id', 'Verdict', 36], ['lineage_name', 'Eval', 34], ['passed', 'Passed', 6], ['score', 'Score', 6], ['reason_code', 'Reason', 22], ['created_at', 'At', 24]];
+  if (unit) {
+    const out = await api.get(`/eval3/units/${unit}/${encodeURIComponent(String(flags[unit]))}/verdicts`);
+    print(unitVerdicts(out), flags, cols);
+    return;
+  }
+  if (flags.failed && flags.passed) throw usage('Give --failed or --passed, not both.');
+  const e = await resolveEval(api, ref);
+  const q = {
+    limit: int(flags.limit, 50, 200),
+    offset: flags.offset,
+    days: daysOf(flags.since),
+    version: flags.version,
+    ...(flags.failed ? { passed: 'false' } : flags.passed ? { passed: 'true' } : {}),
+  };
+  const out = await api.get(`/eval3/definitions/${e.id}/runs`, q);
+  const rows = (out.runs || out.verdicts || []).map((r) => ({ lineage_name: e.name, ...r }));
+  print(flags.table ? rows : { eval: e.name, ...out }, flags, cols);
+}
+
+/** trodo evals verdict VERDICT_ID: one verdict, every step it took and why. */
+async function verdict([id], flags) {
+  if (!id) throw usage('Usage: trodo evals verdict VERDICT_ID');
+  print(await client(config.resolve(flags)).get(`/eval3/runs/${encodeURIComponent(id)}`), flags);
+}
+
+/**
+ * trodo evals mark VERDICT_ID --right
+ * trodo evals mark VERDICT_ID --wrong --should pass|fail --reason TEXT
+ * A person's thumbs on a verdict. A thumbs-down says what it should have been and
+ * why; it becomes that verdict row's Expected and feeds the eval's improvement.
+ */
+async function mark([id], flags) {
+  if (!id) throw usage('Usage: trodo evals mark VERDICT_ID --right | --wrong --should pass|fail --reason TEXT');
+  if (Boolean(flags.right) === Boolean(flags.wrong)) throw usage('Give --right or --wrong.');
+  const body = { source: 'v3', eval_run_id: String(id), thumbs: flags.right ? 'up' : 'down' };
+  if (flags.wrong) {
+    const should = String(flags.should || '');
+    if (!['pass', 'fail'].includes(should)) throw usage('--wrong needs --should pass or --should fail.');
+    if (!flags.reason || flags.reason === true) throw usage('--wrong needs --reason "why".');
+    body.corrected_passed = should === 'pass';
+    body.reason_text = String(flags.reason);
+  } else if (flags.reason && flags.reason !== true) body.reason_text = String(flags.reason);
+  print(await client(config.resolve(flags)).post('/eval3/feedback', body), flags);
+}
+
+/**
+ * trodo evals queue [--eval EVAL] [--graded] [--limit 50]
+ * Verdicts waiting on a person: an eval's human step stops there until someone
+ * picks one of its choices.
+ */
+async function queue(_a, flags) {
+  const api = client(config.resolve(flags));
+  const lineageId = flags.eval && flags.eval !== true ? (await resolveEval(api, flags.eval)).id : undefined;
+  const out = await api.get('/eval3/queue', { status: flags.graded ? 'graded' : 'open', lineage_id: lineageId, limit: int(flags.limit, 50, 200), offset: flags.offset });
+  print(out.items || out, flags, [['id', 'Item', 36], ['lineage_name', 'Eval', 34], ['node_id', 'Step', 22], ['status', 'Status', 8], ['created_at', 'Waiting since', 24]]);
+}
+
+/** trodo evals review ITEM_ID: one waiting item with the path the eval took to it. */
+async function review([id], flags) {
+  if (!id) throw usage('Usage: trodo evals review ITEM_ID');
+  print(await client(config.resolve(flags)).get(`/eval3/queue/${encodeURIComponent(id)}`), flags);
+}
+
+/** trodo evals grade ITEM_ID CHOICE: answer the human step; the eval carries on from there. */
+async function grade([id, choice], flags) {
+  if (!id || !choice) throw usage('Usage: trodo evals grade ITEM_ID CHOICE  (`trodo evals review ITEM_ID` lists the choices)');
+  print(await client(config.resolve(flags)).post(`/eval3/queue/${encodeURIComponent(id)}/grade`, { choice: String(choice) }), flags);
+}
+
+/**
+ * trodo evals steps EVAL [--since 30d] [--version N]
+ * The paths verdicts took through the eval's steps (its nodes), each with how
+ * many runs took it and how they came out: which step decides most failures.
+ */
+async function steps([ref], flags) {
+  const api = client(config.resolve(flags));
+  const e = await resolveEval(api, ref);
+  const out = await api.get(`/eval3/definitions/${e.id}/steps`, { days: daysOf(flags.since) || 30, version: flags.version });
+  if (flags.table) {
+    const rows = (out.paths || []).map((p) => ({ path: (p.names || p.path || []).join(' → '), runs: p.runs, share: p.share, passed: p.passed, failed: p.failed, errored: p.errored }));
+    print(rows, flags, [['path', 'Path through the steps', 90], ['runs', 'Runs', 6], ['share', 'Share', 6], ['passed', 'Passed', 6], ['failed', 'Failed', 6], ['errored', 'Errored', 7]]);
+    return;
+  }
+  print({ eval: e.name, steps: e.steps, ...out }, flags);
+}
+
+module.exports = { list: listEvals, get: getEval, verdicts, verdict, mark, queue, review, grade, steps, daysOf };

package/lib/commands/issues.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const config = require('../config');
+const { client } = require('../http');
+const { print } = require('../output');
+const { usage, int } = require('../common');
+
+const csv = (v) => (v === undefined || v === true ? undefined : [].concat(v).join(','));
+
+/** trodo issues list [--status open,regression,closed] [--agent NAME] [--search TEXT] [--limit 50] */
+async function list(_a, flags) {
+  const out = await client(config.resolve(flags)).get('/issues', {
+    status: csv(flags.status), agent: csv(flags.agent), search: flags.search !== true ? flags.search : undefined,
+    limit: int(flags.limit, 50, 200), offset: flags.offset,
+  });
+  print(out.issues || out, flags, [['id', 'Id', 6], ['status', 'Status', 10], ['agent_name', 'Agent', 28], ['title', 'Issue', 60], ['evidence_count', 'Evidence', 8], ['last_seen_at', 'Last seen', 24]]);
+}
+
+/** trodo issues get ID: the issue, its evidence (runs, spans, conversations) and its timeline. */
+async function get([id], flags) {
+  if (!id) throw usage('Usage: trodo issues get ISSUE_ID');
+  print(await client(config.resolve(flags)).get(`/issues/${encodeURIComponent(id)}`), flags);
+}
+
+/** trodo issues failures ID: the recorded inputs of every failure, to replay against a fix. */
+async function failures([id], flags) {
+  if (!id) throw usage('Usage: trodo issues failures ISSUE_ID');
+  print(await client(config.resolve(flags)).get(`/issues/${encodeURIComponent(id)}/failures`, { limit: flags.limit, cursor: flags.cursor !== true ? flags.cursor : undefined }), flags);
+}
+
+async function setStatus(id, status, flags) {
+  if (!id) throw usage(`Usage: trodo issues ${status === 'closed' ? 'close' : 'reopen'} ISSUE_ID`);
+  print(await client(config.resolve(flags)).post(`/issues/${encodeURIComponent(id)}/status`, { status }), flags);
+}
+
+/** trodo issues close ID: closed; a new failure of the same kind reopens it as a regression. */
+const close = ([id], flags) => setStatus(id, 'closed', flags);
+const reopen = ([id], flags) => setStatus(id, 'open', flags);
+
+module.exports = { list, get, failures, close, reopen };

package/lib/commands/prompts.js

@@ -0,0 +1,125 @@
+'use strict';
+
+const fs = require('fs');
+const config = require('../config');
+const { client } = require('../http');
+const { print } = require('../output');
+const { usage, pick } = require('../common');
+
+/** What a prompt version is, without who saved it: what `pull` writes and `push` reads. */
+const CONTENT_KEYS = ['messages', 'model', 'tools', 'response_format', 'variables'];
+
+/** A refusal to edit, said as what to do about it. */
+async function editing(prompt, fn) {
+  try { return await fn(); } catch (e) {
+    if (e && e.status === 403 && e.body && e.body.error === 'forbidden_edit') {
+      throw Object.assign(new Error(`You can't change "${prompt}": only its owner and the editors they add can. Ask the owner to add you (prompt page → Editors).`), { exitCode: 1 });
+    }
+    throw e;
+  }
+}
+
+async function resolvePrompt(api, ref) {
+  const { prompts } = await api.get('/prompts');
+  const hit = pick(prompts || [], ref, { kind: 'prompt', listCmd: 'trodo prompts list' });
+  const { prompt } = await api.get(`/prompts/${hit.id}`);
+  return prompt;
+}
+
+/** The version a --version N or --label L names; the newest one otherwise. */
+function versionOf(prompt, flags) {
+  const versions = prompt.versions || [];
+  if (flags.version !== undefined && flags.version !== true) {
+    const v = versions.find((x) => String(x.version_no) === String(flags.version));
+    if (!v) throw usage(`"${prompt.name}" has no version ${flags.version}. \`trodo prompts versions "${prompt.name}"\` lists them.`);
+    return v;
+  }
+  if (flags.label !== undefined && flags.label !== true) {
+    const v = versions.find((x) => (x.labels || []).includes(String(flags.label)));
+    if (!v) throw usage(`No version of "${prompt.name}" has the label "${flags.label}".`);
+    return v;
+  }
+  return versions.reduce((a, b) => (!a || Number(b.version_no) > Number(a.version_no) ? b : a), null);
+}
+
+async function list(_a, flags) {
+  const { prompts } = await client(config.resolve(flags)).get('/prompts', { label: flags.label !== true ? flags.label : undefined, tag: flags.tag !== true ? flags.tag : undefined });
+  print(prompts || [], flags, [['name', 'Prompt', 36], ['current_version', 'Version', 8], ['labels', 'Labels', 24], ['id', 'Id', 36], ['updated_at', 'Updated', 24]]);
+}
+
+/** trodo prompts get PROMPT [--version N | --label production]: one version, whole. */
+async function get([ref], flags) {
+  const prompt = await resolvePrompt(client(config.resolve(flags)), ref);
+  const v = versionOf(prompt, flags);
+  print({ id: prompt.id, name: prompt.name, description: prompt.description, tags: prompt.tags, version: v }, flags);
+}
+
+async function versions([ref], flags) {
+  const prompt = await resolvePrompt(client(config.resolve(flags)), ref);
+  const rows = (prompt.versions || []).map((v) => ({ version_no: v.version_no, labels: v.labels, commit_message: v.commit_message, created_by: v.created_by_email, created_at: v.created_at, content_hash: v.content_hash }));
+  print(rows, flags, [['version_no', 'v', 4], ['labels', 'Labels', 22], ['commit_message', 'Message', 44], ['created_by', 'By', 24], ['created_at', 'At', 24]]);
+}
+
+/** trodo prompts pull PROMPT [--version N | --label L] [-o prompt.json]: the content to edit and push back. */
+async function pull([ref], flags) {
+  const prompt = await resolvePrompt(client(config.resolve(flags)), ref);
+  const v = versionOf(prompt, flags);
+  const out = { name: prompt.name, version_no: v.version_no };
+  for (const k of CONTENT_KEYS) out[k] = v[k];
+  if (flags.out && flags.out !== true) {
+    fs.writeFileSync(String(flags.out), `${JSON.stringify(out, null, 2)}\n`);
+    process.stderr.write(`${prompt.name} v${v.version_no} → ${flags.out}\n`);
+    return;
+  }
+  print(out, flags);
+}
+
+/**
+ * trodo prompts push PROMPT -f prompt.json [--message "why"] [--label staging]
+ * A new version from a file `pull` wrote (or any { messages, model?, tools?,
+ * variables? }). The prompt is made when no prompt has that name. Content equal
+ * to the newest version cuts no version.
+ */
+async function push([ref], flags) {
+  const file = flags.file;
+  if (!file || file === true) throw usage('Usage: trodo prompts push PROMPT -f prompt.json [--message "why"] [--label staging]');
+  let content;
+  try { content = JSON.parse(fs.readFileSync(String(file), 'utf8')); } catch (e) { throw usage(`${file} is not a JSON prompt: ${e.message}`); }
+  if (!Array.isArray(content.messages) || !content.messages.length) throw usage(`${file} has no messages.`);
+  const api = client(config.resolve(flags));
+  const name = ref && ref !== true ? String(ref) : content.name;
+  if (!name) throw usage('Name the prompt.');
+  const { prompts } = await api.get('/prompts');
+  let target = (prompts || []).find((p) => p.id === name || p.name === name);
+  let created = false;
+  if (!target) {
+    const made = await api.post('/prompts', { name, ...(content.description ? { description: content.description } : {}) });
+    target = made.prompt || made;
+    created = true;
+  }
+  const body = { messages: content.messages };
+  for (const k of ['model', 'tools', 'response_format', 'variables']) if (content[k] !== undefined) body[k] = content[k];
+  if (flags.message && flags.message !== true) body.commit_message = String(flags.message);
+  if (flags.label && flags.label !== true) body.labels = [].concat(flags.label).map(String);
+  const out = await editing(name, () => api.post(`/prompts/${target.id}/versions`, body));
+  const v = out.version || {};
+  print({ prompt: name, id: target.id, created, version_no: v.version_no, labels: v.labels, unchanged: Boolean(out.unchanged) }, flags);
+}
+
+/**
+ * trodo prompts label PROMPT VERSION LABEL [--remove]
+ * Moves LABEL (say production) to VERSION. Agents that fetch the prompt by that
+ * label run the new version from their next call.
+ */
+async function label([ref, versionNo, name], flags) {
+  if (!ref || !versionNo || !name) throw usage('Usage: trodo prompts label PROMPT VERSION LABEL [--remove]');
+  const api = client(config.resolve(flags));
+  const prompt = await resolvePrompt(api, ref);
+  const v = versionOf(prompt, { version: versionNo });
+  const out = await editing(prompt.name, () => (flags.remove
+    ? api.del(`/prompts/${prompt.id}/versions/${v.version_no}/label/${encodeURIComponent(String(name))}`)
+    : api.post(`/prompts/${prompt.id}/versions/${v.version_no}/label`, { label: String(name) })));
+  print({ prompt: prompt.name, version_no: v.version_no, ...(out.version ? { labels: out.version.labels } : out) }, flags);
+}
+
+module.exports = { list, get, versions, pull, push, label };