dataiku-sdk 3.1.0 → 3.3.0

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

@@ -1,80 +1,153 @@
-import { analysisCommands, } from "./analysis.js";
-import { apiDeployerCommands, } from "./api-deployer.js";
-import { apiServiceCommands, } from "./api-service.js";
-import { appCommands, } from "./app.js";
-import { bundleCommands, } from "./bundle.js";
-import { businessAppCommands, } from "./business-app.js";
-import { codeEnvCommands, } from "./code-env.js";
-import { codeCommands, } from "./code.js";
-import { connectionCommands, } from "./connection.js";
-import { continuousActivityCommands, } from "./continuous-activity.js";
-import { dashboardCommands, } from "./dashboard.js";
-import { dataQualityCommands, } from "./data-quality.js";
-import { datasetCommands, } from "./dataset.js";
-import { discussionCommands, } from "./discussion.js";
-import { doctorCommands, } from "./doctor.js";
-import { flowZoneCommands, } from "./flow-zone.js";
-import { folderCommands, } from "./folder.js";
-import { futureCommands, } from "./future.js";
-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 { projectGitCommands, } from "./project-git.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";
-import { streamingEndpointCommands, } from "./streaming-endpoint.js";
-import { variableCommands, } from "./variable.js";
-import { webappCommands, } from "./webapp.js";
-import { wikiCommands, } from "./wiki.js";
-import { workspaceCommands, } from "./workspace.js";
+// Bun caches these synchronous module loads. Enumerating resource names stays
+// cheap; looking up one resource loads only its command definitions.
 export const commands = {
-    project: projectCommands,
-    analysis: analysisCommands,
-    "ml-task": mlTaskCommands,
-    "saved-model": savedModelCommands,
-    "model-evaluation-store": modelEvaluationStoreCommands,
-    app: appCommands,
-    "business-app": businessAppCommands,
-    webapp: webappCommands,
-    "api-service": apiServiceCommands,
-    "api-deployer": apiDeployerCommands,
-    bundle: bundleCommands,
-    "project-deployer": projectDeployerCommands,
-    "project-git": projectGitCommands,
-    "project-library": projectLibraryCommands,
-    "streaming-endpoint": streamingEndpointCommands,
-    "continuous-activity": continuousActivityCommands,
-    statistics: statisticsCommands,
-    discussion: discussionCommands,
-    meaning: meaningCommands,
-    workspace: workspaceCommands,
-    metrics: metricsCommands,
-    doctor: doctorCommands,
-    wiki: wikiCommands,
-    dashboard: dashboardCommands,
-    insight: insightCommands,
-    "data-quality": dataQualityCommands,
-    future: futureCommands,
-    "flow-zone": flowZoneCommands,
-    dataset: datasetCommands,
-    recipe: recipeCommands,
-    job: jobCommands,
-    scenario: scenarioCommands,
-    folder: folderCommands,
-    variable: variableCommands,
-    connection: connectionCommands,
-    "code-env": codeEnvCommands,
-    sql: sqlCommands,
-    code: codeCommands,
-    notebook: notebookCommands,
+    get "project"() {
+        return require("./project.js").projectCommands;
+    },
+    get "analysis"() {
+        return require("./analysis.js").analysisCommands;
+    },
+    get "ml-task"() {
+        return require("./ml-task.js").mlTaskCommands;
+    },
+    get "saved-model"() {
+        return require("./saved-model.js").savedModelCommands;
+    },
+    get "model-evaluation-store"() {
+        return require("./model-evaluation-store.js")
+            .modelEvaluationStoreCommands;
+    },
+    get "app"() {
+        return require("./app.js").appCommands;
+    },
+    get "business-app"() {
+        return require("./business-app.js").businessAppCommands;
+    },
+    get "webapp"() {
+        return require("./webapp.js").webappCommands;
+    },
+    get "api-service"() {
+        return require("./api-service.js").apiServiceCommands;
+    },
+    get "api-deployer"() {
+        return require("./api-deployer.js").apiDeployerCommands;
+    },
+    get "bundle"() {
+        return require("./bundle.js").bundleCommands;
+    },
+    get "project-deployer"() {
+        return require("./project-deployer.js")
+            .projectDeployerCommands;
+    },
+    get "project-git"() {
+        return require("./project-git.js").projectGitCommands;
+    },
+    get "project-folder"() {
+        return require("./project-folder.js")
+            .projectFolderCommands;
+    },
+    get "project-library"() {
+        return require("./project-library.js")
+            .projectLibraryCommands;
+    },
+    get "streaming-endpoint"() {
+        return require("./streaming-endpoint.js")
+            .streamingEndpointCommands;
+    },
+    get "continuous-activity"() {
+        return require("./continuous-activity.js")
+            .continuousActivityCommands;
+    },
+    get "statistics"() {
+        return require("./statistics.js").statisticsCommands;
+    },
+    get "discussion"() {
+        return require("./discussion.js").discussionCommands;
+    },
+    get "meaning"() {
+        return require("./meaning.js").meaningCommands;
+    },
+    get "workspace"() {
+        return require("./workspace.js").workspaceCommands;
+    },
+    get "metrics"() {
+        return require("./metrics.js").metricsCommands;
+    },
+    get "doctor"() {
+        return require("./doctor.js").doctorCommands;
+    },
+    get "wiki"() {
+        return require("./wiki.js").wikiCommands;
+    },
+    get "dashboard"() {
+        return require("./dashboard.js").dashboardCommands;
+    },
+    get "insight"() {
+        return require("./insight.js").insightCommands;
+    },
+    get "data-quality"() {
+        return require("./data-quality.js").dataQualityCommands;
+    },
+    get "future"() {
+        return require("./future.js").futureCommands;
+    },
+    get "flow-zone"() {
+        return require("./flow-zone.js").flowZoneCommands;
+    },
+    get "dataset"() {
+        return require("./dataset.js").datasetCommands;
+    },
+    get "recipe"() {
+        return require("./recipe.js").recipeCommands;
+    },
+    get "job"() {
+        return require("./job.js").jobCommands;
+    },
+    get "scenario"() {
+        return require("./scenario.js").scenarioCommands;
+    },
+    get "folder"() {
+        return require("./folder.js").folderCommands;
+    },
+    get "variable"() {
+        return require("./variable.js").variableCommands;
+    },
+    get "connection"() {
+        return require("./connection.js").connectionCommands;
+    },
+    get "code-env"() {
+        return require("./code-env.js").codeEnvCommands;
+    },
+    get "sql"() {
+        return require("./sql.js").sqlCommands;
+    },
+    get "code"() {
+        return require("./code.js").codeCommands;
+    },
+    get "notebook"() {
+        return require("./notebook.js").notebookCommands;
+    },
+    get "user"() {
+        return require("./user.js").userCommands;
+    },
+    get "group"() {
+        return require("./group.js").groupCommands;
+    },
+    get "plugin"() {
+        return require("./plugin.js").pluginCommands;
+    },
+    get "llm"() {
+        return require("./llm.js").llmCommands;
+    },
+    get "knowledge-bank"() {
+        return require("./knowledge-bank.js")
+            .knowledgeBankCommands;
+    },
+    get "macro"() {
+        return require("./macro.js").macroCommands;
+    },
+    get "data-collection"() {
+        return require("./data-collection.js")
+            .dataCollectionCommands;
+    },
 };

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

@@ -1,5 +1,6 @@
 import { deepMerge, } from "../../utils/deep-merge.js";
 import { json, jsonInput, parseBooleanOption, textInput, } from "../coerce.js";
+import { executionMode, } from "../flags.js";
 import { readIfExists, skipResult, } from "../output.js";
 import { requireArgs, UsageError, } from "../usage.js";
 export const insightCommands = {
@@ -40,17 +41,17 @@ export const insightCommands = {
             if (params !== undefined)
                 prototype.params = params;
             const pk = f["project-key"];
-            if (f["if-not-exists"] === true || f["dry-run"] === true) {
+            if (f["if-not-exists"] === true || executionMode(f).dryRun) {
                 const existing = name
                     ? (await c.insights.list(pk)).find((insight) => insight.name === name)
                     : undefined;
-                if (existing && f["if-not-exists"] === true && f["dry-run"] !== true) {
+                if (existing && f["if-not-exists"] === true && !executionMode(f).dryRun) {
                     return skipResult("insight", existing.id, "exists", { current: existing, });
                 }
-                if (f["if-not-exists"] === true && !name && f["dry-run"] !== true) {
+                if (f["if-not-exists"] === true && !name && !executionMode(f).dryRun) {
                     throw new UsageError("--if-not-exists requires --name for insight create.");
                 }
-                if (f["dry-run"] === true) {
+                if (executionMode(f).dryRun) {
                     return {
                         dryRun: true,
                         action: "create",
@@ -95,7 +96,7 @@ export const insightCommands = {
                 && contentType === undefined && payload === undefined) {
                 throw new UsageError("--name, --listed, --params, --content, --file, --data, --data-file, or --stdin is required.");
             }
-            if (f["dry-run"] === true) {
+            if (executionMode(f).dryRun) {
                 const current = await c.insights.get(a[0], f["project-key"]);
                 const next = deepMerge(current, data ?? {});
                 if (name !== undefined)
@@ -138,11 +139,11 @@ export const insightCommands = {
         handler: async (c, a, f) => {
             requireArgs(a, 1, "dss insight delete <id>");
             const pk = f["project-key"];
-            if (f["dry-run"] === true || f["if-exists"] === true) {
+            if (executionMode(f).dryRun || f["if-exists"] === true) {
                 const current = await readIfExists(() => c.insights.get(a[0], pk));
                 if (!current)
                     return skipResult("insight", a[0], "missing");
-                if (f["dry-run"] === true) {
+                if (executionMode(f).dryRun) {
                     return { dryRun: true, action: "delete", resource: "insight", id: a[0], current, };
                 }
             }

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

@@ -2,6 +2,7 @@ import { mkdir, writeFile, } from "node:fs/promises";
 import { dirname, resolve, } from "node:path";
 import { parseJobLogProgress, } from "../../resources/jobs.js";
 import { jobBuildTargetTypeFromFlags, jobLogFilterFromFlag, maxLogLinesFromFlags, num, plainRecord, } from "../coerce.js";
+import { executionMode, } from "../flags.js";
 import { encodedProjectEndpoint, } from "../output.js";
 import { requireArgs, UsageError, } from "../usage.js";
 // ---------------------------------------------------------------------------
@@ -276,7 +277,7 @@ export const jobCommands = {
                 targetType: jobBuildTargetTypeFromFlags(f),
                 timeoutMs: num(f["timeout"], "--timeout"),
             };
-            if (f["dry-run"] === true) {
+            if (executionMode(f).dryRun) {
                 return {
                     dryRun: true,
                     action: "build",
@@ -315,7 +316,7 @@ export const jobCommands = {
                 summary: f["summary"] === true,
                 targetType: jobBuildTargetTypeFromFlags(f),
             };
-            if (f["dry-run"] === true) {
+            if (executionMode(f).dryRun) {
                 return {
                     dryRun: true,
                     action: "build-and-wait",
@@ -399,7 +400,7 @@ export const jobCommands = {
         handler: async (c, a, f) => {
             requireArgs(a, 1, "dss job abort <id>");
             const pk = f["project-key"];
-            if (f["dry-run"] === true) {
+            if (executionMode(f).dryRun) {
                 return {
                     dryRun: true,
                     action: "abort",

package/dist/src/cli/commands/knowledge-bank.d.ts

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

package/dist/src/cli/commands/knowledge-bank.js

@@ -0,0 +1,80 @@
+import { requiredJsonInput, } from "../coerce.js";
+import { executionMode, } from "../flags.js";
+import { planResult, } from "../output.js";
+import { requireArgs, UsageError, } from "../usage.js";
+const KB_PLAN_EXIT_CODES = { usage: 1, error: 2, transient: 3, };
+const KB_SEARCH_USAGE = "dss knowledge-bank search <knowledgeBankId> (--data JSON|--data-file PATH|--stdin) [--dry-run] [--project-key KEY]";
+const KB_CLEAR_USAGE = "dss knowledge-bank clear <knowledgeBankId> [--dry-run] [--project-key KEY]";
+/**
+ * Validate a search body before any execution mode: the same check runs for
+ * live, --plan, and --dry-run so planning can never succeed for a body the
+ * live call would reject.
+ */
+function requireKnowledgeBankSearchBody(flags) {
+    const body = requiredJsonInput(flags, "--data, --data-file, or --stdin is required (search body with a query string).");
+    const query = body["query"];
+    if (typeof query !== "string" || query.trim().length === 0) {
+        throw new UsageError(`query is required and must be a non-empty string.\nUsage: ${KB_SEARCH_USAGE}`, "invalid_flag_value");
+    }
+    return body;
+}
+function requireNonEmptyPositional(value, usage) {
+    if (value.trim().length === 0) {
+        throw new UsageError(`knowledgeBankId must be a non-empty string.\nUsage: ${usage}`, "invalid_flag_value");
+    }
+    return value;
+}
+export const knowledgeBankCommands = {
+    search: {
+        handler: async (c, a, f) => {
+            const knowledgeBankId = requireNonEmptyPositional(a[0], KB_SEARCH_USAGE);
+            const body = requireKnowledgeBankSearchBody(f);
+            const projectKey = f["project-key"];
+            if (executionMode(f).dryRun) {
+                return planResult("knowledge-bank", "search", {
+                    asyncKind: "none",
+                    method: "POST",
+                    endpoint: `/public/api/projects/${encodeURIComponent(projectKey ?? c.resolveProjectKey(undefined))}/knowledge-banks/${encodeURIComponent(knowledgeBankId)}/search`,
+                    identifiers: { knowledgeBankId, },
+                    payload: body,
+                    idempotency: "none",
+                    exitCodesOnFailure: KB_PLAN_EXIT_CODES,
+                    plannedAndDryRun: true,
+                });
+            }
+            return c.knowledgeBanks.search(knowledgeBankId, body, projectKey);
+        },
+        usage: KB_SEARCH_USAGE,
+        description: "Search a knowledge bank for documents matching a query. Runs retrieval against the backing vector store. Body: { query, params?: { maxDocuments, searchType, similarityThreshold, mmrK, mmrDiversity, useAdvancedReranking, rrfRankConstant, rrfRankWindowSize } }.",
+        examples: [
+            'dss knowledge-bank search my-kb --data \'{"query":"Hello, world!"}\'',
+            'dss knowledge-bank search my-kb --data \'{"query":"refund policy","params":{"maxDocuments":5,"searchType":"SIMILARITY"}}\' --dry-run',
+        ],
+    },
+    clear: {
+        handler: async (c, a, f) => {
+            requireArgs(a, 1, KB_CLEAR_USAGE);
+            const knowledgeBankId = requireNonEmptyPositional(a[0], KB_CLEAR_USAGE);
+            const projectKey = f["project-key"];
+            if (executionMode(f).dryRun) {
+                return planResult("knowledge-bank", "clear", {
+                    asyncKind: "none",
+                    method: "POST",
+                    endpoint: `/public/api/projects/${encodeURIComponent(projectKey ?? c.resolveProjectKey(undefined))}/knowledge-banks/${encodeURIComponent(knowledgeBankId)}/clear`,
+                    identifiers: { knowledgeBankId, },
+                    idempotency: "convergent",
+                    exitCodesOnFailure: KB_PLAN_EXIT_CODES,
+                    plannedAndDryRun: true,
+                });
+            }
+            await c.knowledgeBanks.clear(knowledgeBankId, projectKey);
+            return { cleared: knowledgeBankId, resource: "knowledge-bank", };
+        },
+        usage: KB_CLEAR_USAGE,
+        description: "DESTRUCTIVE: clear all data from a knowledge bank. The stored content is removed and cannot be recovered from this command.",
+        examples: [
+            "dss knowledge-bank clear my-kb --dry-run",
+            "dss knowledge-bank clear my-kb",
+        ],
+    },
+};

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

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

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

@@ -0,0 +1,93 @@
+import { requiredJsonInput, } from "../coerce.js";
+import { executionMode, } from "../flags.js";
+import { planResult, } from "../output.js";
+import { UsageError, } from "../usage.js";
+const LLM_PLAN_EXIT_CODES = { usage: 1, error: 2, transient: 3, };
+const LLM_LIST_USAGE = "dss llm list [--purpose GENERIC_COMPLETION|TEXT_EMBEDDING_EXTRACTION|IMAGE_GENERATION|NAME] [--project-key KEY]";
+const LLM_COMPLETIONS_USAGE = "dss llm completions (--data JSON|--data-file PATH|--stdin) [--dry-run] [--project-key KEY]";
+const LLM_EMBEDDINGS_USAGE = "dss llm embeddings (--data JSON|--data-file PATH|--stdin) [--dry-run] [--project-key KEY]";
+/**
+ * Validate a completions/embeddings payload before any execution mode: the
+ * same check runs for live, --plan, and --dry-run so planning can never
+ * succeed for a body the live call would reject.
+ */
+function requireLlmInferenceBody(flags, usage) {
+    const body = requiredJsonInput(flags, "--data, --data-file, or --stdin is required (LLM request body with llmId and queries).");
+    const llmId = body["llmId"];
+    if (typeof llmId !== "string" || llmId.trim().length === 0) {
+        throw new UsageError(`llmId is required and must be a non-empty string (e.g. "openai:openai1:gpt-4").\nUsage: ${usage}`, "invalid_flag_value");
+    }
+    const queries = body["queries"];
+    if (!Array.isArray(queries) || queries.length === 0) {
+        throw new UsageError(`queries is required and must be a non-empty array of query objects.\nUsage: ${usage}`, "invalid_flag_value");
+    }
+    return body;
+}
+export const llmCommands = {
+    list: {
+        handler: (c, _a, f) => {
+            const purpose = f["purpose"];
+            return c.llms.list({
+                purpose,
+                projectKey: f["project-key"],
+            });
+        },
+        usage: LLM_LIST_USAGE,
+        description: "List LLMs available in a project (includes Retrieval-Augmented Generation ones). Does not invoke any LLM.",
+        examples: ["dss llm list", "dss llm list --purpose TEXT_EMBEDDING_EXTRACTION",],
+    },
+    completions: {
+        handler: async (c, _a, f) => {
+            const body = requireLlmInferenceBody(f, LLM_COMPLETIONS_USAGE);
+            const projectKey = f["project-key"];
+            if (executionMode(f).dryRun) {
+                return planResult("llm", "completions", {
+                    asyncKind: "none",
+                    method: "POST",
+                    endpoint: `/public/api/projects/${encodeURIComponent(projectKey ?? c.resolveProjectKey(undefined))}/llms/completions`,
+                    identifiers: {
+                        llmId: typeof body["llmId"] === "string" ? body["llmId"] : undefined,
+                    },
+                    payload: body,
+                    idempotency: "none",
+                    exitCodesOnFailure: LLM_PLAN_EXIT_CODES,
+                    plannedAndDryRun: true,
+                });
+            }
+            return c.llms.completions(body, projectKey);
+        },
+        usage: LLM_COMPLETIONS_USAGE,
+        description: "Perform completions on an LLM. COST-BEARING: invokes the LLM provider and may incur charges. Body: { llmId, queries: [{ messages: [...] }], settings?: {...} }.",
+        examples: [
+            'dss llm completions --data \'{"llmId":"openai:openai1:gpt-4","queries":[{"messages":[{"role":"user","content":"Hello"}]}]}\'',
+            'dss llm completions --data \'{"llmId":"openai:openai1:gpt-4","queries":[...],"settings":{"temperature":0.9}}\' --dry-run',
+        ],
+    },
+    embeddings: {
+        handler: async (c, _a, f) => {
+            const body = requireLlmInferenceBody(f, LLM_EMBEDDINGS_USAGE);
+            const projectKey = f["project-key"];
+            if (executionMode(f).dryRun) {
+                return planResult("llm", "embeddings", {
+                    asyncKind: "none",
+                    method: "POST",
+                    endpoint: `/public/api/projects/${encodeURIComponent(projectKey ?? c.resolveProjectKey(undefined))}/llms/embeddings`,
+                    identifiers: {
+                        llmId: typeof body["llmId"] === "string" ? body["llmId"] : undefined,
+                    },
+                    payload: body,
+                    idempotency: "none",
+                    exitCodesOnFailure: LLM_PLAN_EXIT_CODES,
+                    plannedAndDryRun: true,
+                });
+            }
+            return c.llms.embeddings(body, projectKey);
+        },
+        usage: LLM_EMBEDDINGS_USAGE,
+        description: 'Perform embeddings on an LLM. COST-BEARING: invokes the LLM provider and may incur charges. Body: { llmId, queries: [{ text: "..." }] }.',
+        examples: [
+            'dss llm embeddings --data \'{"llmId":"openai:openai1:ada002-text-embedding","queries":[{"text":"Who wrote Beethoven 9th?"}]}\'',
+            'dss llm embeddings --data \'{"llmId":"x","queries":[{"text":"y"}]}\' --dry-run',
+        ],
+    },
+};

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

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