dataiku-sdk 0.11.0 → 0.12.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 clssck
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/packages/types/src/index.d.ts

@@ -147,6 +147,10 @@ export declare const RecipeCreateOptionsSchema: import("@sinclair/typebox").TObj
     outputConnection: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     joinOn: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
     joinType: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    fuzzyOn: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnion<[import("@sinclair/typebox").TString, import("@sinclair/typebox").TArray<import("@sinclair/typebox").TString>]>>;
+    fuzzyDistance: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    fuzzyThreshold: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    fuzzyNormalize: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
     projectKey: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     outputFolder: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
@@ -269,6 +273,11 @@ export declare const ScenarioStepRunSchema: import("@sinclair/typebox").TObject<
     name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     outcome: import("@sinclair/typebox").TString;
+    warningCount: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    warnings: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+        type: import("@sinclair/typebox").TString;
+        count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    }>>>;
 }>;
 export type ScenarioStepRun = Static<typeof ScenarioStepRunSchema>;
 export declare const ScenarioWaitResultSchema: import("@sinclair/typebox").TObject<{
@@ -284,6 +293,11 @@ export declare const ScenarioWaitResultSchema: import("@sinclair/typebox").TObje
         name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         type: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
         outcome: import("@sinclair/typebox").TString;
+        warningCount: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        warnings: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TArray<import("@sinclair/typebox").TObject<{
+            type: import("@sinclair/typebox").TString;
+            count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        }>>>;
     }>>>;
 }>;
 export type ScenarioWaitResult = Static<typeof ScenarioWaitResultSchema>;

package/dist/packages/types/src/index.js

@@ -195,6 +195,10 @@ export const RecipeCreateOptionsSchema = Type.Object({
     outputConnection: Type.Optional(Type.String()),
     joinOn: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String()),])),
     joinType: Type.Optional(Type.String()),
+    fuzzyOn: Type.Optional(Type.Union([Type.String(), Type.Array(Type.String()),])),
+    fuzzyDistance: Type.Optional(Type.String()),
+    fuzzyThreshold: Type.Optional(Type.Number()),
+    fuzzyNormalize: Type.Optional(Type.Boolean()),
     projectKey: Type.Optional(Type.String()),
     outputFolder: Type.Optional(Type.String()),
 });
@@ -318,6 +322,11 @@ export const ScenarioStepRunSchema = Type.Object({
     name: Type.Optional(Type.String()),
     type: Type.Optional(Type.String()),
     outcome: Type.String(),
+    warningCount: Type.Optional(Type.Number()),
+    warnings: Type.Optional(Type.Array(Type.Object({
+        type: Type.String(),
+        count: Type.Optional(Type.Number()),
+    }, { additionalProperties: false, }))),
 }, { additionalProperties: false, });
 export const ScenarioWaitResultSchema = Type.Object({
     scenarioId: Type.String(),

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

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const analysisCommands: Record<string, CommandMeta>;

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

@@ -0,0 +1,66 @@
+import { requiredStringFlag, } from "../coerce.js";
+import { readIfExists, skipResult, } from "../output.js";
+import { requireArgs, } from "../usage.js";
+export const analysisCommands = {
+    list: {
+        handler: (c, _a, f) => c.analyses.list(f["project-key"]),
+        usage: "dss analysis list [--project-key KEY]",
+        description: "List Visual ML analyses in a project.",
+        examples: ["dss analysis list --project-key PROJECT",],
+    },
+    get: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss analysis get <analysisId> [--project-key KEY]");
+            return c.analyses.get(a[0], f["project-key"]);
+        },
+        usage: "dss analysis get <analysisId> [--project-key KEY]",
+        description: "Get a Visual ML analysis.",
+        examples: ["dss analysis get ANALYSIS_ID --project-key PROJECT",],
+    },
+    create: {
+        handler: async (c, _a, f) => {
+            const usage = "dss analysis create --input-dataset DS [--dry-run] [--project-key KEY]";
+            const inputDataset = requiredStringFlag(f, "input-dataset", usage);
+            const projectKey = f["project-key"];
+            const options = { inputDataset, projectKey, };
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "create",
+                    resource: "analysis",
+                    payload: options,
+                };
+            }
+            const created = await c.analyses.create(options);
+            return { created: created.id, resource: "analysis", ...created, };
+        },
+        usage: "dss analysis create --input-dataset DS [--dry-run] [--project-key KEY]",
+        description: "Create a Visual ML analysis for an input dataset.",
+        examples: [
+            "dss analysis create --input-dataset customers --project-key PROJECT",
+            "dss analysis create --input-dataset customers --dry-run --project-key PROJECT",
+        ],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss analysis delete <analysisId> [--if-exists] [--dry-run] [--project-key KEY]");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true || f["if-exists"] === true) {
+                const current = await readIfExists(() => c.analyses.get(a[0], projectKey));
+                if (!current)
+                    return skipResult("analysis", a[0], "missing");
+                if (f["dry-run"] === true) {
+                    return { dryRun: true, action: "delete", resource: "analysis", id: a[0], current, };
+                }
+            }
+            await c.analyses.delete(a[0], projectKey);
+            return { deleted: a[0], resource: "analysis", };
+        },
+        usage: "dss analysis delete <analysisId> [--if-exists] [--dry-run] [--project-key KEY]",
+        description: "Delete a Visual ML analysis.",
+        examples: [
+            "dss analysis delete ANALYSIS_ID --if-exists --project-key PROJECT",
+            "dss analysis delete ANALYSIS_ID --dry-run --project-key PROJECT",
+        ],
+    },
+};

package/dist/src/cli/commands/api-service.js

@@ -36,6 +36,25 @@ export const apiServiceCommands = {
         description: "Save an API service's settings.",
         examples: ["dss api-service save-settings my-service --data-file service.json",],
     },
+    "add-prediction-endpoint": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 3, "dss api-service add-prediction-endpoint <serviceId> <endpointId> <savedModelId> [--dry-run] [--project-key KEY]");
+            const endpoint = {
+                id: a[1],
+                type: "STD_PREDICTION",
+                modelRef: a[2],
+            };
+            if (f["dry-run"] === true)
+                return endpoint;
+            return c.apiServices.addPredictionEndpoint(a[0], a[1], a[2], f["project-key"]);
+        },
+        usage: "dss api-service add-prediction-endpoint <serviceId> <endpointId> <savedModelId> [--dry-run] [--project-key KEY]",
+        description: "Add a saved-model prediction endpoint to an API service.",
+        examples: [
+            "dss api-service add-prediction-endpoint my-service predict churn-model",
+            "dss api-service add-prediction-endpoint my-service predict churn-model --dry-run",
+        ],
+    },
     "list-packages": {
         handler: async (c, a, f) => {
             requireArgs(a, 1, "dss api-service list-packages <serviceId> [--project-key KEY]");

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

@@ -1,3 +1,4 @@
+import { analysisCommands, } from "./analysis.js";
 import { apiDeployerCommands, } from "./api-deployer.js";
 import { apiServiceCommands, } from "./api-service.js";
 import { appCommands, } from "./app.js";
@@ -19,11 +20,14 @@ import { insightCommands, } from "./insight.js";
 import { jobCommands, } from "./job.js";
 import { meaningCommands, } from "./meaning.js";
 import { metricsCommands, } from "./metrics.js";
+import { mlTaskCommands, } from "./ml-task.js";
+import { modelEvaluationStoreCommands, } from "./model-evaluation-store.js";
 import { notebookCommands, } from "./notebook.js";
 import { projectDeployerCommands, } from "./project-deployer.js";
 import { projectLibraryCommands, } from "./project-library.js";
 import { projectCommands, } from "./project.js";
 import { recipeCommands, } from "./recipe.js";
+import { savedModelCommands, } from "./saved-model.js";
 import { scenarioCommands, } from "./scenario.js";
 import { sqlCommands, } from "./sql.js";
 import { statisticsCommands, } from "./statistics.js";
@@ -34,6 +38,10 @@ import { wikiCommands, } from "./wiki.js";
 import { workspaceCommands, } from "./workspace.js";
 export const commands = {
     project: projectCommands,
+    analysis: analysisCommands,
+    "ml-task": mlTaskCommands,
+    "saved-model": savedModelCommands,
+    "model-evaluation-store": modelEvaluationStoreCommands,
     app: appCommands,
     "business-app": businessAppCommands,
     webapp: webappCommands,

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

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const mlTaskCommands: Record<string, CommandMeta>;

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

@@ -0,0 +1,171 @@
+import { requiredJsonInput, requiredStringFlag, } from "../coerce.js";
+import { requireArgs, UsageError, } from "../usage.js";
+function optionalStringFlag(flags, name) {
+    const value = flags[name];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new UsageError(`--${name} requires a non-empty value.`, "usage_error");
+    }
+    return value.trim();
+}
+function taskType(flags, usage) {
+    const normalized = requiredStringFlag(flags, "task-type", usage).toUpperCase();
+    if (normalized === "PREDICTION" || normalized === "CLUSTERING")
+        return normalized;
+    throw new UsageError("--task-type must be PREDICTION or CLUSTERING.", "invalid_enum");
+}
+export const mlTaskCommands = {
+    create: {
+        handler: async (c, a, f) => {
+            const usage = "dss ml-task create <analysisId> --task-type PREDICTION|CLUSTERING [--target COLUMN] [--prediction-type TYPE] [--backend-type TYPE] [--guess-policy POLICY] [--project-key KEY]";
+            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 = {
+                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);
+            return { created: created.mlTaskId, resource: "ml-task", analysisId: a[0], ...created, };
+        },
+        usage: "dss ml-task create <analysisId> --task-type PREDICTION|CLUSTERING [--target COLUMN] [--prediction-type TYPE] [--backend-type TYPE] [--guess-policy POLICY] [--project-key KEY]",
+        description: "Create a prediction or clustering task in an analysis.",
+        examples: [
+            "dss ml-task create ANALYSIS_ID --task-type prediction --target churn --project-key PROJECT",
+        ],
+    },
+    status: {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss ml-task status <analysisId> <mlTaskId> [--project-key KEY]");
+            return c.mlTasks.status(a[0], a[1], f["project-key"]);
+        },
+        usage: "dss ml-task status <analysisId> <mlTaskId> [--project-key KEY]",
+        description: "Get a Visual ML task's current status.",
+        examples: ["dss ml-task status ANALYSIS_ID TASK_ID --project-key PROJECT",],
+    },
+    "get-settings": {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss ml-task get-settings <analysisId> <mlTaskId> [--project-key KEY]");
+            return c.mlTasks.getSettings(a[0], a[1], f["project-key"]);
+        },
+        usage: "dss ml-task get-settings <analysisId> <mlTaskId> [--project-key KEY]",
+        description: "Get a Visual ML task's settings.",
+        examples: ["dss ml-task get-settings ANALYSIS_ID TASK_ID --project-key PROJECT",],
+    },
+    "set-settings": {
+        handler: (c, a, f) => {
+            const usage = "dss ml-task set-settings <analysisId> <mlTaskId> (--data JSON|--data-file PATH|--stdin) [--project-key KEY]";
+            requireArgs(a, 2, usage);
+            const settings = requiredJsonInput(f, "--data, --data-file, or --stdin is required (ML task settings).");
+            const projectKey = f["project-key"];
+            return c.mlTasks.saveSettings(a[0], a[1], settings, projectKey);
+        },
+        usage: "dss ml-task set-settings <analysisId> <mlTaskId> (--data JSON|--data-file PATH|--stdin) [--project-key KEY]",
+        description: "Replace a Visual ML task's settings from JSON input.",
+        examples: [
+            "dss ml-task set-settings ANALYSIS_ID TASK_ID --data-file settings.json --project-key PROJECT",
+        ],
+    },
+    train: {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss ml-task train <analysisId> <mlTaskId> [--session-name NAME] [--wait] [--project-key KEY]");
+            const options = {
+                analysisId: a[0],
+                mlTaskId: a[1],
+                sessionName: optionalStringFlag(f, "session-name"),
+                wait: f["wait"] === true,
+                projectKey: f["project-key"],
+            };
+            return c.mlTasks.train(options);
+        },
+        usage: "dss ml-task train <analysisId> <mlTaskId> [--session-name NAME] [--wait] [--project-key KEY]",
+        description: "Start ML task training, optionally waiting for trained model IDs.",
+        examples: [
+            "dss ml-task train ANALYSIS_ID TASK_ID --session-name baseline --wait --project-key PROJECT",
+        ],
+    },
+    "list-models": {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss ml-task list-models <analysisId> <mlTaskId> [--project-key KEY]");
+            return c.mlTasks.listTrainedModels(a[0], a[1], f["project-key"]);
+        },
+        usage: "dss ml-task list-models <analysisId> <mlTaskId> [--project-key KEY]",
+        description: "List trained models for a Visual ML task.",
+        examples: ["dss ml-task list-models ANALYSIS_ID TASK_ID --project-key PROJECT",],
+    },
+    "model-details": {
+        handler: (c, a, f) => {
+            requireArgs(a, 3, "dss ml-task model-details <analysisId> <mlTaskId> <modelId> [--project-key KEY]");
+            return c.mlTasks.trainedModelDetails(a[0], a[1], a[2], f["project-key"]);
+        },
+        usage: "dss ml-task model-details <analysisId> <mlTaskId> <modelId> [--project-key KEY]",
+        description: "Get details for one trained model.",
+        examples: [
+            "dss ml-task model-details ANALYSIS_ID TASK_ID MODEL_ID --project-key PROJECT",
+        ],
+    },
+    deploy: {
+        handler: async (c, a, f) => {
+            const usage = "dss ml-task deploy <analysisId> <mlTaskId> <modelId> --model-name NAME --train-dataset DATASET [--test-dataset DATASET] [--dry-run] [--project-key KEY]";
+            requireArgs(a, 3, usage);
+            const options = {
+                analysisId: a[0],
+                mlTaskId: a[1],
+                modelId: a[2],
+                modelName: requiredStringFlag(f, "model-name", usage),
+                trainDatasetRef: requiredStringFlag(f, "train-dataset", usage),
+                testDatasetRef: optionalStringFlag(f, "test-dataset"),
+                projectKey: f["project-key"],
+            };
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "deploy",
+                    resource: "ml-task",
+                    ...options,
+                };
+            }
+            return c.mlTasks.deployToFlow(options);
+        },
+        usage: "dss ml-task deploy <analysisId> <mlTaskId> <modelId> --model-name NAME --train-dataset DATASET [--test-dataset DATASET] [--dry-run] [--project-key KEY]",
+        description: "Deploy a trained model to the Flow as a saved model.",
+        examples: [
+            "dss ml-task deploy ANALYSIS_ID TASK_ID MODEL_ID --model-name churn-model --train-dataset train --test-dataset test --project-key PROJECT",
+            "dss ml-task deploy ANALYSIS_ID TASK_ID MODEL_ID --model-name churn-model --train-dataset train --dry-run --project-key PROJECT",
+        ],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss ml-task delete <analysisId> <mlTaskId> [--dry-run] [--project-key KEY]");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "delete",
+                    resource: "ml-task",
+                    analysisId: a[0],
+                    mlTaskId: a[1],
+                    projectKey,
+                };
+            }
+            await c.mlTasks.delete(a[0], a[1], projectKey);
+            return { deleted: a[1], resource: "ml-task", analysisId: a[0], };
+        },
+        usage: "dss ml-task delete <analysisId> <mlTaskId> [--dry-run] [--project-key KEY]",
+        description: "Delete a Visual ML task.",
+        examples: [
+            "dss ml-task delete ANALYSIS_ID TASK_ID --project-key PROJECT",
+            "dss ml-task delete ANALYSIS_ID TASK_ID --dry-run --project-key PROJECT",
+        ],
+    },
+};

package/dist/src/cli/commands/model-evaluation-store.d.ts

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const modelEvaluationStoreCommands: Record<string, CommandMeta>;

package/dist/src/cli/commands/model-evaluation-store.js

@@ -0,0 +1,83 @@
+import { requiredStringFlag, } from "../coerce.js";
+import { readIfExists, skipResult, } from "../output.js";
+import { requireArgs, } from "../usage.js";
+export const modelEvaluationStoreCommands = {
+    list: {
+        handler: (c, _a, f) => c.modelEvaluationStores.list(f["project-key"]),
+        usage: "dss model-evaluation-store list [--project-key KEY]",
+        description: "List model evaluation stores in a project.",
+        examples: ["dss model-evaluation-store list --project-key PROJECT",],
+    },
+    get: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss model-evaluation-store get <storeId> [--project-key KEY]");
+            return c.modelEvaluationStores.get(a[0], f["project-key"]);
+        },
+        usage: "dss model-evaluation-store get <storeId> [--project-key KEY]",
+        description: "Get a model evaluation store.",
+        examples: ["dss model-evaluation-store get STORE_ID --project-key PROJECT",],
+    },
+    create: {
+        handler: async (c, _a, f) => {
+            const usage = "dss model-evaluation-store create --name NAME [--dry-run] [--project-key KEY]";
+            const name = requiredStringFlag(f, "name", usage);
+            const projectKey = f["project-key"];
+            const options = { name, projectKey, };
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "create",
+                    resource: "model-evaluation-store",
+                    payload: options,
+                };
+            }
+            const created = await c.modelEvaluationStores.create(options);
+            return { created: created.id, resource: "model-evaluation-store", ...created, };
+        },
+        usage: "dss model-evaluation-store create --name NAME [--dry-run] [--project-key KEY]",
+        description: "Create an empty model evaluation store.",
+        examples: [
+            "dss model-evaluation-store create --name production-evaluations --project-key PROJECT",
+            "dss model-evaluation-store create --name production-evaluations --dry-run --project-key PROJECT",
+        ],
+    },
+    "list-evaluations": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss model-evaluation-store list-evaluations <storeId> [--project-key KEY]");
+            return c.modelEvaluationStores.listEvaluations(a[0], f["project-key"]);
+        },
+        usage: "dss model-evaluation-store list-evaluations <storeId> [--project-key KEY]",
+        description: "List evaluations in a model evaluation store.",
+        examples: [
+            "dss model-evaluation-store list-evaluations STORE_ID --project-key PROJECT",
+        ],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss model-evaluation-store delete <storeId> [--if-exists] [--dry-run] [--project-key KEY]");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true || f["if-exists"] === true) {
+                const current = await readIfExists(() => c.modelEvaluationStores.get(a[0], projectKey));
+                if (!current)
+                    return skipResult("model-evaluation-store", a[0], "missing");
+                if (f["dry-run"] === true) {
+                    return {
+                        dryRun: true,
+                        action: "delete",
+                        resource: "model-evaluation-store",
+                        id: a[0],
+                        current,
+                    };
+                }
+            }
+            await c.modelEvaluationStores.delete(a[0], projectKey);
+            return { deleted: a[0], resource: "model-evaluation-store", };
+        },
+        usage: "dss model-evaluation-store delete <storeId> [--if-exists] [--dry-run] [--project-key KEY]",
+        description: "Delete a model evaluation store.",
+        examples: [
+            "dss model-evaluation-store delete STORE_ID --if-exists --project-key PROJECT",
+            "dss model-evaluation-store delete STORE_ID --dry-run --project-key PROJECT",
+        ],
+    },
+};

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

@@ -28,11 +28,12 @@ export const projectCommands = {
     },
     map: {
         handler: (c, _a, f) => c.projects.map({
+            projectKey: f["project-key"],
             maxNodes: num(f["max-nodes"]),
             maxEdges: num(f["max-edges"]),
             includeRaw: f["include-raw"] === true,
         }),
-        usage: "dss project map [--max-nodes N] [--max-edges N] [--include-raw]",
+        usage: "dss project map [--max-nodes N] [--max-edges N] [--include-raw] [--project-key KEY]",
         description: "Get a summarized, truncated flow map.",
         examples: [
             "dss project map",

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

@@ -2,7 +2,7 @@ import { readFileSync, } from "node:fs";
 import { mkdir, writeFile, } from "node:fs/promises";
 import { join, } from "node:path";
 import { deepMerge, } from "../../utils/deep-merge.js";
-import { jobLogFilterFromFlag, jsonInput, maxLogLinesFromFlags, normalizeLineEndings, num, recipeInputDatasetsFromFlags, requiredStringFlag, rewritePairsFromFlags, sha256Hex, stableHash, } from "../coerce.js";
+import { jobLogFilterFromFlag, jsonInput, maxLogLinesFromFlags, normalizeLineEndings, num, recipeInputDatasetsFromFlags, requiredStringFlag, rewritePairsFromFlags, sha256Hex, splitCsvFlag, stableHash, } from "../coerce.js";
 import { moveCreatedItemsToZone, resolveFlowZoneIdFromFlags, } from "../helpers/flow-zone.js";
 import { readRecipeBackup, recipeBackupDocument, recipeBackupPath, recipeCodeEnv, recipeGraph, recipeInputItemRef, recipeRoleInputItems, recipeRunShouldWait, } from "../helpers/recipe.js";
 import { encodedProjectEndpoint, readIfExists, skipResult, } from "../output.js";
@@ -180,6 +180,27 @@ export const recipeCommands = {
             const name = f["name"];
             const pk = f["project-key"];
             const inputDatasets = recipeInputDatasetsFromFlags(f);
+            const joinColumns = splitCsvFlag(f["join-on"]);
+            const fuzzyColumns = splitCsvFlag(f["fuzzy-on"]);
+            const rawFuzzyDistance = f["fuzzy-distance"];
+            let fuzzyDistance;
+            if (typeof rawFuzzyDistance === "string") {
+                const normalized = rawFuzzyDistance.trim().toUpperCase();
+                if (![
+                    "DAMERAU_LEVENSHTEIN",
+                    "HAMMING",
+                    "JACCARD",
+                    "COSINE",
+                    "EUCLIDEAN",
+                ].includes(normalized)) {
+                    throw new UsageError("--fuzzy-distance must be one of DAMERAU_LEVENSHTEIN, HAMMING, JACCARD, COSINE, or EUCLIDEAN.", "invalid_enum");
+                }
+                fuzzyDistance = normalized;
+            }
+            const fuzzyThreshold = num(f["fuzzy-threshold"]);
+            if (typeof f["fuzzy-threshold"] === "string" && fuzzyThreshold === undefined) {
+                throw new UsageError("--fuzzy-threshold must be a finite number.", "validation_failed");
+            }
             const payload = {
                 type,
                 name,
@@ -187,6 +208,12 @@ export const recipeCommands = {
                 outputDataset,
                 outputFolder,
                 outputConnection: f["output-connection"],
+                ...(joinColumns.length > 0 ? { joinOn: joinColumns, } : {}),
+                ...(typeof f["join-type"] === "string" ? { joinType: f["join-type"], } : {}),
+                ...(fuzzyColumns.length > 0 ? { fuzzyOn: fuzzyColumns, } : {}),
+                ...(fuzzyDistance ? { fuzzyDistance, } : {}),
+                ...(fuzzyThreshold !== undefined ? { fuzzyThreshold, } : {}),
+                fuzzyNormalize: f["normalize"] === true,
                 projectKey: pk,
             };
             const zoneId = await resolveFlowZoneIdFromFlags(c, f, pk);
@@ -228,7 +255,7 @@ export const recipeCommands = {
                 },], pk);
             return { created: createdName, resource: "recipe", ...created, ...moved, };
         },
-        usage: "dss recipe create --type TYPE --input DS[,DS2] (--output DS | --output-folder FOLDER_ID) [--name NAME] [--output-connection CONN] [--zone ZONE|--zone-id ID] [--if-not-exists] [--dry-run] [--project-key KEY]",
+        usage: "dss recipe create --type TYPE --input DS[,DS2] (--output DS | --output-folder FOLDER_ID) [--name NAME] [--output-connection CONN] [--zone ZONE|--zone-id ID] [--if-not-exists] [--dry-run] [--join-on COL|LEFT=RIGHT[,...]] [--join-type LEFT|INNER|RIGHT|FULL] [--fuzzy-on COL|LEFT=RIGHT[,...]] [--fuzzy-distance DAMERAU_LEVENSHTEIN|HAMMING|JACCARD|COSINE|EUCLIDEAN] [--fuzzy-threshold N] [--normalize] [--project-key KEY]",
         description: "Create a recipe with one or more inputs and a dataset or managed-folder output.",
         examples: [
             "dss recipe create --type python --input raw_orders,lookup --output orders_clean",

package/dist/src/cli/commands/saved-model.d.ts

@@ -0,0 +1,2 @@
+import type { CommandMeta } from "../types.js";
+export declare const savedModelCommands: Record<string, CommandMeta>;

package/dist/src/cli/commands/saved-model.js

@@ -0,0 +1,85 @@
+import { readIfExists, skipResult, } from "../output.js";
+import { requireArgs, } from "../usage.js";
+export const savedModelCommands = {
+    list: {
+        handler: (c, _a, f) => c.savedModels.list(f["project-key"]),
+        usage: "dss saved-model list [--project-key KEY]",
+        description: "List saved models in a project.",
+        examples: ["dss saved-model list --project-key PROJECT",],
+    },
+    get: {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss saved-model get <modelId> [--project-key KEY]");
+            return c.savedModels.get(a[0], f["project-key"]);
+        },
+        usage: "dss saved-model get <modelId> [--project-key KEY]",
+        description: "Get a saved model.",
+        examples: ["dss saved-model get MODEL_ID --project-key PROJECT",],
+    },
+    "list-versions": {
+        handler: (c, a, f) => {
+            requireArgs(a, 1, "dss saved-model list-versions <modelId> [--project-key KEY]");
+            return c.savedModels.listVersions(a[0], f["project-key"]);
+        },
+        usage: "dss saved-model list-versions <modelId> [--project-key KEY]",
+        description: "List versions of a saved model.",
+        examples: ["dss saved-model list-versions MODEL_ID --project-key PROJECT",],
+    },
+    "version-details": {
+        handler: (c, a, f) => {
+            requireArgs(a, 2, "dss saved-model version-details <modelId> <versionId> [--project-key KEY]");
+            return c.savedModels.versionDetails(a[0], a[1], f["project-key"]);
+        },
+        usage: "dss saved-model version-details <modelId> <versionId> [--project-key KEY]",
+        description: "Get details for one saved-model version.",
+        examples: [
+            "dss saved-model version-details MODEL_ID VERSION_ID --project-key PROJECT",
+        ],
+    },
+    "set-active": {
+        handler: async (c, a, f) => {
+            requireArgs(a, 2, "dss saved-model set-active <modelId> <versionId> [--dry-run] [--project-key KEY]");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true) {
+                return {
+                    dryRun: true,
+                    action: "set-active",
+                    resource: "saved-model",
+                    id: a[0],
+                    versionId: a[1],
+                    projectKey,
+                    payload: { versionId: a[1], },
+                };
+            }
+            return c.savedModels.setActiveVersion(a[0], a[1], projectKey);
+        },
+        usage: "dss saved-model set-active <modelId> <versionId> [--dry-run] [--project-key KEY]",
+        description: "Set the active version of a saved model.",
+        examples: [
+            "dss saved-model set-active MODEL_ID VERSION_ID --project-key PROJECT",
+            "dss saved-model set-active MODEL_ID VERSION_ID --dry-run --project-key PROJECT",
+        ],
+    },
+    delete: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, "dss saved-model delete <modelId> [--if-exists] [--dry-run] [--project-key KEY]");
+            const projectKey = f["project-key"];
+            if (f["dry-run"] === true || f["if-exists"] === true) {
+                const current = await readIfExists(() => c.savedModels.get(a[0], projectKey));
+                if (!current)
+                    return skipResult("saved-model", a[0], "missing");
+                if (f["dry-run"] === true) {
+                    return { dryRun: true, action: "delete", resource: "saved-model", id: a[0], current, };
+                }
+            }
+            await c.savedModels.delete(a[0], projectKey);
+            return { deleted: a[0], resource: "saved-model", };
+        },
+        usage: "dss saved-model delete <modelId> [--if-exists] [--dry-run] [--project-key KEY]",
+        description: "Delete a saved model.",
+        examples: [
+            "dss saved-model delete MODEL_ID --if-exists --project-key PROJECT",
+            "dss saved-model delete MODEL_ID --dry-run --project-key PROJECT",
+        ],
+    },
+};