orizu 0.5.38 → 0.5.40

package/dist/dataset-append-workflow.js

@@ -0,0 +1,198 @@
+import { statSync } from 'node:fs';
+import { extname } from 'node:path';
+import { Context, Effect, Result, Schema } from 'effect';
+import { parseDatasetFile } from './file-parser.js';
+import { datasetTransferTimeoutMs } from './dataset-transfer-policy.js';
+import { authedFetch } from './http.js';
+import { streamJsonlRowChunks } from './jsonl-stream.js';
+import { sanitizeTerminalText } from './json-response.js';
+class AppendFailure extends Error {
+    outcome;
+    _tag = 'AppendFailure';
+    constructor(message, outcome) {
+        super(sanitizeTerminalText(message));
+        this.outcome = outcome;
+    }
+}
+const Acknowledgement = Schema.Struct({
+    dataset: Schema.Struct({ id: Schema.String, name: Schema.String, rowCount: Schema.Natural }),
+    appendedCount: Schema.Natural,
+});
+const RowsSchema = Schema.Array(Schema.Record(Schema.String, Schema.Unknown));
+const appendTransport = Context.Service('orizu/cli/DatasetAppendTransport');
+// Only responses naming an existing rows-route rejection establish a known
+// refusal. A proxy body or a lost body is not evidence that nothing committed.
+function isKnownRefusal(message, status) {
+    // These exact templates come from artifact preparation before the append RPC.
+    // Status alone or an arbitrary artifact/proxy prefix cannot prove rejection.
+    if (status === 400 && (message === 'Dataset row id cannot be stored as an artifact' ||
+        /^Invalid dataset row artifact reference at .+$/.test(message) ||
+        /^Dataset row artifact ref at .+ (?:is nested; v1 supports top-level fields only|was not issued by this server|belongs to a different project|has been deleted|has not been finalized|is expired|was issued to a different user|is not attachable|does not match server metadata|targets a different (?:dataset|field|row id))$/.test(message)))
+        return true;
+    if (status === 413 && (/^Dataset row .+ exceeds 65536 bytes after externalizing top-level fields$/.test(message) ||
+        /^.+ exceeds (?:26214400 bytes before compression|10485760 bytes after compression)$/.test(message)))
+        return true;
+    return /^(Missing bearer token|Unauthorized|Dataset not found|Only project curators\/admins can modify dataset rows|Dataset is locked and cannot be mutated|Duplicate row ids provided|One or more row ids already exist in this dataset|rows must contain at least one item|rows\[\d+\] must be an object|Dataset row is too large|Each row in p_rows must)/.test(message);
+}
+function liveTransport(timeoutMs, commandSignal, progress) {
+    return {
+        append: (datasetId, rows) => Effect.suspend(() => {
+            let admitted = false;
+            let timedOut = false;
+            const attempt = new AbortController();
+            let timer;
+            return Effect.tryPromise({
+                try: async (signal) => {
+                    const abortFromEffect = () => attempt.abort(signal.reason);
+                    const abortFromCommand = () => attempt.abort(commandSignal.reason);
+                    try {
+                        // Node 20.0 has no AbortSignal.any. This attempt owns both links
+                        // and the physical fetch/body signal until its receipt is consumed.
+                        if (signal.aborted)
+                            abortFromEffect();
+                        else
+                            signal.addEventListener('abort', abortFromEffect, { once: true });
+                        if (commandSignal.aborted)
+                            abortFromCommand();
+                        else
+                            commandSignal.addEventListener('abort', abortFromCommand, { once: true });
+                        const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/rows`, {
+                            method: 'POST', headers: { 'Content-Type': 'application/json' },
+                            body: JSON.stringify({ rows }), signal: attempt.signal,
+                        }, () => {
+                            admitted = true;
+                            if (progress.chunk)
+                                progress.chunk.outcome = 'unknown';
+                            if (timer)
+                                clearTimeout(timer);
+                            timer = setTimeout(() => { timedOut = true; attempt.abort(); }, timeoutMs);
+                        });
+                        // The single admitted-attempt deadline includes the complete body.
+                        const text = await response.text();
+                        let value;
+                        try {
+                            value = JSON.parse(text);
+                        }
+                        catch {
+                            throw new AppendFailure('Append returned an invalid acknowledgement', 'unknown');
+                        }
+                        if (!response.ok) {
+                            const message = value && typeof value === 'object' && 'error' in value && typeof value.error === 'string' ? value.error : '';
+                            const known = response.status >= 400 && response.status < 500 && isKnownRefusal(message, response.status);
+                            throw new AppendFailure(message ? `Append failed: ${message}` : 'Append failed', known ? 'rejected' : 'unknown');
+                        }
+                        const result = Schema.decodeUnknownResult(Acknowledgement)(value);
+                        if (Result.isFailure(result) || result.success.dataset.id.toLowerCase() !== datasetId.toLowerCase() || result.success.appendedCount !== rows.length)
+                            throw new AppendFailure('Append returned an invalid acknowledgement', 'unknown');
+                        return result.success;
+                    }
+                    finally {
+                        if (timer)
+                            clearTimeout(timer);
+                        signal.removeEventListener('abort', abortFromEffect);
+                        commandSignal.removeEventListener('abort', abortFromCommand);
+                        attempt.abort();
+                    }
+                },
+                catch: cause => cause instanceof AppendFailure ? cause : new AppendFailure(timedOut ? 'DATASET_TRANSFER_TIMEOUT: Dataset append exceeded its deadline' : admitted ? 'fetch failed' : cause instanceof Error ? cause.message : 'Append failed before the request was sent', admitted ? 'unknown' : 'not_sent'),
+            });
+        }),
+    };
+}
+function recovery(progress) {
+    if (progress.chunk?.outcome === 'unknown')
+        return 'This chunk may already be committed. Inspect the dataset and reconcile its rows before rerunning; do not blindly repeat this write.';
+    if (progress.confirmedRows > 0)
+        return 'Earlier acknowledged rows remain appended. Inspect the confirmed source prefix before retrying the remaining input.';
+    return 'Resolve the reported error before rerunning the command.';
+}
+function appendProgram(input, timeoutMs, progress, io, signal) {
+    return Effect.gen(function* () {
+        const rows = yield* Effect.try({
+            try: () => {
+                if (extname(input.file).toLowerCase() === '.jsonl')
+                    return undefined;
+                let bytes;
+                try {
+                    bytes = statSync(input.file).size;
+                }
+                catch (cause) {
+                    const error = cause;
+                    if (error.code === 'ENOENT')
+                        throw new Error(`File not found: ${input.file}. Check the path and filename, then retry.`);
+                    if (error.code === 'EPERM' || error.code === 'EACCES')
+                        throw new Error(`Cannot read file: ${input.file}. Grant folder permission to your terminal app and retry.`);
+                    throw new Error(`Failed to access file ${input.file}: ${error.message}`);
+                }
+                if (bytes > 50 * 1024 * 1024)
+                    throw new Error(`Input file is ${(bytes / (1024 * 1024)).toFixed(1)} MB, which exceeds the 50 MB limit. Split the file into smaller parts and append each separately.`);
+                const parsed = parseDatasetFile(input.file).rows;
+                if (!Array.isArray(parsed) || parsed.length === 0)
+                    throw new Error('Dataset append file must contain at least one row');
+                return parsed;
+            },
+            catch: cause => new AppendFailure(cause instanceof Error ? cause.message : 'Could not read append input', 'not_sent'),
+        });
+        const source = yield* Effect.acquireRelease(Effect.sync(() => rows ? (async function* () {
+            for (let offset = 0; offset < rows.length; offset += 500)
+                yield rows.slice(offset, offset + 500);
+        })() : streamJsonlRowChunks(input.file, { signal })), iterator => Effect.promise(async () => { await iterator.return(undefined); }));
+        const transport = liveTransport(timeoutMs, signal, progress);
+        let acknowledgement;
+        let index = 0;
+        while (true) {
+            const next = yield* Effect.tryPromise({ try: () => source.next(), catch: cause => new AppendFailure(cause instanceof Error ? cause.message : 'Could not read append input', 'not_sent') });
+            if (next.done)
+                break;
+            index++;
+            progress.chunk = { index, inputRows: next.value.length, outcome: 'not_sent' };
+            const rows = yield* Schema.decodeUnknownEffect(RowsSchema)(next.value).pipe(Effect.mapError(() => new AppendFailure('Dataset rows must be JSON objects', 'not_sent')));
+            if (!io.json)
+                yield* Effect.sync(() => io.print(`Uploading chunk ${index} (${rows.length} rows)...`));
+            acknowledgement = yield* appendTransport.use(api => api.append(input.datasetId, rows)).pipe(Effect.provideService(appendTransport, transport));
+            progress.confirmedRows += acknowledgement.appendedCount;
+            progress.confirmedChunks++;
+            progress.chunk = null;
+        }
+        if (!acknowledgement)
+            return yield* Effect.fail(new AppendFailure('Dataset append file must contain at least one row', 'not_sent'));
+        return { dataset: acknowledgement.dataset, appendedCount: progress.confirmedRows };
+    }).pipe(Effect.scoped);
+}
+/** Owns standalone append's source, admitted writes, progress and recovery. */
+export async function appendDatasetWorkflow(resolveInput, io) {
+    const controller = new AbortController();
+    const progress = { datasetId: null, confirmedRows: 0, confirmedChunks: 0, chunk: null };
+    let interrupted;
+    const interrupt = () => { interrupted = 130; controller.abort(); };
+    const terminate = () => { interrupted = 143; controller.abort(); };
+    const program = Effect.gen(function* () {
+        const timeoutMs = yield* Effect.try({ try: datasetTransferTimeoutMs, catch: cause => new AppendFailure(cause instanceof Error ? cause.message : 'Invalid append configuration', 'not_sent') });
+        const input = yield* Effect.tryPromise({ try: resolveInput, catch: cause => new AppendFailure(cause instanceof Error ? cause.message : 'Could not resolve append input', 'not_sent') });
+        progress.datasetId = input.datasetId;
+        // Retained interactive selection does not accept a signal. Preserve
+        // natural Node termination until we own cancellable source/transport work.
+        return yield* Effect.acquireUseRelease(Effect.sync(() => { process.once('SIGINT', interrupt); process.once('SIGTERM', terminate); }), () => appendProgram(input, timeoutMs, progress, io, controller.signal), () => Effect.sync(() => { process.removeListener('SIGINT', interrupt); process.removeListener('SIGTERM', terminate); }));
+    });
+    const report = (message) => {
+        const error = sanitizeTerminalText(message);
+        const advice = recovery(progress);
+        io.print(io.json ? JSON.stringify({ error, datasetId: progress.datasetId, confirmedRows: progress.confirmedRows, confirmedChunks: progress.confirmedChunks, failedChunk: progress.chunk, recovery: advice })
+            : `${error}\n${progress.confirmedRows} rows from ${progress.confirmedChunks} chunk(s) were already appended. ${advice}`);
+    };
+    try {
+        const result = await Effect.runPromise(Effect.result(program), { signal: controller.signal });
+        if (Result.isFailure(result)) {
+            if (progress.chunk)
+                progress.chunk.outcome = result.failure.outcome;
+            report(result.failure.message);
+            return 1;
+        }
+        io.print(io.json ? JSON.stringify(result.success) : `Appended ${result.success.appendedCount} rows to dataset ${sanitizeTerminalText(result.success.dataset.name)} (${sanitizeTerminalText(result.success.dataset.id)}). New row count: ${result.success.dataset.rowCount}`);
+        return 0;
+    }
+    catch {
+        report(interrupted ? 'Dataset append interrupted' : 'Dataset append failed');
+        return interrupted ?? 1;
+    }
+}

package/dist/dataset-commands.d.ts

@@ -1,4 +1,6 @@
 declare function createDatasetVersion(): Promise<void>;
+declare function listDatasetSplitSets(): Promise<void>;
+declare function showDatasetSplitSet(): Promise<void>;
 declare function createDatasetSplitSet(): Promise<void>;
 declare function listDatasets(): Promise<void>;
 declare function uploadDataset(): Promise<void>;
@@ -12,5 +14,5 @@ declare function deleteDataset(): Promise<void>;
 declare function lockDataset(): Promise<void>;
 declare function cloneDataset(): Promise<void>;
 declare function downloadAnnotations(): Promise<void>;
-export { uploadDataset, listDatasets, pushDataset, downloadDataset, appendDatasetRows, setDatasetReadme, createDatasetVersion, createDatasetSplitSet, editDatasetRows, deleteDatasetRows, deleteDataset, lockDataset, cloneDataset, downloadAnnotations, };
+export { uploadDataset, listDatasets, pushDataset, downloadDataset, appendDatasetRows, setDatasetReadme, createDatasetVersion, createDatasetSplitSet, listDatasetSplitSets, showDatasetSplitSet, editDatasetRows, deleteDatasetRows, deleteDataset, lockDataset, cloneDataset, downloadAnnotations, };
 //# sourceMappingURL=dataset-commands.d.ts.map

package/dist/dataset-commands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dataset-commands.d.ts","sourceRoot":"","sources":["../src/dataset-commands.ts"],"names":[],"mappings":"AA8IA,iBAAe,oBAAoB,kBAiClC;AAED,iBAAe,qBAAqB,kBAkDnC;AAED,iBAAe,YAAY,kBAW1B;AAsBD,iBAAe,aAAa,kBAiC3B;AAED,iBAAe,WAAW,kBAwCzB;AAED,iBAAe,gBAAgB,kBA+C9B;AAgBD,iBAAe,eAAe,kBA8B7B;AA0ED,iBAAe,iBAAiB,kBAiG/B;AAED,iBAAe,eAAe,kBAyB7B;AAED,iBAAe,iBAAiB,kBAyC/B;AA0BD,iBAAe,aAAa,kBA8B3B;AAED,iBAAe,WAAW,kBAwCzB;AAED,iBAAe,YAAY,kBAuC1B;AAED,iBAAe,mBAAmB,kBA+BjC;AAED,OAAO,EACL,aAAa,EACb,YAAY,EACZ,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,YAAY,EACZ,mBAAmB,GACpB,CAAA"}
+{"version":3,"file":"dataset-commands.d.ts","sourceRoot":"","sources":["../src/dataset-commands.ts"],"names":[],"mappings":"AAuJA,iBAAe,oBAAoB,kBAiClC;AAED,iBAAe,oBAAoB,kBAYlC;AAED,iBAAe,mBAAmB,kBAcjC;AAED,iBAAe,qBAAqB,kBAkDnC;AAED,iBAAe,YAAY,kBAW1B;AAsBD,iBAAe,aAAa,kBAiC3B;AAED,iBAAe,WAAW,kBAwCzB;AAED,iBAAe,gBAAgB,kBA+B9B;AAgBD,iBAAe,eAAe,kBA6C7B;AAED,iBAAe,iBAAiB,kBAU/B;AAED,iBAAe,eAAe,kBA2B7B;AAED,iBAAe,iBAAiB,kBA2B/B;AA0BD,iBAAe,aAAa,kBAuB3B;AAED,iBAAe,WAAW,kBAuBzB;AAED,iBAAe,YAAY,kBAuC1B;AAED,iBAAe,mBAAmB,kBA0BjC;AAED,OAAO,EACL,aAAa,EACb,YAAY,EACZ,WAAW,EACX,eAAe,EACf,iBAAiB,EACjB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,oBAAoB,EACpB,mBAAmB,EACnB,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,WAAW,EACX,YAAY,EACZ,mBAAmB,GACpB,CAAA"}

package/dist/dataset-commands.js

@@ -1,9 +1,9 @@
 // ORI-2044: moved from index.ts to keep dataset commands together.
-import { readFileSync, statSync, writeFileSync } from 'fs';
+import { readFileSync } from 'fs';
 import { basename, extname } from 'path';
 import { createInterface } from 'readline/promises';
 import { stdin as input, stdout as output } from 'process';
-import { getArg, expandHomePath, getPositionalArg, hasJsonFlag, getArchiveListStatus, cliArgs, isInteractiveTerminal, } from './command-line-arguments.js';
+import { getArg, hasArg, expandHomePath, getPositionalArg, hasJsonFlag, getArchiveListStatus, cliArgs, isInteractiveTerminal, } from './command-line-arguments.js';
 import { resolveProjectSlug, fetchDatasets, selectDatasetInteractively, selectTaskIdInteractively, } from './account-directory.js';
 import { sanitizeTerminalText, parseJsonResponse } from './json-response.js';
 import { authedFetch } from './http.js';
@@ -14,10 +14,18 @@ import { printDatasetSummaries } from './archive-artifacts-cli.js';
 import { formatTerminalLink } from './auth-commands.js';
 import { parseDatasetFile } from './file-parser.js';
 import { parseDatasetReference } from './dataset-download.js';
-import { streamJsonlRowChunks } from './jsonl-stream.js';
-import { editDatasetRows as runEditDatasetRows } from './dataset-edit-rows.js';
 import { parseCommaSeparated } from './task-commands.js';
 const MAX_README_LENGTH = 200_000;
+function readReadmeFile(readmeFile) {
+    try {
+        return readFileSync(expandHomePath(readmeFile), 'utf8');
+    }
+    catch (error) {
+        const missing = error instanceof Error && 'code' in error && error.code === 'ENOENT';
+        const reason = missing ? 'file not found' : error instanceof Error ? error.message : String(error);
+        throw new Error(`Could not read README file ${readmeFile}: ${reason}`);
+    }
+}
 function readReadmeMarkdownFromArgs(usage) {
     const readmeFile = getArg('--readme-file');
     const readmeText = getArg('--readme-text');
@@ -25,7 +33,7 @@ function readReadmeMarkdownFromArgs(usage) {
         throw new Error(`Use either --readme-file or --readme-text, not both.\n${usage}`);
     }
     const markdown = readmeFile !== null
-        ? readFileSync(expandHomePath(readmeFile), 'utf8')
+        ? readReadmeFile(readmeFile)
         : readmeText;
     if (markdown !== null && markdown.length > MAX_README_LENGTH) {
         throw new Error(`README markdown is too large. Maximum size is ${MAX_README_LENGTH} characters.`);
@@ -117,6 +125,41 @@ async function createDatasetVersion() {
     printLine(`Created dataset version ${sanitizeTerminalText(data.datasetVersion.id)}` +
         (details ? ` (${sanitizeTerminalText(details)})` : ''));
 }
+async function listDatasetSplitSets() {
+    const versionId = getPositionalArg(3);
+    if (!versionId)
+        throw new Error('Usage: orizu datasets splits list <datasetVersionId> [--json]');
+    const { listDatasetSplits } = await import('./dataset-split-reads.js');
+    const data = await listDatasetSplits(versionId);
+    if (hasJsonFlag())
+        return printJson({ ...data });
+    printLine(`Dataset version ${sanitizeTerminalText(data.dataset_version_id)}`);
+    for (const set of data.split_sets) {
+        printLine(`${sanitizeTerminalText(set.name)} (${sanitizeTerminalText(set.id)})`);
+        for (const partition of set.partitions)
+            printLine(`  ${sanitizeTerminalText(partition.name)}: ${partition.row_count} rows`);
+    }
+    if (!data.split_sets.length)
+        printLine('No saved split sets.');
+}
+async function showDatasetSplitSet() {
+    const setId = getPositionalArg(3);
+    if (!setId)
+        throw new Error('Usage: orizu datasets splits show <splitSetId> [--json]');
+    const { showDatasetSplit } = await import('./dataset-split-reads.js');
+    const data = await showDatasetSplit(setId);
+    if (hasJsonFlag())
+        return printJson({ ...data });
+    printLine(`${sanitizeTerminalText(data.name)} (${sanitizeTerminalText(data.split_set_id)})`);
+    printLine(`Dataset version: ${sanitizeTerminalText(data.dataset_version_id)}`);
+    printLine(`Strategy: ${sanitizeTerminalText(data.strategy)}; seed: ${data.seed ?? 'none'}`);
+    printLine(`Metadata: ${sanitizeTerminalText(JSON.stringify(data.metadata))}`);
+    for (const partition of data.partitions) {
+        printLine(`${sanitizeTerminalText(partition.name)}: ${partition.row_ids.length} rows`);
+        for (const id of partition.row_ids)
+            printLine(`  ${sanitizeTerminalText(id)}`);
+    }
+}
 async function createDatasetSplitSet() {
     const datasetVersionId = getPositionalArg(3) || getArg('--dataset-version');
     const splitFile = getArg('--from-file');
@@ -133,7 +176,7 @@ async function createDatasetSplitSet() {
         throw new Error('Usage: orizu datasets splits create <datasetVersionId> [--from-file <split.json>] [--name <name>] [--seed <n>] [--train <ratio>] [--validation <ratio>] [--test <ratio>] [--json]');
     }
     const partitions = splitSpec && Array.isArray(splitSpec.partitions) ? splitSpec.partitions : undefined;
-    const metadata = splitSpec && typeof splitSpec.metadata === 'object' && splitSpec.metadata !== null
+    const metadata = splitSpec && Object.prototype.hasOwnProperty.call(splitSpec, 'metadata')
         ? splitSpec.metadata
         : undefined;
     const response = await authedFetch(`/api/cli/dataset-versions/${encodeURIComponent(datasetVersionId)}/split-sets`, {
@@ -265,25 +308,18 @@ async function setDatasetReadme() {
         throw new Error(usage);
     }
     const resolvedDatasetId = await resolveDatasetIdForProject(datasetId, project);
-    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(resolvedDatasetId)}/readme`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ markdown: readmeMarkdown }),
-    });
-    if (!response.ok) {
-        throw new Error(`Failed to save dataset README: ${await response.text()}`);
-    }
-    const data = await parseJsonResponse(response, 'Dataset README save');
+    const { saveDatasetReadme } = await import('./dataset-readme-workflow.js');
+    const version = await saveDatasetReadme(resolvedDatasetId, readmeMarkdown);
     if (hasJsonFlag()) {
         printJson({
-            dataset_id: data.version.dataset_id,
-            readme_version_id: data.version.id,
-            readme_version_num: data.version.version_num,
+            dataset_id: version.dataset_id,
+            readme_version_id: version.id,
+            readme_version_num: version.version_num,
         });
         return;
     }
-    printLine(`Saved README v${data.version.version_num} for dataset ` +
-        `${sanitizeTerminalText(data.version.dataset_id)} (${sanitizeTerminalText(data.version.id)}).`);
+    printLine(`Saved README v${version.version_num} for dataset ` +
+        `${sanitizeTerminalText(version.dataset_id)} (${sanitizeTerminalText(version.id)}).`);
 }
 function getDatasetReferenceInput() {
     const fromFlag = getArg('--dataset');
@@ -304,6 +340,24 @@ async function downloadDataset() {
     if (!['csv', 'json', 'jsonl'].includes(format)) {
         throw new Error('format must be one of: csv, json, jsonl');
     }
+    const versionId = getArg('--dataset-version'), setId = getArg('--split-set');
+    const inlineSplit = cliArgs.find(argument => argument.startsWith('--split='));
+    const split = inlineSplit === undefined ? getArg('--split') : inlineSplit.slice('--split='.length);
+    if (['--dataset-version', '--split-set', '--split'].some(flag => hasArg(flag) || cliArgs.some(argument => argument.startsWith(`${flag}=`)))) {
+        if (!versionId || !setId || !split || [versionId, setId].some(value => value.startsWith('--')) || (inlineSplit === undefined && split.startsWith('--')))
+            throw new Error('Pinned download requires --dataset-version, --split-set and --split together');
+        if (datasetInput)
+            throw new Error('Use --dataset-version with split selectors without a live --dataset or dataset argument');
+        if (format === 'csv')
+            throw new Error('Pinned download format must be json or jsonl');
+        const filename = outPathArg ? expandHomePath(outPathArg) : `${versionId}.${format}`;
+        const { downloadPinnedDatasetSplit } = await import('./dataset-split-reads.js');
+        await downloadPinnedDatasetSplit(versionId, setId, split, format, filename);
+        if (hasJsonFlag())
+            return printJson({ dataset_version_id: versionId, split_set_id: setId, split, format, savedTo: filename });
+        printLine(`Saved split ${sanitizeTerminalText(split)} from dataset version ${sanitizeTerminalText(versionId)} (${format.toUpperCase()}) to ${sanitizeTerminalText(filename)}`);
+        return;
+    }
     let datasetId;
     if (datasetInput) {
         datasetId = parseDatasetReference(datasetInput).datasetId;
@@ -323,135 +377,17 @@ async function downloadDataset() {
     }
     printLine(`Saved dataset ${sanitizeTerminalText(datasetId)} (${format.toUpperCase()}) to ${sanitizeTerminalText(filename)}`);
 }
-const MAX_INPUT_FILE_SIZE_BYTES = 50 * 1024 * 1024; // 50 MB
-const APPEND_CHUNK_SIZE_ROWS = 500;
-async function appendChunk(datasetId, rows) {
-    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/rows`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ rows }),
-    });
-    if (!response.ok) {
-        throw new Error(`Append failed: ${await response.text()}`);
-    }
-    return parseJsonResponse(response, 'Dataset append');
-}
-async function appendJsonlDatasetRowsInChunks(datasetId, file) {
-    let totalAppended = 0;
-    let lastResult = null;
-    let chunkIndex = 0;
-    const chunks = streamJsonlRowChunks(file)[Symbol.asyncIterator]();
-    while (true) {
-        let nextChunk;
-        try {
-            nextChunk = await chunks.next();
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Append stopped while reading the next JSONL chunk: ${message}\n` +
-                `${totalAppended} rows from ${chunkIndex} chunk(s) were already appended. ` +
-                `Fix the file, remove the first ${totalAppended} rows, and re-run the command.`);
-        }
-        if (nextChunk.done) {
-            break;
-        }
-        const chunk = nextChunk.value;
-        chunkIndex += 1;
-        printLine(`Uploading chunk ${chunkIndex} (${chunk.length} rows)...`);
-        try {
-            const data = await appendChunk(datasetId, chunk);
-            totalAppended += data.appendedCount;
-            lastResult = data;
-        }
-        catch (error) {
-            const message = error instanceof Error ? error.message : String(error);
-            throw new Error(`Chunk ${chunkIndex} failed: ${message}\n` +
-                `${totalAppended} rows from ${chunkIndex - 1} chunk(s) were already appended. ` +
-                `To retry, remove the first ${totalAppended} rows from your file and re-run the command.`);
-        }
-    }
-    if (!lastResult) {
-        throw new Error('Dataset append file must contain at least one row');
-    }
-    printLine(`Appended ${totalAppended} rows to dataset ${sanitizeTerminalText(lastResult.dataset.name)} (${sanitizeTerminalText(lastResult.dataset.id)}). New row count: ${lastResult.dataset.rowCount}`);
-}
 async function appendDatasetRows() {
-    const projectArg = getArg('--project');
-    const datasetInput = getDatasetReferenceInput();
-    const fileArg = getArg('--file');
-    if (!fileArg) {
-        throw new Error('Usage: orizu datasets append [--dataset <datasetId|datasetUrl>] [--project <team/project>] --file <path>');
-    }
-    let datasetId;
-    if (datasetInput) {
-        datasetId = parseDatasetReference(datasetInput).datasetId;
-    }
-    else {
-        const selected = await selectDatasetInteractively(projectArg);
-        datasetId = selected.datasetId;
-    }
-    const file = expandHomePath(fileArg);
-    if (extname(file).toLowerCase() === '.jsonl') {
-        await appendJsonlDatasetRowsInChunks(datasetId, file);
-        return;
-    }
-    // Check file size before reading to prevent OOM on large files (ALI-565).
-    // Wrap statSync in try/catch so missing/inaccessible files get friendly
-    // errors instead of raw Node.js ENOENT/EPERM (ALI-554).
-    let fileSizeBytes;
-    try {
-        fileSizeBytes = statSync(file).size;
-    }
-    catch (error) {
-        const maybeError = error;
-        if (maybeError.code === 'ENOENT') {
-            throw new Error(`File not found: ${file}. Check the path and filename, then retry.`);
-        }
-        if (maybeError.code === 'EPERM' || maybeError.code === 'EACCES') {
-            throw new Error(`Cannot read file: ${file}. Grant folder permission to your terminal app and retry.`);
-        }
-        throw new Error(`Failed to access file ${file}: ${maybeError.message}`);
-    }
-    if (fileSizeBytes > MAX_INPUT_FILE_SIZE_BYTES) {
-        const sizeMb = (fileSizeBytes / (1024 * 1024)).toFixed(1);
-        throw new Error(`Input file is ${sizeMb} MB, which exceeds the 50 MB limit. Split the file into smaller parts and append each separately.`);
-    }
-    const { rows } = parseDatasetFile(file);
-    if (!Array.isArray(rows) || rows.length === 0) {
-        throw new Error('Dataset append file must contain at least one row');
-    }
-    if (rows.length <= APPEND_CHUNK_SIZE_ROWS) {
-        const data = await appendChunk(datasetId, rows);
-        printLine(`Appended ${data.appendedCount} rows to dataset ${sanitizeTerminalText(data.dataset.name)} (${sanitizeTerminalText(data.dataset.id)}). New row count: ${data.dataset.rowCount}`);
-        return;
-    }
-    // Chunked upload for large row counts (ALI-555: track partial progress)
-    let totalAppended = 0;
-    let lastResult = null;
-    const totalChunks = Math.ceil(rows.length / APPEND_CHUNK_SIZE_ROWS);
-    for (let offset = 0; offset < rows.length; offset += APPEND_CHUNK_SIZE_ROWS) {
-        const chunk = rows.slice(offset, offset + APPEND_CHUNK_SIZE_ROWS);
-        const chunkIndex = Math.floor(offset / APPEND_CHUNK_SIZE_ROWS) + 1;
-        printLine(`Uploading chunk ${chunkIndex}/${totalChunks} (${chunk.length} rows)...`);
-        try {
-            const data = await appendChunk(datasetId, chunk);
-            totalAppended += data.appendedCount;
-            lastResult = data;
-        }
-        catch (error) {
-            const msg = error instanceof Error ? error.message : String(error);
-            throw new Error(`Chunk ${chunkIndex}/${totalChunks} failed: ${msg}\n` +
-                `${totalAppended} rows from ${chunkIndex - 1} chunk(s) were already appended. ` +
-                `To retry, remove the first ${totalAppended} rows from your file and re-run the command.`);
-        }
-    }
-    if (lastResult) {
-        if (hasJsonFlag()) {
-            printJson({ dataset: lastResult.dataset, appendedCount: totalAppended });
-            return;
-        }
-        printLine(`Appended ${totalAppended} rows to dataset ${sanitizeTerminalText(lastResult.dataset.name)} (${sanitizeTerminalText(lastResult.dataset.id)}). New row count: ${lastResult.dataset.rowCount}`);
-    }
+    const { appendDatasetWorkflow } = await import('./dataset-append-workflow.js');
+    process.exitCode = await appendDatasetWorkflow(async () => {
+        const projectArg = getArg('--project');
+        const datasetInput = getDatasetReferenceInput();
+        const fileArg = getArg('--file');
+        if (!fileArg)
+            throw new Error('Usage: orizu datasets append [--dataset <datasetId|datasetUrl>] [--project <team/project>] --file <path>');
+        const datasetId = datasetInput ? parseDatasetReference(datasetInput).datasetId : (await selectDatasetInteractively(projectArg)).datasetId;
+        return { datasetId, file: expandHomePath(fileArg) };
+    }, { json: hasJsonFlag(), print: printLine });
 }
 async function editDatasetRows() {
     const projectArg = getArg('--project');
@@ -468,7 +404,8 @@ async function editDatasetRows() {
         const selected = await selectDatasetInteractively(projectArg);
         datasetId = selected.datasetId;
     }
-    await runEditDatasetRows({
+    const { editDatasetRows: runEditDatasetRows } = await import('./dataset-row-workflow.js');
+    const exitCode = await runEditDatasetRows({
         datasetId,
         file: expandHomePath(fileArg),
         json: hasJsonFlag(),
@@ -476,6 +413,8 @@ async function editDatasetRows() {
         printLine,
         sanitize: sanitizeTerminalText,
     });
+    if (exitCode !== 0)
+        process.exitCode = exitCode;
 }
 async function deleteDatasetRows() {
     const projectArg = getArg('--project');
@@ -492,22 +431,17 @@ async function deleteDatasetRows() {
         const selected = await selectDatasetInteractively(projectArg);
         datasetId = selected.datasetId;
     }
-    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/rows`, {
-        method: 'DELETE',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({
-            rowIds,
-        }),
+    const { deleteDatasetRows: runDeleteDatasetRows } = await import('./dataset-row-workflow.js');
+    const exitCode = await runDeleteDatasetRows({
+        datasetId,
+        rowIds,
+        json: hasJsonFlag(),
+        printJson,
+        printLine,
+        sanitize: sanitizeTerminalText,
     });
-    if (!response.ok) {
-        throw new Error(`Delete rows failed: ${await response.text()}`);
-    }
-    const data = await parseJsonResponse(response, 'Dataset delete rows');
-    if (hasJsonFlag()) {
-        printJson({ dataset: data.dataset, deletedCount: data.deletedCount });
-        return;
-    }
-    printLine(`Deleted ${data.deletedCount} rows from dataset ${sanitizeTerminalText(data.dataset.name)} (${sanitizeTerminalText(data.dataset.id)}). New row count: ${data.dataset.rowCount}`);
+    if (exitCode !== 0)
+        process.exitCode = exitCode;
 }
 async function confirmDatasetDeletion(dataset) {
     if (!isInteractiveTerminal()) {
@@ -538,18 +472,15 @@ async function deleteDataset() {
         dataset = await selectDatasetInteractively(projectArg);
     }
     await confirmDatasetDeletion(dataset);
-    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(dataset.datasetId)}`, {
-        method: 'DELETE',
-    });
-    if (!response.ok) {
-        throw new Error(`Delete failed: ${await response.text()}`);
-    }
-    const data = await parseJsonResponse(response, 'Dataset delete');
+    const { deleteDataset: requestDelete } = await import('./dataset-delete-workflow.js');
+    // Only a dataset picked from a project's list has a known project; with
+    // --dataset, --project is never checked against the dataset.
+    const deleted = await requestDelete(dataset.datasetId, dataset.project ?? null);
     if (hasJsonFlag()) {
-        printJson({ dataset: data.dataset, deleted: true });
+        printJson({ dataset: deleted, deleted: true });
         return;
     }
-    printLine(`Deleted dataset ${sanitizeTerminalText(data.dataset.id)}.`);
+    printLine(`Deleted dataset ${sanitizeTerminalText(deleted.id)}.`);
 }
 async function lockDataset() {
     const projectArg = getArg('--project');
@@ -563,20 +494,13 @@ async function lockDataset() {
         const selected = await selectDatasetInteractively(projectArg);
         datasetId = selected.datasetId;
     }
-    const response = await authedFetch(`/api/cli/datasets/${encodeURIComponent(datasetId)}/lock`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify(reason ? { reason } : {}),
-    });
-    if (!response.ok) {
-        throw new Error(`Lock failed: ${await response.text()}`);
-    }
-    const data = await parseJsonResponse(response, 'Dataset lock');
+    const { lockDataset: requestLock } = await import('./dataset-lock-workflow.js');
+    const dataset = await requestLock(datasetId, reason);
     if (hasJsonFlag()) {
-        printJson({ dataset: data.dataset });
+        printJson({ dataset });
         return;
     }
-    printLine(`Locked dataset ${sanitizeTerminalText(data.dataset.name)} (${sanitizeTerminalText(data.dataset.id)}) at ${sanitizeTerminalText(data.dataset.lockedAt)}. Row count: ${data.dataset.rowCount}`);
+    printLine(`Locked dataset ${sanitizeTerminalText(dataset.name)} (${sanitizeTerminalText(dataset.id)}) at ${sanitizeTerminalText(dataset.lockedAt)}. Row count: ${dataset.rowCount}`);
 }
 async function cloneDataset() {
     const projectArg = getArg('--project');
@@ -615,20 +539,16 @@ async function downloadAnnotations() {
     if (!taskId) {
         taskId = await selectTaskIdInteractively();
     }
-    const response = await authedFetch(`/api/cli/tasks/${taskId}/export?format=${format}`);
-    if (!response.ok) {
-        throw new Error(`Download failed: ${await response.text()}`);
-    }
     const fallbackName = `${taskId}.${format}`;
     const filename = outPathArg
         ? expandHomePath(outPathArg)
         : fallbackName;
-    const bytes = new Uint8Array(await response.arrayBuffer());
-    writeFileSync(filename, bytes);
+    const { runTaskExportDownload } = await import('./task-export-workflow.js');
+    await runTaskExportDownload(taskId, format, filename);
     if (hasJsonFlag()) {
         printJson({ taskId, format, savedTo: filename });
         return;
     }
     printLine(`Saved ${format.toUpperCase()} export to ${sanitizeTerminalText(filename)}`);
 }
-export { uploadDataset, listDatasets, pushDataset, downloadDataset, appendDatasetRows, setDatasetReadme, createDatasetVersion, createDatasetSplitSet, editDatasetRows, deleteDatasetRows, deleteDataset, lockDataset, cloneDataset, downloadAnnotations, };
+export { uploadDataset, listDatasets, pushDataset, downloadDataset, appendDatasetRows, setDatasetReadme, createDatasetVersion, createDatasetSplitSet, listDatasetSplitSets, showDatasetSplitSet, editDatasetRows, deleteDatasetRows, deleteDataset, lockDataset, cloneDataset, downloadAnnotations, };

package/dist/dataset-delete-workflow.d.ts

@@ -0,0 +1,4 @@
+export declare function deleteDataset(datasetId: string, project: string | null): Promise<{
+    id: string;
+}>;
+//# sourceMappingURL=dataset-delete-workflow.d.ts.map

package/dist/dataset-delete-workflow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset-delete-workflow.d.ts","sourceRoot":"","sources":["../src/dataset-delete-workflow.ts"],"names":[],"mappings":"AAmEA,wBAAsB,aAAa,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAItG"}