dataiku-sdk 3.6.1 → 3.7.0

package/dist/src/cli/commands/analysis.js

@@ -1,4 +1,4 @@
-import { requiredStringFlag, } from "../coerce.js";
+import { requiredJsonInput, requiredStringFlag, } from "../coerce.js";
 import { executionMode, } from "../flags.js";
 import { readIfExists, skipResult, } from "../output.js";
 import { commandUsage, withUsage, } from "../syntax.js";
@@ -61,4 +61,22 @@ export const analysisCommands = withUsage("analysis", {
             "dss analysis delete ANALYSIS_ID --dry-run --project-key PROJECT",
         ],
     },
+    update: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, commandUsage("analysis", "update"));
+            const definition = requiredJsonInput(f, "The analysis definition is required via --data, --data-file, or --stdin (dss analysis get, edited).");
+            await c.analyses.update(a[0], definition, f["project-key"]);
+            return { updated: a[0], resource: "analysis", };
+        },
+        description: "Replace a visual analysis definition (name, script steps, charts, tags) with the object from dss analysis get, edited.",
+        examples: ["dss analysis update ANALYSIS_ID --data-file analysis.json",],
+    },
+    "list-ml-tasks": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, commandUsage("analysis", "list-ml-tasks"));
+            return c.analyses.listMlTasks(a[0], f["project-key"]);
+        },
+        description: "List the ML tasks of one visual analysis (whole project: dss ml-task list).",
+        examples: ["dss analysis list-ml-tasks ANALYSIS_ID",],
+    },
 });

package/dist/src/cli/commands/bundle.js

@@ -131,4 +131,26 @@ export const bundleCommands = withUsage("bundle", {
         description: "Delete an imported Automation-node bundle.",
         examples: ["dss bundle delete-imported v1",],
     },
+    "get-exported": {
+        handler: (c, a, f) => c.bundles.getExported(a[0], f["project-key"]),
+        description: "Get an exported bundle's details (content summary, export manifest, changelog).",
+        examples: ["dss bundle get-exported v1",],
+    },
+    "create-project": {
+        handler: async (c, _a, f) => {
+            const file = f["file"];
+            const archive = f["archive-path"];
+            if ((typeof file === "string") === (typeof archive === "string")) {
+                throw new UsageError("Pass exactly one of --file PATH (local bundle zip) or --archive-path PATH (zip on the Automation node).", "missing_required_flag");
+            }
+            const folder = f["project-folder"];
+            const result = await c.bundles.createProjectFromBundle(typeof file === "string" ? { filePath: file, } : { archivePath: archive, }, folder);
+            return result ?? { created: true, resource: "bundle", };
+        },
+        description: "Automation node (global admin): create a new project from a bundle, uploading --file PATH or using --archive-path PATH on the node host; --project-folder places it.",
+        examples: [
+            "dss bundle create-project --file bundle-v1.zip",
+            "dss bundle create-project --archive-path /data/bundles/v1.zip",
+        ],
+    },
 });

package/dist/src/cli/commands/connection.js

@@ -1,3 +1,4 @@
+import { DataikuError, } from "../../errors.js";
 import { sanitizeErrorSecrets, sanitizeSecrets, } from "../../utils/secret-sanitize.js";
 import { requiredJsonInput, } from "../coerce.js";
 import { executionMode, } from "../flags.js";
@@ -26,6 +27,7 @@ const SENSITIVE_CONNECTION_KEYS = {
     refreshtoken: true,
     secret: true,
     secretkey: true,
+    sessiontoken: true,
     sharesecret: true,
     token: true,
 };
@@ -97,12 +99,34 @@ export const connectionCommands = withUsage("connection", {
         handler: async (c, a) => {
             const usage = commandUsage("connection", "get");
             requireArgs(a, 1, usage);
-            const details = await c.connections.adminGet(requireConnectionName(a[0], usage));
-            return sanitizeConnectionSecrets(details);
+            const name = requireConnectionName(a[0], usage);
+            try {
+                const details = await c.connections.adminGet(name);
+                return sanitizeConnectionSecrets(details);
+            }
+            catch (error) {
+                if (error instanceof DataikuError && error.status === 403) {
+                    // The admin endpoint refuses non-admin keys for every connection,
+                    // including ones they can query; status, code, and exit stay as is.
+                    error.retryHint =
+                        "connection get reads the admin definition. For a connection this key can use, run `dss connection info NAME`; `dss doctor` shows which identity the key acts as.";
+                }
+                throw error;
+            }
         },
         description: "Get a connection by name (admin). Credential-bearing params (e.g. params.password) are redacted in output.",
         examples: ["dss connection get postgres",],
     },
+    info: {
+        handler: async (c, a) => {
+            const usage = commandUsage("connection", "info");
+            requireArgs(a, 1, usage);
+            const details = await c.connections.info(requireConnectionName(a[0], usage));
+            return sanitizeConnectionSecrets(details);
+        },
+        description: "Read a connection's usage view (no admin privilege required): type, params, and credentials mode for every connection the key can query, where `connection get` (admin) answers 403. Credential-bearing params (e.g. params.password) are redacted in output.",
+        examples: ["dss connection info postgres",],
+    },
     create: {
         handler: async (c, _a, f) => {
             const usage = commandUsage("connection", "create");

package/dist/src/cli/commands/data-quality.js

@@ -1,5 +1,5 @@
 import { deepMerge, } from "../../utils/deep-merge.js";
-import { num, parseBooleanOption, requiredJsonInput, } from "../coerce.js";
+import { num, parseBooleanOption, requiredJsonInput, splitCsvFlag, } from "../coerce.js";
 import { executionMode, } from "../flags.js";
 import { encodedProjectEndpoint, readIfExists, skipResult, } from "../output.js";
 import { commandUsage, withUsage, } from "../syntax.js";
@@ -41,6 +41,38 @@ export const dataQualityCommands = withUsage("data-quality", {
         description: "Get the aggregate data quality status for a dataset.",
         examples: ["dss data-quality status orders",],
     },
+    "instance-status": {
+        handler: (c) => c.dataQuality.instanceStatus(),
+        description: "Data quality status of every monitored project you can read, keyed by project key (ok/warning/error/empty rule counts, last run).",
+        examples: ["dss data-quality instance-status",],
+    },
+    "partitions-status": {
+        handler: (c, a, f) => c.dataQuality.partitionsStatus(a[0], {
+            projectKey: f["project-key"],
+            partitions: splitCsvFlag(f["partitions"]),
+        }),
+        description: "Last data quality outcome for specific partitions of a dataset (--partitions P1,P2); a non-partitioned dataset needs none.",
+        examples: ["dss data-quality partitions-status orders --partitions 2026-01,2026-02",],
+    },
+    "delete-history": {
+        handler: async (c, a, f) => {
+            const partition = f["partition"] ?? "NP";
+            const pk = f["project-key"];
+            if (executionMode(f).dryRun) {
+                return {
+                    dryRun: true,
+                    action: "delete-history",
+                    resource: "data-quality",
+                    dataset: a[0],
+                    partition,
+                };
+            }
+            await c.dataQuality.deleteHistory(a[0], { projectKey: pk, partition, });
+            return { deleted: "history", resource: "data-quality", dataset: a[0], partition, };
+        },
+        description: "Delete data quality rule history of a dataset partition (--partition, default NP; ALL for every partition).",
+        examples: ["dss data-quality delete-history orders --partition ALL --dry-run",],
+    },
     "create-rule": {
         handler: async (c, a, f) => {
             requireArgs(a, 1, commandUsage("data-quality", "create-rule"));

package/dist/src/cli/commands/dataset.js

@@ -1,7 +1,8 @@
+import { assertDatasetTypeCreatable, } from "../../resources/dataset-create.js";
 import { deepMerge, } from "../../utils/deep-merge.js";
 import { isRecord, } from "../../utils/records.js";
 import { compareStrings, stableHash, } from "../../utils/stable-hash.js";
-import { jsonInput, num, schemaColumnsInput, unknownJsonInput, } from "../coerce.js";
+import { jsonInput, num, schemaColumnsInput, splitCsvFlag, unknownJsonInput, } from "../coerce.js";
 import { executionMode, } from "../flags.js";
 import { datasetSourceSummary, } from "../helpers/dataset.js";
 import { moveCreatedItemsToZone, resolveFlowZoneIdFromFlags, } from "../helpers/flow-zone.js";
@@ -96,6 +97,14 @@ export function compareDatasetSchemas(expected, actual) {
         differencesTruncated: acc.items.length < acc.total,
     };
 }
+/** `--columns` / `--partitions` read selection (served by the POST variant of the data endpoint). */
+function dataSelectionFromFlags(f) {
+    const columns = splitCsvFlag(f["columns"]);
+    return {
+        ...(columns.length > 0 ? { columns, } : {}),
+        ...(typeof f["partitions"] === "string" ? { partitions: f["partitions"], } : {}),
+    };
+}
 export const datasetCommands = withUsage("dataset", {
     list: {
         handler: (c, _a, f) => c.datasets.list(f["project-key"]),
@@ -225,6 +234,7 @@ export const datasetCommands = withUsage("dataset", {
                 maxRows,
                 projectKey: f["project-key"],
                 timeoutMs: num(f["timeout"], "--timeout"),
+                ...dataSelectionFromFlags(f),
             });
             if (result.truncated) {
                 enqueueCliWarning({
@@ -239,8 +249,11 @@ export const datasetCommands = withUsage("dataset", {
             }
             return result;
         },
-        description: "Preview dataset rows (--rows is an alias for --max-rows). Returns { columns, rows, rowCount, truncated, limit }; when the dataset has more rows than the cap, truncated is true and a dataset_preview_truncated warning is written to stderr.",
-        examples: ["dss dataset preview orders", "dss dataset preview orders --rows 5",],
+        description: "Preview dataset rows (--rows is an alias for --max-rows); --columns COLS and --partitions SPEC narrow the read. Returns { columns, rows, rowCount, truncated, limit }; a dataset_preview_truncated warning on stderr flags more rows.",
+        examples: [
+            "dss dataset preview orders",
+            "dss dataset preview orders --rows 5 --columns id,amount",
+        ],
     },
     "assert-count": {
         handler: async (c, a, f) => {
@@ -291,6 +304,22 @@ export const datasetCommands = withUsage("dataset", {
         description: "Get dataset-level metadata.",
         examples: ["dss dataset metadata orders",],
     },
+    "sync-hive-metastore": {
+        handler: async (c, a, f) => {
+            await c.datasets.synchronizeHiveMetastore(a[0], f["project-key"]);
+            return { synchronized: a[0], resource: "dataset", };
+        },
+        description: "Create or update the Hive table of an HDFS dataset to match its schema (Hive metastore sync). HDFS datasets only.",
+        examples: ["dss dataset sync-hive-metastore web_logs",],
+    },
+    "update-from-hive": {
+        handler: async (c, a, f) => {
+            await c.datasets.updateFromHive(a[0], f["project-key"]);
+            return { updated: a[0], resource: "dataset", };
+        },
+        description: "Update an HDFS dataset's path, schema, partitioning, and format from its Hive metastore table. HDFS datasets only.",
+        examples: ["dss dataset update-from-hive web_logs --plan",],
+    },
     "metadata-set": {
         handler: async (c, a, f) => {
             const usage = commandUsage("dataset", "metadata-set");
@@ -333,6 +362,7 @@ export const datasetCommands = withUsage("dataset", {
             if (!name || !dsType) {
                 throw new UsageError(`--name and --type are required. Usage: ${commandUsage("dataset", "create")}`);
             }
+            assertDatasetTypeCreatable(dsType);
             if (!connection && dsType.toLowerCase() !== "uploadedfiles") {
                 throw new UsageError("--connection is required unless --type is UploadedFiles.");
             }
@@ -472,6 +502,7 @@ export const datasetCommands = withUsage("dataset", {
                 projectKey: f["project-key"],
                 limit: num(f["limit"], "--limit"),
                 rawData: f["raw-data"] === true,
+                ...dataSelectionFromFlags(f),
             });
             if (result.truncated) {
                 enqueueCliWarning({
@@ -495,7 +526,7 @@ export const datasetCommands = withUsage("dataset", {
             }
             return result;
         },
-        description: "Download up to --limit rows (default 100k) as CSV and return { path, rows, truncated, limit }. Formula-like cells are neutralized for spreadsheets; --raw-data preserves exact bytes. Warnings report truncation and the default output path.",
+        description: "Download up to --limit rows (default 100k) as CSV and return { path, rows, truncated, limit }; --columns COLS and --partitions SPEC narrow the read. Formula-like cells are neutralized for spreadsheets; --raw-data preserves exact bytes.",
         examples: [
             "dss dataset download orders",
             "dss dataset download orders --output ./data/",

package/dist/src/cli/commands/discussion.js

@@ -1,3 +1,4 @@
+import { jsonInput, } from "../coerce.js";
 import { commandUsage, withUsage, } from "../syntax.js";
 import { requireArgs, UsageError, } from "../usage.js";
 export const discussionCommands = withUsage("discussion", {
@@ -41,4 +42,18 @@ export const discussionCommands = withUsage("discussion", {
         description: "Add a reply to an existing discussion.",
         examples: ["dss discussion reply DATASET customers d123 --text Done",],
     },
+    update: {
+        handler: async (c, a, f) => {
+            const pk = f["project-key"];
+            const body = jsonInput(f);
+            const topic = f["topic"];
+            if ((body === undefined) === (typeof topic !== "string")) {
+                throw new UsageError("Pass exactly one of --topic TEXT or --data/--data-file/--stdin.", "missing_required_flag");
+            }
+            const next = body ?? { ...await c.discussions.get(a[0], a[1], a[2], pk), topic, };
+            return c.discussions.update(a[0], a[1], a[2], next, pk);
+        },
+        description: "Update a discussion: --topic TEXT edits the topic of the current discussion, or --data sends a full discussion object from get (e.g. to move it to another object of the project).",
+        examples: ['dss discussion update DATASET orders L8gkpoI6 --topic "Schema change (edited)"',],
+    },
 });

package/dist/src/cli/commands/doctor.js

@@ -5,7 +5,7 @@ export const doctorCommands = withUsage("doctor", {
             const { runDoctor, } = await import("../doctor.js");
             return (await runDoctor(f)).result;
         },
-        description: "Run JSON diagnostics for DSS credentials, connectivity, and project access.",
+        description: "Run JSON diagnostics for DSS credentials, connectivity, and project access, and report the identity (whoami: user, groups, auth source) the API key acts as.",
         examples: ["dss doctor", "dss doctor --project-key MYPROJ", "dss doctor --capabilities --fast",],
     },
 });

package/dist/src/cli/commands/flow.d.ts

@@ -0,0 +1,5 @@
+import type { SchemaPropagationOptions } from "../../resources/flow.js";
+import type { CommandMeta } from "../types.js";
+/** Propagation options from flags; shared with the `--plan` builder. */
+export declare function schemaPropagationOptionsFromFlags(flags: Record<string, string | boolean>): SchemaPropagationOptions;
+export declare const flowCommands: Record<string, CommandMeta>;

package/dist/src/cli/commands/flow.js

@@ -0,0 +1,57 @@
+import { writeResponseToFile, } from "../../utils/response-file.js";
+import { splitCsvFlag, } from "../coerce.js";
+import { documentationTemplateFromFlags, runDocumentationCommand, taskWaitOptions, } from "../helpers/documentation.js";
+import { commandUsage, withUsage, } from "../syntax.js";
+import { requireArgs, } from "../usage.js";
+/** Propagation options from flags; shared with the `--plan` builder. */
+export function schemaPropagationOptionsFromFlags(flags) {
+    const excludedRecipes = splitCsvFlag(flags["stop-at"]);
+    const markAsOkRecipes = splitCsvFlag(flags["mark-ok"]);
+    return {
+        ...(flags["no-auto-rebuild"] === true ? { autoRebuild: false, } : {}),
+        ...(excludedRecipes.length > 0 ? { excludedRecipes, } : {}),
+        ...(markAsOkRecipes.length > 0 ? { markAsOkRecipes, } : {}),
+    };
+}
+export const flowCommands = withUsage("flow", {
+    "propagate-schema": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, commandUsage("flow", "propagate-schema"));
+            const opts = {
+                ...schemaPropagationOptionsFromFlags(f),
+                projectKey: f["project-key"],
+            };
+            if (f["wait"] === true) {
+                return c.flow.propagateSchemaAndWait(a[0], { ...opts, ...taskWaitOptions(f), });
+            }
+            return c.flow.propagateSchema(a[0], opts);
+        },
+        description: "Propagate a dataset's schema change through all downstream recipes and datasets (UI schema propagation). Rebuilds as needed unless --no-auto-rebuild; --stop-at / --mark-ok RECIPES limit it. Returns the DSS task; --wait waits. One recipe only: dss recipe update-schema.",
+        examples: [
+            "dss flow propagate-schema orders_raw --wait",
+            "dss flow propagate-schema orders_raw --stop-at compute_report --no-auto-rebuild --plan",
+        ],
+    },
+    "generate-documentation": {
+        handler: async (c, _a, f) => {
+            const pk = f["project-key"];
+            const task = await c.flow.generateDocumentation(documentationTemplateFromFlags(f), pk);
+            return runDocumentationCommand(c, f, task, (exportId) => c.flow.downloadDocumentation(exportId, pk));
+        },
+        description: "Generate the flow documentation (Word docx) from the DSS default template, an uploaded --template-file, or a template in a managed folder (--folder FOLDER_ID --path PATH). Returns the DSS future; --wait waits; --output PATH waits and downloads the document.",
+        examples: [
+            "dss flow generate-documentation --output flow.docx",
+            "dss flow generate-documentation --template-file template.docx --wait",
+        ],
+    },
+    "download-documentation": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, commandUsage("flow", "download-documentation"));
+            const output = f["output"];
+            const res = await c.flow.downloadDocumentation(a[0], f["project-key"]);
+            return { path: output, bytes: await writeResponseToFile(output, res), };
+        },
+        description: "Download a generated flow documentation by the exportId from a finished generate-documentation future.",
+        examples: ["dss flow download-documentation EXPORT_ID --output flow.docx",],
+    },
+});

package/dist/src/cli/commands/future.js

@@ -4,6 +4,14 @@ import { planResult, } from "../output.js";
 import { commandUsage, withUsage, } from "../syntax.js";
 import { requireArgs, } from "../usage.js";
 export const futureCommands = withUsage("future", {
+    list: {
+        handler: (c, _a, f) => c.futures.list({
+            allUsers: f["all-users"] === true,
+            withScenarios: f["with-scenarios"] === true,
+        }),
+        description: "List long tasks in progress on the instance (DSS futures): your own, or every user's with --all-users; --with-scenarios adds running scenarios.",
+        examples: ["dss future list", "dss future list --all-users --with-scenarios",],
+    },
     get: {
         handler: (c, a) => {
             requireArgs(a, 1, commandUsage("future", "get"));

package/dist/src/cli/commands/index.js

@@ -91,6 +91,12 @@ export const commands = {
     get "future"() {
         return require("./future.js").futureCommands;
     },
+    get "flow"() {
+        return require("./flow.js").flowCommands;
+    },
+    get "mlflow"() {
+        return require("./mlflow.js").mlflowCommands;
+    },
     get "flow-zone"() {
         return require("./flow-zone.js").flowZoneCommands;
     },

package/dist/src/cli/commands/job.js

@@ -3,9 +3,26 @@ import { dirname, resolve, } from "node:path";
 import { asRecord, } from "../../utils/records.js";
 import { jobBuildTargetTypeFromFlags, jobLogFilterFromFlag, maxLogLinesFromFlags, num, } from "../coerce.js";
 import { executionMode, } from "../flags.js";
-import { encodedProjectEndpoint, } from "../output.js";
+import { encodedProjectEndpoint, enqueueCliWarning, } from "../output.js";
 import { commandUsage, withUsage, } from "../syntax.js";
 import { requireArgs, UsageError, } from "../usage.js";
+/**
+ * With an empty output schema DSS ends a dataset build DONE after writing no
+ * columns and no rows, without an error. Flag that after a successful build so
+ * it is not mistaken for real output.
+ */
+async function warnIfBuiltDatasetHasNoColumns(c, target, targetType, success, projectKey) {
+    if (!success || targetType !== "DATASET")
+        return;
+    const schema = await c.datasets.schema(target, projectKey).catch(() => undefined);
+    if (!schema || schema.columns.length > 0)
+        return;
+    enqueueCliWarning({
+        code: "built_dataset_has_no_columns",
+        dataset: target,
+        hint: "The build succeeded but the dataset schema is empty, so no data was written. For a visual or SQL query recipe, run dss recipe update-schema RECIPE (or rebuild with --auto-update-schema).",
+    });
+}
 // ---------------------------------------------------------------------------
 // Utility helpers
 // ---------------------------------------------------------------------------
@@ -236,7 +253,7 @@ export const jobCommands = withUsage("job", {
             await writeFile(outputPath, log.endsWith("\n") ? log : `${log}\n`, "utf-8");
             return outputPath;
         },
-        description: "Get public API job log output. Use --errors-only (or --log-filter errors) to surface just error/traceback lines, and --output PATH to write the log to a file (stdout returns the path). --log-id is accepted for UI parity but DSS API-key auth cannot select browser-only cat-activity-log files.",
+        description: "Get public API job log output; find why a job failed. Use --errors-only (or --log-filter errors) to surface just error/traceback lines, and --output PATH to write the log to a file (stdout returns the path). --log-id is accepted for UI parity but DSS API-key auth cannot select browser-only cat-activity-log files.",
         examples: [
             "dss job log JOB_ID",
             "dss job log JOB_ID --activity main --max-log-lines 200",
@@ -270,6 +287,7 @@ export const jobCommands = withUsage("job", {
             requireArgs(a, 1, commandUsage("job", "build"));
             const pk = f["project-key"];
             const options = {
+                autoUpdateSchema: f["auto-update-schema"] === true,
                 buildMode: f["build-mode"],
                 partition: f["partition"],
                 pollIntervalMs: num(f["poll-interval"], "--poll-interval"),
@@ -288,11 +306,13 @@ export const jobCommands = withUsage("job", {
                 };
             }
             if (f["wait"] === true) {
-                return c.jobs.buildAndWait(a[0], { ...options, projectKey: pk, });
+                const result = await c.jobs.buildAndWait(a[0], { ...options, projectKey: pk, });
+                await warnIfBuiltDatasetHasNoColumns(c, a[0], options.targetType, result.success, pk);
+                return result;
             }
             return c.jobs.build(a[0], { ...options, projectKey: pk, });
         },
-        description: "Start a dataset or managed-folder build, optionally waiting for completion.",
+        description: "Start a dataset or managed-folder build, optionally waiting for completion. --auto-update-schema lets DSS update each recipe's output schema before it runs.",
         examples: [
             "dss job build orders",
             "dss job build orders --build-mode RECURSIVE_BUILD --wait",
@@ -304,6 +324,7 @@ export const jobCommands = withUsage("job", {
             requireArgs(a, 1, commandUsage("job", "build-and-wait"));
             const pk = f["project-key"];
             const options = {
+                autoUpdateSchema: f["auto-update-schema"] === true,
                 buildMode: f["build-mode"],
                 includeLogs: f["include-logs"] === true,
                 logFilter: jobLogFilterFromFlag(f["log-filter"]),
@@ -325,9 +346,11 @@ export const jobCommands = withUsage("job", {
                     method: "POST",
                 };
             }
-            return c.jobs.buildAndWait(a[0], { ...options, projectKey: pk, });
+            const result = await c.jobs.buildAndWait(a[0], { ...options, projectKey: pk, });
+            await warnIfBuiltDatasetHasNoColumns(c, a[0], options.targetType, result.success, pk);
+            return result;
         },
-        description: "Build a dataset or managed folder and wait for completion.",
+        description: "Build a dataset or managed folder and wait for completion. --auto-update-schema lets DSS update each recipe's output schema before it runs; a successful dataset build that leaves an empty schema emits a built_dataset_has_no_columns warning.",
         examples: [
             "dss job build-and-wait orders",
             "dss job build-and-wait orders --include-logs --log-filter stdout --summary",

package/dist/src/cli/commands/metrics.js

@@ -1,5 +1,6 @@
+import { unknownJsonInput, } from "../coerce.js";
 import { commandUsage, withUsage, } from "../syntax.js";
-import { requireArgs, } from "../usage.js";
+import { requireArgs, UsageError, } from "../usage.js";
 export const metricsCommands = withUsage("metrics", {
     "dataset-get": {
         handler: (c, a, f) => {
@@ -17,6 +18,25 @@ export const metricsCommands = withUsage("metrics", {
         description: "Compute the DSS-configured metrics for a dataset.",
         examples: ["dss metrics dataset-compute customers",],
     },
+    "dataset-run-checks": {
+        handler: (c, a, f) => {
+            const data = unknownJsonInput(f);
+            const checks = data && typeof data === "object" && "checks" in data ? data.checks : undefined;
+            if (data !== undefined && !Array.isArray(checks)) {
+                throw new UsageError('--data must be {"checks": [...]}.', "validation_failed");
+            }
+            return c.metrics.runDatasetChecks(a[0], {
+                projectKey: f["project-key"],
+                partitions: f["partitions"],
+                ...(Array.isArray(checks) ? { checks, } : {}),
+            });
+        },
+        description: 'Run the checks configured on a dataset, or the {"checks": [...]} definitions passed as JSON, and return their outcomes.',
+        examples: [
+            "dss metrics dataset-run-checks customers",
+            "dss metrics dataset-run-checks customers --data-file checks.json",
+        ],
+    },
     "dataset-history": {
         handler: (c, a, f) => {
             requireArgs(a, 2, commandUsage("metrics", "dataset-history"));

package/dist/src/cli/commands/ml-task.d.ts

@@ -1,2 +1,7 @@
+import type { MlTaskCreateFields, MlTaskReguessOptions } from "../../resources/ml-tasks.js";
 import type { CommandMeta } from "../types.js";
+/** Task definition flags shared by `create`, `create-for-dataset`, and their --plan. */
+export declare function mlTaskFieldsFromFlags(flags: Record<string, string | boolean>, usage: string): MlTaskCreateFields;
+/** `reguess` flags → SDK options (shared with --plan). */
+export declare function mlTaskReguessOptionsFromFlags(flags: Record<string, string | boolean>): MlTaskReguessOptions;
 export declare const mlTaskCommands: Record<string, CommandMeta>;

package/dist/src/cli/commands/ml-task.js

@@ -1,5 +1,6 @@
-import { num, requiredJsonInput, requiredStringFlag, } from "../coerce.js";
+import { num, parseBooleanOption, requiredJsonInput, requiredStringFlag, splitCsvFlag, } from "../coerce.js";
 import { executionMode, } from "../flags.js";
+import { trainedModelCommands, } from "../helpers/trained-model.js";
 import { commandUsage, withUsage, } from "../syntax.js";
 import { requireArgs, UsageError, } from "../usage.js";
 function optionalStringFlag(flags, name) {
@@ -17,27 +18,47 @@ function taskType(flags, usage) {
         return normalized;
     throw new UsageError("--task-type must be PREDICTION or CLUSTERING.", "invalid_enum");
 }
+/** Task definition flags shared by `create`, `create-for-dataset`, and their --plan. */
+export function mlTaskFieldsFromFlags(flags, usage) {
+    const normalizedTaskType = taskType(flags, usage);
+    const targetVariable = optionalStringFlag(flags, "target");
+    if (normalizedTaskType === "PREDICTION" && targetVariable === undefined) {
+        throw new UsageError("--target is required for PREDICTION ML tasks.", "missing_required_flag");
+    }
+    const timeseriesIdentifiers = splitCsvFlag(flags["timeseries-ids"]);
+    return {
+        taskType: normalizedTaskType,
+        targetVariable,
+        predictionType: optionalStringFlag(flags, "prediction-type"),
+        timeVariable: optionalStringFlag(flags, "time-variable"),
+        ...(timeseriesIdentifiers.length > 0 ? { timeseriesIdentifiers, } : {}),
+        backendType: optionalStringFlag(flags, "backend-type"),
+        guessPolicy: optionalStringFlag(flags, "guess-policy"),
+    };
+}
+/** `reguess` flags → SDK options (shared with --plan). */
+export function mlTaskReguessOptionsFromFlags(flags) {
+    const timeseriesIdentifiers = splitCsvFlag(flags["timeseries-ids"]);
+    return {
+        predictionType: optionalStringFlag(flags, "prediction-type"),
+        targetVariable: optionalStringFlag(flags, "target"),
+        timeVariable: optionalStringFlag(flags, "time-variable"),
+        ...(timeseriesIdentifiers.length > 0 ? { timeseriesIdentifiers, } : {}),
+        ...(flags["full-reguess"] !== undefined
+            ? { fullReguess: parseBooleanOption(flags["full-reguess"], "--full-reguess"), }
+            : {}),
+    };
+}
 export const mlTaskCommands = withUsage("ml-task", {
     create: {
         handler: async (c, a, f) => {
             const usage = commandUsage("ml-task", "create");
             requireArgs(a, 1, usage);
-            const projectKey = f["project-key"];
-            const normalizedTaskType = taskType(f, usage);
-            const targetVariable = optionalStringFlag(f, "target");
-            if (normalizedTaskType === "PREDICTION" && targetVariable === undefined) {
-                throw new UsageError("--target is required for PREDICTION ML tasks.", "missing_required_flag");
-            }
-            const options = {
+            const created = await c.mlTasks.create({
                 analysisId: a[0],
-                taskType: normalizedTaskType,
-                targetVariable,
-                predictionType: optionalStringFlag(f, "prediction-type"),
-                backendType: optionalStringFlag(f, "backend-type"),
-                guessPolicy: optionalStringFlag(f, "guess-policy"),
-                projectKey,
-            };
-            const created = await c.mlTasks.create(options);
+                ...mlTaskFieldsFromFlags(f, usage),
+                projectKey: f["project-key"],
+            });
             return { created: created.mlTaskId, resource: "ml-task", analysisId: a[0], ...created, };
         },
         description: "Create a prediction or clustering task in an analysis.",
@@ -173,4 +194,53 @@ export const mlTaskCommands = withUsage("ml-task", {
             "dss ml-task delete ANALYSIS_ID TASK_ID --dry-run --project-key PROJECT",
         ],
     },
+    list: {
+        handler: (c, _a, f) => c.mlTasks.list(f["project-key"]),
+        description: "List every ML task of the project with its visual analysis (one analysis: dss analysis list-ml-tasks).",
+        examples: ["dss ml-task list",],
+    },
+    "create-for-dataset": {
+        handler: async (c, a, f) => {
+            const usage = commandUsage("ml-task", "create-for-dataset");
+            requireArgs(a, 1, usage);
+            const created = await c.mlTasks.createForDataset({
+                inputDataset: a[0],
+                ...mlTaskFieldsFromFlags(f, usage),
+                projectKey: f["project-key"],
+            });
+            return { created: created.mlTaskId, resource: "ml-task", ...created, };
+        },
+        description: "Create a new visual analysis on a dataset with one prediction, clustering, or forecasting task (--prediction-type TIMESERIES_FORECAST --time-variable COL [--timeseries-ids COLS]). DSS guesses settings asynchronously: poll status until guessing is false.",
+        examples: [
+            "dss ml-task create-for-dataset customers --task-type prediction --target churn",
+            "dss ml-task create-for-dataset sales --task-type prediction --target amount --prediction-type TIMESERIES_FORECAST --time-variable day",
+        ],
+    },
+    reguess: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, commandUsage("ml-task", "reguess"));
+            await c.mlTasks.reguess(a[0], a[1], mlTaskReguessOptionsFromFlags(f), f["project-key"]);
+            return { reguessed: a[1], resource: "ml-task", analysisId: a[0], };
+        },
+        description: "Re-guess an ML task's settings: all of them, or after changing one core parameter (--prediction-type, --target, --time-variable, --timeseries-ids), only the impacted ones unless --full-reguess true.",
+        examples: ["dss ml-task reguess ANALYSIS_ID TASK_ID --target churn_flag",],
+    },
+    "reguess-forecasting": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, commandUsage("ml-task", "reguess-forecasting"));
+            await c.mlTasks.reguessForecasting(a[0], a[1], requiredJsonInput(f, "Forecasting parameters are required via --data, --data-file, or --stdin (forecastHorizon, validationHorizons, timestepParams, updateAlgorithmSettings)."), f["project-key"]);
+            return { reguessed: a[1], resource: "ml-task", analysisId: a[0], };
+        },
+        description: "Time series forecasting tasks: change forecasting parameters (forecastHorizon, validationHorizons, timestepParams {timeunit, numberOfTimeunits, ...}, updateAlgorithmSettings) and re-guess impacted algorithm settings.",
+        examples: [
+            'dss ml-task reguess-forecasting ANALYSIS_ID TASK_ID --data \'{"forecastHorizon":7,"updateAlgorithmSettings":true}\'',
+        ],
+    },
+    ...trainedModelCommands({
+        resource: "ml-task",
+        ids: "ANALYSIS_ID TASK_ID MODEL_ID",
+        noun: "lab model",
+        model: (c, a, pk) => c.mlTasks.model(a[0], a[1], a[2], pk),
+        downloadDocumentation: (c, exportId, pk) => c.mlTasks.downloadModelDocumentation(exportId, pk),
+    }),
 });

package/dist/src/cli/commands/mlflow.d.ts

@@ -0,0 +1,11 @@
+import type { MlflowDeployRunOptions, MlflowExperimentsDatasetOptions, MlflowInferenceInfo } from "../../resources/mlflow-extension.js";
+import type { CommandMeta } from "../types.js";
+type Flags = Record<string, string | boolean>;
+/** `dss mlflow set-inference-info` flags → SDK inference info (shared with --plan). */
+export declare function inferenceInfoFromFlags(runId: string, f: Flags): MlflowInferenceInfo;
+/** `dss mlflow deploy-run` flags → SDK deploy options (shared with --plan). */
+export declare function deployRunOptionsFromFlags(runId: string, savedModelId: string, f: Flags): MlflowDeployRunOptions;
+/** `dss mlflow create-experiments-dataset` flags → SDK options (shared with --plan). */
+export declare function experimentsDatasetOptionsFromFlags(datasetName: string, f: Flags): MlflowExperimentsDatasetOptions;
+export declare const mlflowCommands: Record<string, CommandMeta>;
+export {};