feat(cli): default tables import to a new table named after the file

`sim tables import people.csv` now does the obvious thing rather than
demanding a target. Requiring one guarded the wrong direction: a forgotten
flag creating a new table is visible and easily undone, while the outcome
worth protecting — writing into an existing table — is the one that now has
to be asked for by name.

--to-table becomes --table-id, and --mode/--mapping/--create-columns apply
only alongside it. Passing one without it is an error rather than a no-op:
silently ignoring `--mode replace` would let it read as honoured while a new
table was created beside the one it was meant to overwrite. The reverse is
also refused, since --table-id already names the destination.

The derived name is sanitized, because table names are identifiers: the
obvious basename would reject most real files, so `2026-quarterly sales.csv`
imports as `_2026_quarterly_sales` instead of failing. --name overrides it,
and is required for --file-id, where there is no file name to take one from.

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/commands/hand-written.test.ts

@@ -84,31 +84,35 @@ describe('tables import argument guards', () => {
     await importCommand().parseAsync(['node', 'sim', 'tables', 'import', ...argv])
   }
 
-  it('refuses to guess the target', async () => {
-    // Defaulting to a new table would turn a forgotten `--to-table` into a
-    // silent second copy of the data.
-    await expect(run(['f.csv'])).rejects.toThrow(/exactly one of --new-table/)
-    await expect(run(['f.csv', '--new-table', 'a', '--to-table', 't'])).rejects.toThrow(
-      /exactly one of --new-table/
-    )
+  it('refuses to guess the source', async () => {
+    // A new table is a safe default; where the bytes are is not inferable.
+    await expect(run([])).rejects.toThrow(/exactly one of <path>/)
+    await expect(run(['f.csv', '--file-id', 'w_1'])).rejects.toThrow(/exactly one of <path>/)
   })
 
-  it('refuses to guess the source', async () => {
-    await expect(run(['--new-table', 'a'])).rejects.toThrow(/exactly one of <path>/)
-    await expect(run(['f.csv', '--new-table', 'a', '--file-id', 'w_1'])).rejects.toThrow(
-      /exactly one of <path>/
-    )
+  it('rejects existing-table flags when creating one', async () => {
+    // Ignoring these would let `--mode replace` read as honoured while a new
+    // table is created beside the one it was meant to overwrite.
+    await expect(run(['f.csv', '--mode', 'replace'])).rejects.toThrow(/applies to --table-id/)
+    await expect(run(['f.csv', '--mapping', '{}'])).rejects.toThrow(/applies to --table-id/)
+    await expect(run(['f.csv', '--create-columns', '{}'])).rejects.toThrow(/applies to --table-id/)
   })
 
-  it('names the flag when mapping is paired with a new table', async () => {
-    // The server rejects this too, but as a message about the request body.
-    await expect(run(['f.csv', '--new-table', 'a', '--mapping', '{}'])).rejects.toThrow(
-      /--to-table only/
+  it('rejects new-table flags when importing into an existing one', async () => {
+    await expect(run(['f.csv', '--table-id', 't', '--name', 'x'])).rejects.toThrow(
+      /--table-id already names the destination/
     )
+    await expect(run(['f.csv', '--table-id', 't', '--folder-id', 'f'])).rejects.toThrow(
+      /--table-id already names the destination/
+    )
+  })
+
+  it('asks for a name when there is no file name to take one from', async () => {
+    await expect(run(['--file-id', 'w_1'])).rejects.toThrow(/--name <name>/)
   })
 
   it('checks all of that before touching the filesystem', async () => {
     // `f.csv` does not exist; a "cannot read" error would mean a guard ran late.
-    await expect(run(['f.csv'])).rejects.toThrow(/exactly one of/)
+    await expect(run(['f.csv', '--mode', 'append'])).rejects.toThrow(/applies to --table-id/)
   })
 })

packages/sim-cli/src/commands/hand-written.ts

@@ -294,9 +294,9 @@ interface TableImport {
 }
 
 interface ImportOptions {
-  newTable?: string
-  toTable?: string
-  mode: string
+  name?: string
+  tableId?: string
+  mode?: string
   folderId?: string
   fileId?: string
   mapping?: string
@@ -306,6 +306,22 @@ interface ImportOptions {
   wait: boolean
 }
 
+/**
+ * Turns a file name into a legal table name.
+ *
+ * Table names are identifiers — `^[A-Za-z_][A-Za-z0-9_]*$`, 128 max — so the
+ * obvious `basename(path)` would reject most real files: `2026-sales.csv` and
+ * `customer data.csv` both fail. Runs of anything else collapse to a single
+ * underscore, and a leading digit gets one in front, so a default derived from
+ * the file is a name the server actually accepts.
+ */
+function tableNameFrom(fileName: string): string {
+  const stem = fileName.replace(/\.[^.]+$/, '')
+  const cleaned = stem.replace(/[^A-Za-z0-9]+/g, '_').replace(/^_+|_+$/g, '')
+  if (!cleaned) return 'imported_table'
+  return (/^[0-9]/.test(cleaned) ? `_${cleaned}` : cleaned).slice(0, 128)
+}
+
 /** How often to ask an in-progress import where it got to. */
 const IMPORT_POLL_MS = 1500
 
@@ -414,37 +430,49 @@ export function attachHandWritten(program: Command): void {
     )
 
   // ── tables import ── a transfer, then an async job to watch ──────────────
-  const tablesGroup = group(program, 'tables')
-  tablesGroup
+  group(program, 'tables')
     .command('import [path]')
-    .description('Import a CSV into a new or existing table')
-    .option('--new-table <name>', 'Create a table with this name')
-    .option('--to-table <tableId>', 'Import into an existing table')
-    .option('--mode <append|replace>', 'How to write into an existing table', 'append')
-    .option('--folder-id <id>', 'Folder for a new table')
+    .description('Import a CSV, into a new table by default')
+    .option('--name <name>', 'Name for the new table (defaults to the file name)')
+    .option('--table-id <id>', 'Import into this existing table instead of creating one')
+    .option('--mode <append|replace>', 'How to write into --table-id (default: append)')
+    .option('--folder-id <id>', 'Folder for the new table')
     .option('--file-id <id>', 'Import a file already in the workspace instead of a local path')
-    .option('--mapping <json|@file>', 'Column mapping (existing table only)')
-    .option('--create-columns <json|@file>', 'Columns to create (existing table only)')
+    .option('--mapping <json|@file>', 'Column mapping (--table-id only)')
+    .option('--create-columns <json|@file>', 'Columns to create (--table-id only)')
     .option('--timezone <iana>', 'Timezone for date parsing, e.g. America/New_York')
     .option('--no-wait', 'Return once the import is queued instead of watching it')
     .action(async (path: string | undefined, options: ImportOptions, command: Command) => {
       const { client } = clientFrom(command)
       const workspaceId = client.requireWorkspace()
 
-      // Both target choices are stated, never inferred. Defaulting to a new
-      // table would turn a forgotten `--to-table` into a second copy of the
-      // data, which is not something to discover afterwards.
-      if (Boolean(options.newTable) === Boolean(options.toTable)) {
-        throw new SimApiError('Pass exactly one of --new-table <name> or --to-table <id>', 0)
-      }
+      // The one thing that cannot be inferred: the bytes are either local or
+      // already in the workspace, and neither implies the other.
       if (Boolean(path) === Boolean(options.fileId)) {
         throw new SimApiError('Pass exactly one of <path> or --file-id <id>', 0)
       }
-      // The server rejects these against a new table; saying so here names the
-      // flag rather than returning a validation error about the request body.
-      if (options.newTable && (options.mapping || options.createColumns)) {
+
+      const intoExisting = Boolean(options.tableId)
+
+      // Flags that only mean something for one target. Silently ignoring them
+      // would let `--mode replace` read as honoured while a new table is
+      // created beside the one it was meant to overwrite.
+      const misplaced = intoExisting
+        ? ([
+            ['--name', options.name],
+            ['--folder-id', options.folderId],
+          ] as const)
+        : ([
+            ['--mode', options.mode],
+            ['--mapping', options.mapping],
+            ['--create-columns', options.createColumns],
+          ] as const)
+      for (const [flag, value] of misplaced) {
+        if (value === undefined) continue
         throw new SimApiError(
-          '--mapping and --create-columns apply to --to-table only: a new table takes its columns from the CSV',
+          intoExisting
+            ? `${flag} applies to a new table; --table-id already names the destination`
+            : `${flag} applies to --table-id: a new table takes its name and columns from the CSV`,
           0
         )
       }
@@ -459,13 +487,18 @@ export function attachHandWritten(program: Command): void {
           }
         : { type: 'workspace_file', fileId: options.fileId }
 
-      const target = options.toTable
-        ? { type: 'existing', tableId: options.toTable, mode: options.mode }
-        : {
-            type: 'new',
-            name: options.newTable,
-            ...(options.folderId ? { folderId: options.folderId } : {}),
-          }
+      let target: Record<string, unknown>
+      if (intoExisting) {
+        target = { type: 'existing', tableId: options.tableId, mode: options.mode ?? 'append' }
+      } else {
+        // A local file names the table; a workspace file id does not, and
+        // guessing one from an id would produce nonsense.
+        const name = options.name ?? (local ? tableNameFrom(local.name) : undefined)
+        if (!name) {
+          throw new SimApiError('Pass --name <name> to say what the new table is called', 0)
+        }
+        target = { type: 'new', name, ...(options.folderId ? { folderId: options.folderId } : {}) }
+      }
 
       const started = await client.request<{ data: TableImport }>('/api/v2/tables/imports', {
         method: 'POST',