biblioplex 0.1.1 → 0.2.1

package/src/cli.mjs

@@ -1,14 +1,17 @@
 import { parseArgs, boolFlag, strFlag } from './args.mjs';
 import { createOutput } from './output.mjs';
 import { CliError } from './errors.mjs';
-import { EXIT, VERSION, DEFAULT_API_BASE } from './constants.mjs';
-import { loadCredentials, saveCredentials, loadConfig } from './store.mjs';
-import { Session } from './api.mjs';
+import { EXIT, VERSION, DEFAULT_API_ORIGIN } from './constants.mjs';
+import { loadConfig } from './store.mjs';
 import { commands, commandOrder } from './commands/index.mjs';
 
-function resolveApiBase(flags) {
-  const base = strFlag(flags, 'api') || process.env.BIBLIOPLEX_API_BASE || loadConfig().apiBase || DEFAULT_API_BASE;
-  return base.replace(/\/+$/, '');
+function resolveApiOrigin(flags) {
+  const origin =
+    strFlag(flags, 'api') ||
+    process.env.BIBLIOPLEX_API_ORIGIN ||
+    loadConfig().apiOrigin ||
+    DEFAULT_API_ORIGIN;
+  return origin.replace(/\/+$/, '');
 }
 
 function printHelp(out) {
@@ -16,19 +19,22 @@ function printHelp(out) {
   out.line('');
   out.line('usage: bp <command> [options]');
   out.line('');
-  out.line('commands:');
-  for (const name of commandOrder) {
-    out.line('  ' + name.padEnd(12) + commands[name].summary);
+  if (commandOrder.length) {
+    out.line('commands:');
+    for (const name of commandOrder) {
+      out.line('  ' + name.padEnd(12) + commands[name].summary);
+    }
+    out.line('');
   }
-  out.line('');
   out.line('global options:');
-  out.line('  --json        machine-readable output ({ok,data}|{ok,error})');
-  out.line('  --no-color    disable colored output');
-  out.line('  --api <url>   override the API base url');
-  out.line('  --help        show help (also: bp <command> --help)');
-  out.line('  --version     print the version');
+  out.line('  --json          machine-readable output ({ok,data}|{ok,error})');
+  out.line('  --no-color      disable colored output');
+  out.line('  --api <origin>  override the API origin (or set BIBLIOPLEX_API_ORIGIN)');
+  out.line('  --help          show help (also: bp <command> --help)');
+  out.line('  --version       print the version');
   out.line('');
-  out.line('start with: bp login');
+  out.line('auth: run `bp login`, or set BIBLIOPLEX_TOKEN to a personal access');
+  out.line('token for headless / CI use.');
 }
 
 export async function run(argv) {
@@ -36,13 +42,18 @@ export async function run(argv) {
   const out = createOutput({ json: boolFlag(flags, 'json'), color: !boolFlag(flags, 'no-color') });
   const command = positionals[0];
 
-  if (!command) {
-    if (boolFlag(flags, 'version')) { out.line(VERSION); return EXIT.OK; }
+  if (!command || command === 'help') {
+    if (boolFlag(flags, 'version')) {
+      out.line(VERSION);
+      return EXIT.OK;
+    }
     printHelp(out);
     return EXIT.OK;
   }
-  if (command === 'help') { printHelp(out); return EXIT.OK; }
-  if (boolFlag(flags, 'version')) { out.line(VERSION); return EXIT.OK; }
+  if (boolFlag(flags, 'version')) {
+    out.line(VERSION);
+    return EXIT.OK;
+  }
 
   const cmd = commands[command];
   if (!cmd) {
@@ -58,11 +69,13 @@ export async function run(argv) {
     out,
     flags,
     args: positionals.slice(1),
-    apiBase: resolveApiBase(flags),
-    makeSession() {
-      const creds = loadCredentials();
-      if (!creds?.accessToken) throw new CliError('not logged in — run `bp login`', EXIT.AUTH);
-      return new Session({ base: this.apiBase, credentials: creds, persist: saveCredentials });
+    apiOrigin: resolveApiOrigin(flags),
+    // Lazily build an MCP session. Uses BIBLIOPLEX_TOKEN (a personal access
+    // token) when set, otherwise the stored OAuth credentials. Imported on
+    // demand so `help`/`version` work without auth wiring.
+    async makeSession({ write = false } = {}) {
+      const { createSession } = await import('./mcp.mjs');
+      return createSession({ origin: this.apiOrigin, requireWrite: write, out: this.out });
     },
   };
 

package/src/commands/add.mjs

@@ -1,57 +1,36 @@
-import { resolvePrinting, cardToFields } from '../scryfall.mjs';
-import { normalizeCollectionEntry } from '../../vendor/collection.js';
-import { mergeIntoCollection } from '../../vendor/importMerge.js';
-import { applyMutation } from '../mutate.mjs';
-import { strFlag, intFlag, boolFlag } from '../args.mjs';
-import { requireWrite, parseLocationFlag, ensureContainer, persistUndo, printWrite } from './writeHelpers.mjs';
-import { usageError, CliError } from '../errors.mjs';
+import { intFlag, strFlag } from '../args.mjs';
+import { usageError } from '../errors.mjs';
+import { runMutation, resolveOnePrinting } from '../mutate.mjs';
 
 export default {
   summary: 'add a card to your collection',
-  help: [
-    'usage: bp add <name> [--set xxx --cn 123] [--finish foil] [--condition lightly_played]',
-    '                     [--qty 2] [--location "deck:breya"] [--tags trade,wishlist] [--dry-run]',
-    '       bp add --scryfall-id <id> [...]',
-    '',
-    'resolves the printing on scryfall (give --set + --cn to pin an exact printing),',
-    'then adds it to your cloud collection. coalesces with an identical existing stack.',
-  ].join('\n'),
-  async run(ctx) {
-    const { out, flags, args } = ctx;
-    const session = ctx.makeSession();
-    requireWrite(session);
-
-    const scryfallId = strFlag(flags, 'scryfall-id', 'id');
-    const set = strFlag(flags, 'set', 's');
-    const cn = strFlag(flags, 'cn');
-    const name = args.join(' ').trim();
-    if (!scryfallId && !(set && cn) && !name) throw usageError('usage: bp add <name> [--set --cn] | --scryfall-id <id>');
-
-    const finish = strFlag(flags, 'finish') || 'normal';
-    const card = await resolvePrinting({ scryfallId, set, cn, name });
-    if (!card) throw new CliError("couldn't find that printing — try specifying --set and --cn");
+  help: `bp add <name> [--set CODE] [--cn NUMBER] [--finish foil|nonfoil|etched] [--qty N] [--to LOCATION] [--tag a,b] [--yes] [--dry-run]
 
-    const tags = strFlag(flags, 'tags', 'tag');
-    const entry = normalizeCollectionEntry({
-      ...cardToFields(card, finish),
-      finish,
-      qty: intFlag(flags, 'qty', 1) || 1,
-      condition: strFlag(flags, 'condition', 'cond') || 'near_mint',
-      language: strFlag(flags, 'lang', 'language') || 'en',
-      location: parseLocationFlag(strFlag(flags, 'location', 'loc', 'to')),
-      tags: tags ? tags.split(',').map(s => s.trim()).filter(Boolean) : [],
-    }, { preserveResolvedFields: true });
-
-    const result = await applyMutation(session, (draft) => {
-      ensureContainer(draft, entry.location);
-      draft.app.collection = mergeIntoCollection(draft.app.collection, [entry]);
-      return { added: { name: entry.name, set: entry.setCode.toUpperCase(), cn: entry.cn, finish: entry.finish, qty: entry.qty } };
-    }, { dryRun: boolFlag(flags, 'dry-run') });
-
-    persistUndo(result);
-    printWrite(out, result, () => out.info(
-      out.c.green('✓ added') + ` ${entry.qty}x ${entry.name} (${entry.setCode.toUpperCase()} ${entry.cn}${entry.finish !== 'normal' ? ' ' + entry.finish : ''})`
-      + (entry.location ? ` → ${entry.location.type}:${entry.location.name}` : '')));
-    return 0;
+Resolves a printing, then adds it. For an exact printing use --set + --cn.
+Examples:
+  bp add "sol ring" --to deck:breya
+  bp add --set sld --cn 2144 --finish foil --qty 2`,
+  async run(ctx) {
+    const session = await ctx.makeSession({ write: true });
+    const query = ctx.args.join(' ').trim();
+    const setCode = strFlag(ctx.flags, 'set');
+    const cn = strFlag(ctx.flags, 'cn');
+    const finish = strFlag(ctx.flags, 'finish');
+    if (!query && !(setCode && cn)) {
+      throw usageError('usage: bp add <name>  (or --set CODE --cn NUMBER)');
+    }
+    const { scryfallId } = await resolveOnePrinting(session, { query, setCode, cn, finish });
+    const args = { operation: 'add', scryfallId, qty: intFlag(ctx.flags, 'qty', 1) };
+    if (finish) args.finish = finish;
+    const to = strFlag(ctx.flags, 'to');
+    if (to) args.location = to;
+    const tagStr = strFlag(ctx.flags, 'tag', 'tags');
+    if (tagStr) {
+      args.tags = tagStr
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
+    }
+    return runMutation(ctx, session, args, { verb: 'add' });
   },
 };

package/src/commands/deck.mjs

@@ -1,52 +1,18 @@
-import { loadSnapshot } from '../mutate.mjs';
-import { findContainer, containerCards } from '../snapshot.mjs';
-import { cardRow, CARD_COLUMNS } from '../render.mjs';
-import { usageError, CliError } from '../errors.mjs';
-import { runDeckExport } from './deckExport.mjs';
-
-const BOARDS = ['main', 'sideboard', 'maybe'];
-
-async function deckShow(ctx, name) {
-  const { out } = ctx;
-  if (!name) throw usageError('usage: bp deck show <name>');
-  const session = ctx.makeSession();
-  const { snapshot } = await loadSnapshot(session);
-  const { matches } = findContainer(snapshot, 'deck:' + name);
-  const decks = matches.filter(m => m.type === 'deck');
-  if (!decks.length) throw new CliError(`no deck named "${name}"`);
-
-  const deck = decks[0];
-  const cards = containerCards(snapshot, deck);
-  const boards = { main: [], sideboard: [], maybe: [] };
-  for (const c of cards) (boards[c.deckBoard] || boards.main).push(c);
-
-  out.emit({ deck: { name: deck.name, meta: deck.deck || null }, boards }, () => {
-    out.line(out.c.bold('deck: ' + deck.name));
-    const meta = deck.deck || {};
-    if (meta.format) out.line('  format: ' + meta.format);
-    if (meta.commander?.name) out.line('  commander: ' + meta.commander.name);
-    for (const b of BOARDS) {
-      const list = boards[b];
-      if (!list.length) continue;
-      const n = list.reduce((s, c) => s + (parseInt(c.qty, 10) || 0), 0);
-      out.line('');
-      out.line(out.c.bold(`${b} (${n})`));
-      out.table(CARD_COLUMNS, list.map(cardRow));
-    }
-  });
-  return 0;
-}
+import { emitResult, DECKLIST_COLUMNS, CONTAINER_COLUMNS } from '../render.mjs';
 
 export default {
-  summary: 'inspect or export a deck',
-  help: [
-    'usage: bp deck show <name>',
-    '       bp deck export <name> [--preset plain|moxfield|arena|mtgo|csv|json] [--boards main,sideboard,maybe]',
-  ].join('\n'),
+  summary: 'list decks or show a decklist',
+  help: `bp deck [name]
+
+With no name, lists your decks/containers. With a deck name, shows its decklist.`,
   async run(ctx) {
-    const [sub, ...rest] = ctx.args;
-    if (sub === 'show') return deckShow(ctx, rest.join(' '));
-    if (sub === 'export') return runDeckExport(ctx, rest);
-    throw usageError('usage: bp deck <show|export> <name>');
+    const session = await ctx.makeSession();
+    const name = ctx.args.join(' ').trim();
+    if (!name) {
+      const sc = await session.call('query_collection', { from: 'containers' });
+      return emitResult(ctx, sc, { columns: CONTAINER_COLUMNS });
+    }
+    const sc = await session.call('query_collection', { from: 'decklist', deckName: name });
+    return emitResult(ctx, sc, { columns: DECKLIST_COLUMNS });
   },
 };

package/src/commands/edit.mjs

@@ -1,45 +1,33 @@
-import { collectionKey, normalizeCondition, normalizeFinish } from '../../vendor/collection.js';
-import { applyMutation } from '../mutate.mjs';
-import { strFlag, intFlag, boolFlag } from '../args.mjs';
-import { requireWrite, selectorFrom, requireStacks, persistUndo, printWrite } from './writeHelpers.mjs';
+import { strFlag } from '../args.mjs';
 import { usageError } from '../errors.mjs';
+import { runMutation } from '../mutate.mjs';
 
 export default {
-  summary: 'edit a stack (condition / finish / qty / tags)',
-  help: [
-    'usage: bp edit <name> [--set --cn ...] [--condition lightly_played] [--finish foil]',
-    '                      [--qty 3] [--tags trade,foil] [--all] [--dry-run]',
-    '',
-    'updates fields on a matching stack. --tags replaces the tag set ("" clears).',
-  ].join('\n'),
+  summary: 'edit a card (finish, condition, tags)',
+  help: `bp edit <itemKey> [--finish ...] [--condition ...] [--tag a,b,c] [--yes] [--dry-run]
+
+Edit an inventory row. Tags use set-semantics: pass the full desired list
+(empty --tag clears them).`,
   async run(ctx) {
-    const { out, flags, args } = ctx;
-    const session = ctx.makeSession();
-    requireWrite(session);
-    const sel = selectorFrom(flags, args);
-    const newCond = strFlag(flags, 'condition', 'cond');
-    const newFinish = strFlag(flags, 'finish');
-    const newQty = intFlag(flags, 'qty', null);
-    const setTags = strFlag(flags, 'tags');
-    if (newCond == null && newFinish == null && newQty == null && setTags == null) {
-      throw usageError('nothing to edit — pass --condition, --finish, --qty, or --tags');
+    const itemKey = ctx.args[0] || strFlag(ctx.flags, 'item');
+    if (!itemKey)
+      throw usageError('usage: bp edit <itemKey> [--finish ...] [--condition ...] [--tag ...]');
+    const session = await ctx.makeSession({ write: true });
+    const args = { operation: 'edit', itemKey };
+    const finish = strFlag(ctx.flags, 'finish');
+    if (finish) args.finish = finish;
+    const condition = strFlag(ctx.flags, 'condition');
+    if (condition) args.condition = condition;
+    const tagStr = strFlag(ctx.flags, 'tag', 'tags');
+    if (tagStr != null) {
+      args.tags = tagStr
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean);
     }
-
-    const result = await applyMutation(session, (draft) => {
-      const stacks = requireStacks(draft.app.collection, sel, { all: boolFlag(flags, 'all') });
-      const keys = new Set(stacks.map(collectionKey));
-      for (const e of draft.app.collection) {
-        if (!keys.has(collectionKey(e))) continue;
-        if (newCond) e.condition = normalizeCondition(newCond);
-        if (newFinish) e.finish = normalizeFinish(newFinish);
-        if (newQty != null) e.qty = Math.max(1, newQty);
-        if (setTags != null) e.tags = setTags ? setTags.split(',').map(s => s.trim()).filter(Boolean) : [];
-      }
-      return { edited: stacks.length };
-    }, { dryRun: boolFlag(flags, 'dry-run') });
-
-    persistUndo(result);
-    printWrite(out, result, () => out.info(out.c.green('✓ edited') + ` ${result.meta.edited} stack(s)`));
-    return 0;
+    if (!finish && !condition && tagStr == null) {
+      throw usageError('nothing to edit — pass --finish, --condition, or --tag');
+    }
+    return runMutation(ctx, session, args, { verb: 'edit' });
   },
 };

package/src/commands/export.mjs

@@ -1,56 +1,72 @@
 import { writeFileSync } from 'node:fs';
-import { loadSnapshot } from '../mutate.mjs';
-import { runQuery, collectionOf } from '../snapshot.mjs';
-import { getAdapter } from '../../vendor/adapters.js';
-import { buildPortableArchive, portableArchiveToJson } from '../../vendor/portableArchive.js';
-import { strFlag, boolFlag } from '../args.mjs';
-import { usageError, CliError } from '../errors.mjs';
+import { strFlag, boolFlag, intFlag } from '../args.mjs';
+import { toCsv } from '../csv.mjs';
+import { pickRows } from '../render.mjs';
+import { EXIT } from '../constants.mjs';
 
-const CSV_FORMATS = ['canonical', 'moxfield', 'manabox', 'deckbox'];
+const INVENTORY_EXPORT_COLUMNS = [
+  'name',
+  'setCode',
+  'cn',
+  'finish',
+  'condition',
+  'qty',
+  'location',
+  'tags',
+  'price',
+];
 
 export default {
-  summary: 'export your collection to csv / json',
-  help: [
-    'usage: bp export [query] [--format canonical|moxfield|manabox|deckbox|json] [--output file]',
-    '       bp export --archive [--output backup.json]   (full round-trippable backup)',
-    '',
-    'with a query, exports only the matching cards (e.g. bp export "f:foil" --format moxfield).',
-    'writes to stdout unless --output is given.',
-  ].join('\n'),
+  summary: 'export your collection (CSV/JSON)',
+  help: `bp export [--deck NAME] [--format csv|json] [--all] [--output FILE]
+
+Export your inventory (default) or a deck's list (--deck NAME). CSV by default.
+--all pages the entire collection (otherwise one page). Writes to --output, or
+stdout if omitted. The inventory CSV round-trips with \`bp import\`.`,
   async run(ctx) {
-    const { out, flags, args } = ctx;
-    const session = ctx.makeSession();
-    const { snapshot } = await loadSnapshot(session);
-    const file = strFlag(flags, 'output', 'o');
+    const session = await ctx.makeSession();
+    const deck = strFlag(ctx.flags, 'deck');
+    const format = (
+      strFlag(ctx.flags, 'format') || (boolFlag(ctx.flags, 'json') ? 'json' : 'csv')
+    ).toLowerCase();
 
-    let body;
+    const rows = [];
     let meta;
-    if (boolFlag(flags, 'archive')) {
-      const archive = buildPortableArchive({ snapshot });
-      if (!archive) throw new CliError('could not build archive');
-      body = portableArchiveToJson(archive);
-      meta = { kind: 'archive' };
+    if (deck) {
+      const sc = await session.call('query_collection', { from: 'decklist', deckName: deck });
+      rows.push(...pickRows(sc));
+      meta = { deck };
     } else {
-      const cards = runQuery(collectionOf(snapshot), args.join(' '));
-      const format = strFlag(flags, 'format') || 'canonical';
-      if (format === 'json') {
-        body = JSON.stringify(cards, null, 2);
-      } else if (CSV_FORMATS.includes(format)) {
-        body = getAdapter(format).export(cards);
-      } else {
-        throw usageError(`unknown format: ${format} (use ${CSV_FORMATS.join('/')}, json, or --archive)`);
-      }
-      meta = { format, count: cards.length };
+      const all = boolFlag(ctx.flags, 'all');
+      const limit = intFlag(ctx.flags, 'limit');
+      let cursor;
+      let pages = 0;
+      do {
+        const args = { from: 'inventory' };
+        if (limit) args.limit = limit;
+        if (cursor) args.cursor = cursor;
+        const sc = await session.call('query_collection', args);
+        rows.push(...pickRows(sc));
+        cursor = all ? sc?.nextCursor : undefined;
+        pages += 1;
+      } while (cursor && pages < 1000);
+      meta = { count: rows.length };
     }
 
+    const payload =
+      format === 'json'
+        ? JSON.stringify({ ...meta, rows }, null, 2) + '\n'
+        : toCsv(rows, deck ? undefined : INVENTORY_EXPORT_COLUMNS);
+
+    const file = strFlag(ctx.flags, 'output');
     if (file) {
-      writeFileSync(file, body.endsWith('\n') ? body : body + '\n');
-      out.emit({ file, ...meta }, () => out.info(`wrote ${file}`));
-    } else if (out.json) {
-      out.emit({ ...meta, body });
+      writeFileSync(file, payload);
+      ctx.out.emit({ written: file, count: rows.length }, () =>
+        ctx.out.info(`wrote ${rows.length} rows to ${file}`),
+      );
     } else {
-      out.raw(body);
+      ctx.out.raw(payload.replace(/\n$/, ''));
     }
-    return 0;
+    return EXIT.OK;
   },
 };

package/src/commands/history.mjs

@@ -0,0 +1,24 @@
+import { intFlag } from '../args.mjs';
+import { emitResult } from '../render.mjs';
+
+export default {
+  summary: 'recent collection changes',
+  help: `bp history [--limit N]
+
+Recent change events for your collection.`,
+  async run(ctx) {
+    const session = await ctx.makeSession();
+    const args = { from: 'history' };
+    const limit = intFlag(ctx.flags, 'limit');
+    if (limit != null) args.limit = limit;
+    const sc = await session.call('query_collection', args);
+    return emitResult(ctx, sc, {
+      columns: [
+        { key: 'type', header: 'type' },
+        { key: 'summary', header: 'summary' },
+        { key: 'description', header: 'description' },
+        { key: 'at', header: 'when' },
+      ],
+    });
+  },
+};

package/src/commands/import.mjs

@@ -1,94 +1,66 @@
 import { readFileSync } from 'node:fs';
-import { parseCsv } from '../../vendor/importParsing.js';
-import { detectAdapter } from '../../vendor/adapters.js';
-import { mergeIntoCollection } from '../../vendor/importMerge.js';
-import { normalizeCollectionEntry } from '../../vendor/collection.js';
-import { resolvePrinting, cardToFields, sleep } from '../scryfall.mjs';
-import { applyMutation } from '../mutate.mjs';
-import { boolFlag } from '../args.mjs';
-import { requireWrite, ensureContainer, printWrite } from './writeHelpers.mjs';
+import { strFlag } from '../args.mjs';
 import { usageError, CliError } from '../errors.mjs';
+import { fromCsv } from '../csv.mjs';
+import { runMutation } from '../mutate.mjs';
+import { EXIT } from '../constants.mjs';
 
-// Pushed in chunks so a large import stays within the worker's per-request CPU
-// and payload limits; each chunk is one revision. Not undoable (too large).
-const CHUNK = 150;
+// The server caps mutate_inventory at 200 items/call; keep v1 import to a single
+// call and tell the user to split larger files (auto-chunking can come later).
+const MAX_ROWS = 200;
 
 export default {
-  summary: 'import cards from a csv file (moxfield/manabox/deckbox/canonical)',
-  help: [
-    'usage: bp import <file.csv> [--no-resolve] [--dry-run]',
-    '',
-    'auto-detects the csv format and merges the cards into your cloud collection.',
-    'by default each card is resolved on scryfall so it is fully searchable; pass',
-    '--no-resolve to import as-is (faster, but no oracle/color/price data).',
-  ].join('\n'),
-  async run(ctx) {
-    const { out, flags, args } = ctx;
-    const session = ctx.makeSession();
-    requireWrite(session);
-    const path = args[0];
-    if (!path) throw usageError('usage: bp import <file.csv>');
+  summary: 'import cards from a CSV file',
+  help: `bp import <file.csv> [--to LOCATION] [--yes] [--dry-run]
 
+Bulk-add cards from CSV (previewed and confirmed like any write). Columns:
+setCode (or set), cn, finish, qty, condition, tags (; or | separated), location.
+--to overrides the location for every row. Up to ${MAX_ROWS} rows per file.`,
+  async run(ctx) {
+    const file = ctx.args[0] || strFlag(ctx.flags, 'input');
+    if (!file) throw usageError('usage: bp import <file.csv> [--to LOCATION]');
     let text;
-    try { text = readFileSync(path, 'utf8'); } catch { throw new CliError('cannot read file: ' + path); }
-    const rows = parseCsv(text);
-    if (rows.length < 2) throw new CliError('no rows found in ' + path);
-    const adapter = detectAdapter(rows[0]);
-    if (!adapter) throw new CliError('could not detect a supported csv format (moxfield/manabox/deckbox/canonical)');
-    let entries = adapter.parse(rows);
-    if (!entries.length) throw new CliError('no cards parsed from ' + path);
-
-    let resolved = 0;
-    let unresolved = 0;
-    if (!boolFlag(flags, 'no-resolve')) {
-      out.info(`resolving ${entries.length} card(s) on scryfall…`);
-      const next = [];
-      for (let i = 0; i < entries.length; i += 1) {
-        const e = entries[i];
-        let card = null;
-        try { card = await resolvePrinting({ scryfallId: e.scryfallId || null, set: e.setCode, cn: e.cn, name: e.name }); } catch { /* leave unresolved */ }
-        if (card) {
-          resolved += 1;
-          next.push(normalizeCollectionEntry({
-            ...cardToFields(card, e.finish), finish: e.finish, qty: e.qty,
-            condition: e.condition, language: e.language, location: e.location, tags: e.tags,
-            ...(e._source ? { _source: e._source } : {}),
-          }, { preserveResolvedFields: true }));
-        } else {
-          unresolved += 1;
-          next.push(e);
-        }
-        if ((i + 1) % 25 === 0) out.info(out.c.dim(`  ${i + 1}/${entries.length}`));
-        await sleep(80);
-      }
-      entries = next;
+    try {
+      text = readFileSync(file, 'utf8');
+    } catch (e) {
+      throw new CliError(`cannot read ${file}: ${e.message}`, EXIT.USAGE);
     }
-
-    if (boolFlag(flags, 'dry-run')) {
-      const result = await applyMutation(session, (draft) => {
-        for (const e of entries) ensureContainer(draft, e.location);
-        draft.app.collection = mergeIntoCollection(draft.app.collection, entries);
-        return { format: adapter.id, imported: entries.length, resolved, unresolved };
-      }, { dryRun: true });
-      printWrite(out, result, () => out.info(out.c.dim(`dry run — would import ${entries.length} card(s) (${adapter.id})`)));
-      return 0;
+    const rows = fromCsv(text);
+    if (!rows.length) throw new CliError(`no rows found in ${file}`, EXIT.USAGE);
+    if (rows.length > MAX_ROWS) {
+      throw new CliError(
+        `${rows.length} rows exceeds the ${MAX_ROWS}-row per-import cap — split the file`,
+        EXIT.USAGE,
+      );
     }
 
-    let revision = 0;
-    for (let i = 0; i < entries.length; i += CHUNK) {
-      const chunk = entries.slice(i, i + CHUNK);
-      const result = await applyMutation(session, (draft) => {
-        for (const e of chunk) ensureContainer(draft, e.location);
-        draft.app.collection = mergeIntoCollection(draft.app.collection, chunk);
-      });
-      revision = result.revision || revision;
-      if (entries.length > CHUNK) out.info(out.c.dim(`  pushed ${Math.min(i + CHUNK, entries.length)}/${entries.length}`));
-    }
+    const to = strFlag(ctx.flags, 'to');
+    const items = rows.map((r) => {
+      const item = {};
+      const set = r.setCode || r.set;
+      if (set) item.setCode = set;
+      if (r.cn) item.cn = r.cn;
+      if (r.finish) item.finish = r.finish;
+      const qty = parseInt(r.qty, 10);
+      item.qty = Number.isFinite(qty) && qty > 0 ? qty : 1;
+      if (r.condition) item.condition = r.condition;
+      if (r.tags) {
+        item.tags = String(r.tags)
+          .split(/[;|]/)
+          .map((s) => s.trim())
+          .filter(Boolean);
+      }
+      const loc = to || r.location;
+      if (loc) item.location = loc;
+      return item;
+    });
 
-    out.emit(
-      { changed: true, imported: entries.length, format: adapter.id, resolved, unresolved, revision },
-      () => out.info(out.c.green('✓ imported') + ` ${entries.length} card(s) (${adapter.id})` + (unresolved ? `, ${unresolved} unresolved` : '')),
+    const session = await ctx.makeSession({ write: true });
+    return runMutation(
+      ctx,
+      session,
+      { operation: 'add', items },
+      { verb: `import ${items.length} rows` },
     );
-    return 0;
   },
 };