fix(cli): make tables rows query show the rows

Three things stacked up so the command appeared to do nothing.

A row's cells live under `data`, and column inference skips object-valued
fields — so the table came back listing an id and two timestamps per row and
none of the content the query was run for. `expand` names the wrapper whose
keys become columns, unioned across the page like the top-level ones. A cell
key that shadows a top-level field is shown by its full path, so two different
values never share a header.

A cell containing a newline pushed the rest of its row onto the next line and
every column after it lost alignment; in text mode a tab invented a field that
`cut -f` reads as real. Display cells are now flattened to one line. `sanitize`
still keeps \t and \n — json and yaml must round-trip them, and this is applied
only to finished cells.

A single cell holding an LLM response set the column width for the whole table
and pushed everything after it off-screen, so table cells clamp at 60 columns.
text/json/yaml are untouched: those exist for the whole value.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0148a65fkPhP4N8tgGPYtRTU

Author: TheodoreSpeaks

packages/sim-cli/src/contract/commands.ts

@@ -98,6 +98,9 @@ export const CLI_CONTRACT: CliContract = {
   queryRows: {
     command: 'tables rows query',
     flags: { predicate: { name: 'filter', json: true }, sort: { json: true } },
+    // A row's cells live under `data`; without this the table showed an id and
+    // two timestamps per row and none of the content anyone ran the query for.
+    expand: 'data',
   },
 
   // ─── Output columns for list commands ─────────────────────────────────────

packages/sim-cli/src/contract/types.ts

@@ -84,6 +84,16 @@ export interface CommandSpec {
    * the point is that the caller can tell whether they meant it.
    */
   confirm?: string
+  /**
+   * Discover table columns from inside this nested field as well as from the
+   * row's own scalars.
+   *
+   * For rows whose real content sits in a wrapper the server chose — a table
+   * row's user-defined cells live under `data` — the inferred columns would
+   * otherwise be `id` and two timestamps, because a nested object cannot be a
+   * column. Only meaningful when `columns` is absent.
+   */
+  expand?: string
   /**
    * The response IS a document, not a record to look at.
    *

packages/sim-cli/src/output/render.test.ts

@@ -259,3 +259,61 @@ describe('sanitize', () => {
     expect(timestamp('2026-07-31T09:14:22.500Z')).toBe('2026-07-31 09:14:22')
   })
 })
+
+describe('cells stay on their own line', () => {
+  const rows = [{ note: 'first\nsecond', tabbed: 'a\tb' }]
+  const columns: Column<(typeof rows)[number]>[] = [
+    { header: 'note', value: (row) => row.note },
+    { header: 'tabbed', value: (row) => row.tabbed },
+  ]
+
+  function captured(format: 'table' | 'text' | 'json'): string[] {
+    const lines: string[] = []
+    const spy = vi.spyOn(console, 'log').mockImplementation((line: string) => {
+      lines.push(line)
+    })
+    printList(format, rows, columns)
+    spy.mockRestore()
+    return lines
+  }
+
+  it('collapses a newline inside a table cell', () => {
+    // One newline pushed the rest of the row onto the next line and every
+    // column after it lost its alignment.
+    const table = captured('table').join('\n')
+    expect(table.split('\n')).toHaveLength(2)
+    expect(table).toContain('first second')
+  })
+
+  it('collapses a tab in text mode, so cut -f still sees real fields', () => {
+    const [line] = captured('text')
+    expect(line.split('\t')).toHaveLength(2)
+    expect(line).toBe('first second\ta b')
+  })
+
+  it('leaves json untouched', () => {
+    expect(JSON.parse(captured('json').join('\n'))).toEqual([
+      { note: 'first\nsecond', tabbed: 'a\tb' },
+    ])
+  })
+
+  it('clamps a very wide cell in table mode only', () => {
+    const wide = [{ blob: 'x'.repeat(500) }]
+    const cols: Column<(typeof wide)[number]>[] = [{ header: 'blob', value: (row) => row.blob }]
+    const lines: string[] = []
+    const spy = vi.spyOn(console, 'log').mockImplementation((line: string) => {
+      lines.push(line)
+    })
+    printList('table', wide, cols)
+    printList('text', wide, cols)
+    spy.mockRestore()
+
+    // The table arrives as one string: header line, then the clamped body line.
+    const [header, body] = lines[0].split('\n')
+    expect(header.trim()).toBe('BLOB')
+    expect(body).toMatch(/…$/)
+    expect(body.length).toBeLessThan(100)
+    // `text` feeds pipelines; truncating there would corrupt the data.
+    expect(lines[1]).toHaveLength(500)
+  })
+})

packages/sim-cli/src/output/render.ts

@@ -131,14 +131,49 @@ function pad(value: string, width: number): string {
   return value + ' '.repeat(Math.max(0, width - visibleWidth(value)))
 }
 
+/**
+ * Flattens a cell onto one line.
+ *
+ * `sanitize` keeps `\t` and `\n` on purpose — they are legitimate content, and
+ * json/yaml must round-trip them. Every *display* format is line-oriented
+ * though: one newline inside a table cell pushes the rest of the row into the
+ * next line and every column after it loses its alignment, and in `text` mode a
+ * stray tab invents a field that `cut -f` then reads as real. A table row of a
+ * workflow's Slack output did exactly this.
+ *
+ * Applied to finished cells only, so it cannot reach the machine formats.
+ */
+function oneLine(value: string): string {
+  return value.replace(/\s*[\r\n\t]+\s*/g, ' ')
+}
+
+/**
+ * Widest a single table column may render.
+ *
+ * A table row can hold a whole LLM response; at full width one such cell sets
+ * the column width for every row and pushes everything after it off-screen.
+ * `text`, `json` and `yaml` are untouched — this is a legibility cap on the
+ * human view, and the other three formats exist for the whole value.
+ */
+const MAX_CELL_WIDTH = 60
+
+function clampCell(value: string): string {
+  // ANSI-bearing cells come from the short formatters (`yes`/`no`, the empty
+  // glyph); slicing one mid-escape would corrupt it, and none are ever wide.
+  if (visibleWidth(value) <= MAX_CELL_WIDTH || value !== value.replace(ANSI_PATTERN, '')) {
+    return value
+  }
+  return `${value.slice(0, MAX_CELL_WIDTH - 1)}…`
+}
+
 function renderTable<T>(rows: T[], columns: Column<T>[]): string {
   if (rows.length === 0) return chalk.dim('No results.')
 
   // A header can be a user-defined column name (a table's own columns), so it is
   // remote content and gets the same treatment as a cell. Doing it here rather
   // than only at each call site means a future column source cannot reopen this.
   const headers = columns.map((column) => sanitize(column.header))
-  const cells = rows.map((row) => columns.map((column) => column.value(row)))
+  const cells = rows.map((row) => columns.map((column) => clampCell(oneLine(column.value(row)))))
   const widths = columns.map((_column, index) =>
     Math.max(visibleWidth(headers[index]), ...cells.map((line) => visibleWidth(line[index])))
   )
@@ -193,7 +228,7 @@ export function printList<T>(format: OutputFormat, rows: T[], columns: Column<T>
 
   if (format === 'text') {
     for (const row of rows) {
-      console.log(columns.map((column) => stripAnsi(column.value(row))).join('\t'))
+      console.log(columns.map((column) => oneLine(stripAnsi(column.value(row)))).join('\t'))
     }
     return
   }
@@ -226,13 +261,13 @@ export function printRecord(format: OutputFormat, fields: Array<[string, string]
 
   if (format === 'text') {
     for (const [label, value] of fields) {
-      console.log(`${label}\t${stripAnsi(value)}`)
+      console.log(`${label}\t${oneLine(stripAnsi(value))}`)
     }
     return
   }
 
   const width = Math.max(...fields.map(([label]) => label.length))
   for (const [label, value] of fields) {
-    console.log(`${chalk.dim(pad(`${label}:`, width + 1))}  ${value}`)
+    console.log(`${chalk.dim(pad(`${label}:`, width + 1))}  ${oneLine(value)}`)
   }
 }

packages/sim-cli/src/runtime/build.test.ts

@@ -243,3 +243,30 @@ describe('pagination slot', () => {
     expect(mockRequest.mock.calls[1][1].query).toMatchObject({ cursor: 'c1' })
   })
 })
+
+describe('rows whose content sits in a wrapper', () => {
+  it('discovers columns from the expanded field', async () => {
+    // `tables rows query` returned a table of ids and timestamps: a row's cells
+    // live under `data`, and column inference skipped it for being an object.
+    mockRequest.mockReset()
+    mockRequest.mockResolvedValue({
+      data: [
+        { id: 'r1', data: { url: 'https://a', title: 'A' }, createdAt: 'now' },
+        { id: 'r2', data: { url: 'https://b', extra: 'E' }, createdAt: 'now' },
+      ],
+      nextCursor: null,
+    })
+    const lines: string[] = []
+    output.format = 'text'
+    vi.spyOn(console, 'log').mockImplementation((line: string) => {
+      lines.push(line)
+    })
+    await program().parseAsync(['node', 'sim', 'tables', 'rows', 'query', 'tbl_1'])
+    output.format = 'json'
+
+    // Unioned across the page: `extra` appears only on the second row.
+    expect(lines[0]).toContain('https://a')
+    expect(lines[0]).toContain('A')
+    expect(lines[1]).toContain('E')
+  })
+})

packages/sim-cli/src/runtime/build.ts

@@ -89,10 +89,12 @@ function columnsFrom(specs: ColumnSpec[]): Column<unknown>[] {
  * Row shapes are only known at runtime here — a table's `data` is user-defined —
  * so the keys are unioned across the page rather than read off the first row,
  * which would let a sparse row hide every column it happens to omit. Nested
- * values are skipped: they render as JSON blobs and make the table unreadable.
+ * values are skipped: they render as JSON blobs and make the table unreadable —
+ * unless the contract names one with `expand`, which is how a row's cells reach
+ * the table.
  */
-function inferColumns(rows: unknown[]): Column<unknown>[] {
-  const keys: string[] = []
+function inferColumns(rows: unknown[], expand?: string): Column<unknown>[] {
+  const paths: Array<{ path: string; header: string }> = []
   const seen = new Set<string>()
 
   for (const row of rows) {
@@ -101,16 +103,34 @@ function inferColumns(rows: unknown[]): Column<unknown>[] {
       if (seen.has(key)) continue
       if (value !== null && typeof value === 'object') continue
       seen.add(key)
-      keys.push(key)
+      paths.push({ path: key, header: key })
     }
   }
 
-  return keys.map((key) => ({
+  // The wrapper named by `expand` holds the only content the caller cares about;
+  // the loop above skipped it for being an object, which is how `tables rows
+  // query` came back showing nothing but ids and timestamps.
+  if (expand) {
+    const nested = new Set<string>()
+    for (const row of rows) {
+      const container = at(row, expand)
+      if (!container || typeof container !== 'object' || Array.isArray(container)) continue
+      for (const key of Object.keys(container)) {
+        if (nested.has(key)) continue
+        nested.add(key)
+        // A user-defined key that shadows a top-level one is shown by its full
+        // path, so two different values never appear under one header.
+        paths.push({ path: `${expand}.${key}`, header: seen.has(key) ? `${expand}.${key}` : key })
+      }
+    }
+  }
+
+  return paths.map(({ path, header }) => ({
     // The key itself is remote data when the rows are user-defined, and the
     // header is printed just like a cell — sanitizing values but not headers
     // left the same control sequences executable one row higher.
-    header: sanitize(key),
-    value: (row: unknown) => renderCell(at(row, key), 'auto'),
+    header: sanitize(header),
+    value: (row: unknown) => renderCell(at(row, path), 'auto'),
   }))
 }
 
@@ -297,7 +317,11 @@ function buildLeaf(operation: V2OperationName, spec: CommandSpec, leafName: stri
       } while (cursor && rows.length < limit)
 
       const page = Number.isFinite(limit) ? rows.slice(0, limit) : rows
-      printList(profile.output, page, spec.columns ? columnsFrom(spec.columns) : inferColumns(page))
+      printList(
+        profile.output,
+        page,
+        spec.columns ? columnsFrom(spec.columns) : inferColumns(page, spec.expand)
+      )
       return
     }
 
@@ -318,7 +342,11 @@ function buildLeaf(operation: V2OperationName, spec: CommandSpec, leafName: stri
     if (Array.isArray(data)) {
       // Reached when a non-paginated operation answers with a collection.
       // `printRecord` would silently print nothing for an array.
-      printList(profile.output, data, spec.columns ? columnsFrom(spec.columns) : inferColumns(data))
+      printList(
+        profile.output,
+        data,
+        spec.columns ? columnsFrom(spec.columns) : inferColumns(data, spec.expand)
+      )
       return
     }