dataiku-sdk 0.1.2 → 0.2.0

package/dist/src/auth.d.ts

@@ -0,0 +1,4 @@
+export declare function validateCredentials(url: string, apiKey: string): Promise<{
+    valid: boolean;
+    error?: string;
+}>;

package/dist/src/auth.js

@@ -0,0 +1,20 @@
+import { DataikuClient, } from "./client.js";
+import { DataikuError, } from "./errors.js";
+export async function validateCredentials(url, apiKey) {
+    try {
+        const client = new DataikuClient({
+            url,
+            apiKey,
+            requestTimeoutMs: 10_000,
+            retryMaxAttempts: 1,
+        });
+        await client.projects.list();
+        return { valid: true, };
+    }
+    catch (err) {
+        if (err instanceof DataikuError) {
+            return { valid: false, error: err.message, };
+        }
+        return { valid: false, error: err instanceof Error ? err.message : String(err), };
+    }
+}

package/dist/src/cli.js

@@ -1,12 +1,27 @@
 #!/usr/bin/env node
 import { readFileSync, } from "node:fs";
+import { writeFile, } from "node:fs/promises";
 import { dirname, resolve, } from "node:path";
+import { createInterface, } from "node:readline";
+import { Writable, } from "node:stream";
 import { fileURLToPath, } from "node:url";
+import { validateCredentials, } from "./auth.js";
 import { DataikuClient, } from "./client.js";
+import { deleteCredentials, getCredentialsPath, loadCredentials, maskApiKey, saveCredentials, } from "./config.js";
 import { DataikuError, } from "./errors.js";
+import { AGENTS, detectAgents, installSkill, } from "./skill.js";
 // ---------------------------------------------------------------------------
 // Utility helpers
 // ---------------------------------------------------------------------------
+const CLI_VERSION = (() => {
+    try {
+        const pkgPath = resolve(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+        return JSON.parse(readFileSync(pkgPath, "utf-8")).version;
+    }
+    catch {
+        return "unknown";
+    }
+})();
 function num(v) {
     if (typeof v !== "string")
         return undefined;
@@ -63,9 +78,29 @@ function formatLineDiff(remoteName, localPath, remoteContent, localContent) {
 function parseOutputFormat(v) {
     if (v === undefined)
         return "json";
-    if (v === "json" || v === "quiet" || v === "tsv")
+    if (v === "json" || v === "quiet" || v === "table" || v === "tsv")
         return v;
-    throw new UsageError(`Invalid --format value: ${String(v)}. Use json, tsv, or quiet.`);
+    throw new UsageError(`Invalid --format value: ${String(v)}. Use json, tsv, table, or quiet.`);
+}
+function writeTable(items) {
+    if (items.length === 0)
+        return;
+    const keys = Object.keys(items[0]);
+    const maxWidths = keys.map((k) => {
+        const values = items.map((item) => String(item[k] ?? ""));
+        return Math.min(40, Math.max(k.length, ...values.map((v) => v.length)));
+    });
+    process.stdout.write(`${keys.map((k, i) => k.padEnd(maxWidths[i])).join("  ")}\n`);
+    process.stdout.write(`${maxWidths.map((w) => "-".repeat(w)).join("  ")}\n`);
+    for (const item of items) {
+        const row = keys.map((k, i) => {
+            const val = String(item[k] ?? "");
+            return (val.length > maxWidths[i]
+                ? `${val.slice(0, maxWidths[i] - 1)}\u2026`
+                : val).padEnd(maxWidths[i]);
+        });
+        process.stdout.write(`${row.join("  ")}\n`);
+    }
 }
 function writeCommandResult(result, format) {
     if (result === undefined || result === null) {
@@ -84,9 +119,9 @@ function writeCommandResult(result, format) {
     }
     if (format === "quiet")
         return;
-    if (format === "tsv"
-        && Array.isArray(result)
-        && result.every((item) => item !== null && typeof item === "object" && !Array.isArray(item))) {
+    const isArrayOfObjects = Array.isArray(result)
+        && result.every((item) => item !== null && typeof item === "object" && !Array.isArray(item));
+    if (format === "tsv" && isArrayOfObjects) {
         const items = result;
         if (items.length === 0)
             return;
@@ -97,8 +132,23 @@ function writeCommandResult(result, format) {
         }
         return;
     }
+    if (format === "table" && isArrayOfObjects) {
+        writeTable(result);
+        return;
+    }
     process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
 }
+// ---------------------------------------------------------------------------
+// Arg parsing
+// ---------------------------------------------------------------------------
+const BOOLEAN_FLAGS = new Set(["help", "verbose", "version", "stdin", "global", "list-agents",]);
+const SHORT_FLAGS = {
+    h: "help",
+    v: "verbose",
+    V: "version",
+    f: "format",
+    o: "output",
+};
 function parseArgs(argv) {
     const positional = [];
     const flags = {};
@@ -115,16 +165,43 @@ function parseArgs(argv) {
                 flags[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
             }
             else {
-                const next = argv[i + 1];
-                if (next !== undefined && !next.startsWith("--")) {
-                    flags[arg.slice(2)] = next;
-                    i++;
+                const flagName = arg.slice(2);
+                if (BOOLEAN_FLAGS.has(flagName)) {
+                    flags[flagName] = true;
                 }
                 else {
-                    flags[arg.slice(2)] = true;
+                    const next = argv[i + 1];
+                    if (next !== undefined && !next.startsWith("-")) {
+                        flags[flagName] = next;
+                        i++;
+                    }
+                    else {
+                        flags[flagName] = true;
+                    }
                 }
             }
         }
+        else if (arg.length === 2 && arg[0] === "-" && arg[1] !== "-") {
+            const long = SHORT_FLAGS[arg[1]];
+            if (long) {
+                if (BOOLEAN_FLAGS.has(long)) {
+                    flags[long] = true;
+                }
+                else {
+                    const next = argv[i + 1];
+                    if (next !== undefined && !next.startsWith("-")) {
+                        flags[long] = next;
+                        i++;
+                    }
+                    else {
+                        flags[long] = true;
+                    }
+                }
+            }
+            else {
+                positional.push(arg);
+            }
+        }
         else {
             positional.push(arg);
         }
@@ -325,6 +402,33 @@ const commands = {
             },
             usage: "dss recipe update <name> [--data '{...}' | --data-file PATH | --stdin] [--project-key KEY]",
         },
+        "get-payload": {
+            handler: async (c, a, f) => {
+                requireArgs(a, 1, "dss recipe get-payload <name>");
+                const payload = await c.recipes.getPayload(a[0], {
+                    projectKey: f["project-key"],
+                });
+                if (typeof f["output"] === "string") {
+                    await writeFile(f["output"], payload, "utf-8");
+                    return f["output"];
+                }
+                return payload;
+            },
+            usage: "dss recipe get-payload <name> [--output PATH] [--project-key KEY]",
+        },
+        "set-payload": {
+            handler: async (c, a, f) => {
+                requireArgs(a, 1, "dss recipe set-payload <name> --file PATH");
+                const filePath = f["file"];
+                if (!filePath)
+                    throw new UsageError("--file is required.");
+                const content = readFileSync(filePath, "utf-8");
+                await c.recipes.setPayload(a[0], content, {
+                    projectKey: f["project-key"],
+                });
+            },
+            usage: "dss recipe set-payload <name> --file PATH [--project-key KEY]",
+        },
     },
     job: {
         list: {
@@ -648,21 +752,35 @@ const commands = {
 // ---------------------------------------------------------------------------
 // Help
 // ---------------------------------------------------------------------------
-const RESOURCE_NAMES = Object.keys(commands).sort();
+const RESOURCE_NAMES = [...Object.keys(commands), "auth", "install-skill",].sort();
 function printTopLevelHelp() {
     const lines = [
         "Usage: dss <resource> <action> [args...] [--flags]",
         "",
         "Global flags:",
-        "  --url URL            Dataiku DSS base URL (env: DATAIKU_URL)",
-        "  --api-key KEY        API key              (env: DATAIKU_API_KEY)",
-        "  --project-key KEY    Default project key   (env: DATAIKU_PROJECT_KEY)",
-        "  --format FORMAT      Output format: json|tsv|quiet",
-        "  --verbose            Log HTTP requests to stderr",
-        "  --help               Show help",
+        "  -h, --help               Show help",
+        "  -v, --verbose            Log HTTP requests to stderr",
+        "  -V, --version            Show version",
+        "  -f, --format FORMAT      Output format: json|tsv|table|quiet",
+        "  -o, --output PATH        Write output to file (recipe get-payload)",
+        "      --url URL            Dataiku DSS base URL (env: DATAIKU_URL)",
+        "      --api-key KEY        API key              (env: DATAIKU_API_KEY)",
+        "      --project-key KEY    Default project key   (env: DATAIKU_PROJECT_KEY)",
+        "      --timeout MS         Request timeout in ms  (default: 30000)",
         "",
         "Resources:",
         ...RESOURCE_NAMES.map((r) => `  ${r}`),
+        "",
+        "Quick start:",
+        "  dss auth login                         Save DSS credentials",
+        "  dss auth status                        Verify connection",
+        "  dss project list                       List accessible projects",
+        "  dss dataset list                       List datasets in default project",
+        "  dss dataset preview <name>             Preview dataset rows as CSV",
+        "  dss recipe get-payload <name>          Print recipe code to stdout",
+        "  dss recipe download-code <name>        Download recipe code to a file",
+        "  dss job log <id>                       View job log output",
+        "  dss install-skill                      Install agent skill for coding agents",
     ];
     process.stderr.write(`${lines.join("\n")}\n`);
 }
@@ -728,11 +846,133 @@ function loadEnvFile() {
     }
 }
 // ---------------------------------------------------------------------------
+// Auth commands (run before client creation)
+// ---------------------------------------------------------------------------
+const AUTH_ACTIONS = {
+    login: {
+        handler: async (flags) => {
+            let { url, apiKey, projectKey, } = resolveCredentials(flags);
+            if (!url || !apiKey) {
+                if (!process.stdin.isTTY) {
+                    throw new UsageError("Missing --url and/or --api-key. Provide them as flags or run interactively.");
+                }
+                if (!url)
+                    url = await promptLine("DSS URL: ");
+                if (!apiKey)
+                    apiKey = await promptSecret("API key: ");
+                if (!projectKey)
+                    projectKey = (await promptLine("Project key (optional): ")) || undefined;
+            }
+            if (!url)
+                throw new UsageError("URL is required.");
+            if (!apiKey)
+                throw new UsageError("API key is required.");
+            process.stderr.write("Validating credentials... ");
+            const result = await validateCredentials(url, apiKey);
+            if (!result.valid) {
+                process.stderr.write(`✗ Failed\n`);
+                throw new DataikuError(0, "Authentication Failed", result.error ?? "Credential validation failed");
+            }
+            process.stderr.write("\u2713 Connected\n");
+            saveCredentials({ url, apiKey, projectKey, });
+            process.stderr.write(`Credentials saved to ${getCredentialsPath()}\n`);
+        },
+        usage: "dss auth login [--url URL] [--api-key KEY] [--project-key KEY]",
+    },
+    status: {
+        handler: async (_flags) => {
+            const creds = loadCredentials();
+            if (!creds) {
+                process.stderr.write("No saved credentials. Run: dss auth login\n");
+                return;
+            }
+            const lines = [
+                `URL:         ${creds.url}`,
+                `API key:     ${maskApiKey(creds.apiKey)}`,
+                `Project key: ${creds.projectKey ?? "(not set)"}`,
+            ];
+            for (const line of lines)
+                process.stderr.write(`${line}\n`);
+            const result = await validateCredentials(creds.url, creds.apiKey);
+            if (result.valid) {
+                process.stderr.write("Connection:  \u2713 Valid\n");
+            }
+            else {
+                process.stderr.write(`Connection:  \u2717 Failed (${result.error ?? "unknown error"})\n`);
+            }
+            process.stderr.write(`Config:      ${getCredentialsPath()}\n`);
+        },
+        usage: "dss auth status",
+    },
+    logout: {
+        handler: async (_flags) => {
+            deleteCredentials();
+            process.stderr.write("Credentials removed.\n");
+        },
+        usage: "dss auth logout",
+    },
+};
+// ---------------------------------------------------------------------------
+// Interactive prompts
+// ---------------------------------------------------------------------------
+function promptLine(label) {
+    return new Promise((res, rej) => {
+        const rl = createInterface({ input: process.stdin, output: process.stderr, });
+        rl.on("close", () => rej(new UsageError("Input closed before a value was provided.")));
+        rl.question(label, (answer) => {
+            rl.close();
+            res(answer.trim());
+        });
+    });
+}
+function promptSecret(label) {
+    return new Promise((res, rej) => {
+        const muted = new Writable({
+            write(_chunk, _encoding, cb) {
+                cb();
+            },
+        });
+        const rl = createInterface({ input: process.stdin, output: muted, terminal: true, });
+        rl.on("close", () => rej(new UsageError("Input closed before a value was provided.")));
+        process.stderr.write(label);
+        rl.question("", (answer) => {
+            rl.close();
+            process.stderr.write("\n");
+            res(answer.trim());
+        });
+    });
+}
+// ---------------------------------------------------------------------------
+// Credential resolution
+// ---------------------------------------------------------------------------
+function resolveCredentials(flags) {
+    let url = flags["url"];
+    let apiKey = flags["api-key"];
+    let projectKey = flags["project-key"];
+    url ??= process.env.DATAIKU_URL;
+    apiKey ??= process.env.DATAIKU_API_KEY;
+    projectKey ??= process.env.DATAIKU_PROJECT_KEY;
+    if (!url || !apiKey) {
+        const saved = loadCredentials();
+        if (saved) {
+            url ??= saved.url;
+            apiKey ??= saved.apiKey;
+            projectKey ??= saved.projectKey;
+        }
+    }
+    return { url: url ?? "", apiKey: apiKey ?? "", projectKey, };
+}
+// ---------------------------------------------------------------------------
 // Main
 // ---------------------------------------------------------------------------
 async function main() {
     loadEnvFile();
     const { positional, flags, } = parseArgs(process.argv.slice(2));
+    // --version
+    if (flags["version"] === true) {
+        process.stdout.write(`${CLI_VERSION}\n`);
+        process.exit(0);
+    }
     // Top-level help
     if (positional.length === 0 || (positional.length === 0 && flags["help"])) {
         printTopLevelHelp();
@@ -741,13 +981,91 @@ async function main() {
         process.exit(1);
     }
     const resource = positional[0];
+    // Auth commands — dispatched before client creation
+    if (resource === "auth") {
+        const action = positional[1];
+        if (!action || flags["help"] === true) {
+            const lines = [
+                "Usage: dss auth <action> [--flags]",
+                "",
+                "Actions:",
+                ...Object.entries(AUTH_ACTIONS).map(([name, meta,]) => `  ${name}  \u2192  ${meta.usage}`),
+            ];
+            process.stderr.write(`${lines.join("\n")}\n`);
+            process.exit(flags["help"] === true ? 0 : 1);
+        }
+        const authMeta = AUTH_ACTIONS[action];
+        if (!authMeta) {
+            process.stderr.write(`Unknown action: auth ${action}\nAvailable: ${Object.keys(AUTH_ACTIONS).join(", ")}\n`);
+            process.exit(1);
+        }
+        await authMeta.handler(flags);
+        return;
+    }
+    // install-skill — dispatched before client creation
+    if (resource === "install-skill") {
+        if (flags["help"] === true) {
+            const lines = [
+                "Usage: dss install-skill [--global] [--agent NAME] [--list-agents]",
+                "",
+                "Install the dataiku-dss agent skill for detected coding agents.",
+                "",
+                "Flags:",
+                "  --global         Install to user-level global scope (default: project)",
+                "  --agent NAME     Target a specific agent: claude, codex, cursor, pi, omp",
+                "  --list-agents    Print detected agents and exit",
+            ];
+            process.stderr.write(`${lines.join("\n")}\n`);
+            process.exit(0);
+        }
+        const listOnly = flags["list-agents"] === true;
+        const agentFilter = typeof flags["agent"] === "string" ? flags["agent"] : undefined;
+        const isGlobal = flags["global"] === true;
+        // Resolve target agents
+        let targets;
+        if (agentFilter) {
+            const def = AGENTS[agentFilter];
+            if (!def) {
+                throw new UsageError(`Unknown agent: ${agentFilter}. Available: ${Object.keys(AGENTS).join(", ")}`);
+            }
+            targets = [{ id: agentFilter, def, via: "flag", },];
+        }
+        else {
+            targets = detectAgents();
+        }
+        if (listOnly) {
+            if (targets.length === 0) {
+                process.stderr.write("No coding agents detected.\n");
+            }
+            else {
+                process.stderr.write("Detected agents:\n");
+                for (const t of targets) {
+                    process.stderr.write(`  ${t.id}  (${t.def.name}, via ${t.via})\n`);
+                }
+            }
+            process.exit(0);
+        }
+        if (targets.length === 0) {
+            throw new UsageError("No coding agents detected. Install one (claude, codex, cursor, pi, omp) or use --agent NAME.");
+        }
+        const scope = isGlobal ? "global" : "project";
+        process.stderr.write(`Installing dataiku-dss skill (${scope} scope):\n`);
+        const results = installSkill(targets, { global: isGlobal, cwd: process.cwd(), });
+        for (const r of results) {
+            process.stderr.write(`  ${r.agent}  \u2192  ${r.path}\n`);
+        }
+        if (results.length > 0) {
+            process.stderr.write(`\nDone. ${results.length} skill(s) installed.\n`);
+        }
+        return;
+    }
     // Unknown resource
     if (!commands[resource]) {
         if (flags["help"]) {
             printTopLevelHelp();
             process.exit(0);
         }
-        process.stderr.write(`Unknown resource: ${resource}\nAvailable: ${RESOURCE_NAMES.join(", ")}\n`);
+        process.stderr.write(`Unknown resource: ${resource} \nAvailable: ${RESOURCE_NAMES.join(", ")} \n`);
         process.exit(1);
     }
     // Resource-level help
@@ -763,7 +1081,7 @@ async function main() {
     const actionMeta = commands[resource][action];
     // Unknown action
     if (!actionMeta) {
-        process.stderr.write(`Unknown action: ${resource} ${action}\nAvailable actions for ${resource}: ${Object.keys(commands[resource]).join(", ")}\n`);
+        process.stderr.write(`Unknown action: ${resource} ${action} \nAvailable actions for ${resource}: ${Object.keys(commands[resource]).join(", ")} \n`);
         process.exit(1);
     }
     // Action-level help
@@ -771,22 +1089,21 @@ async function main() {
         printActionHelp(resource, action);
         process.exit(0);
     }
-    // Validate config
-    const url = flags["url"] ?? process.env.DATAIKU_URL ?? "";
-    const apiKey = flags["api-key"] ?? process.env.DATAIKU_API_KEY ?? "";
+    // Resolve credentials: flags > env > saved > .env
+    const { url, apiKey, projectKey, } = resolveCredentials(flags);
     if (!url) {
-        process.stderr.write(`${JSON.stringify({ error: "Missing Dataiku URL. Set DATAIKU_URL or pass --url.", }, null, 2)}\n`);
-        process.exit(1);
+        throw new UsageError("Missing Dataiku URL. Set DATAIKU_URL, pass --url, or run: dss auth login");
     }
     if (!apiKey) {
-        process.stderr.write(`${JSON.stringify({ error: "Missing API key. Set DATAIKU_API_KEY or pass --api-key.", }, null, 2)}\n`);
-        process.exit(1);
+        throw new UsageError("Missing API key. Set DATAIKU_API_KEY, pass --api-key, or run: dss auth login");
     }
+    const requestTimeoutMs = num(flags["timeout"]) ?? undefined;
     const client = new DataikuClient({
         url,
         apiKey,
-        projectKey: flags["project-key"] ?? process.env.DATAIKU_PROJECT_KEY,
+        projectKey,
         verbose: flags["verbose"] === true,
+        requestTimeoutMs,
     });
     const args = positional.slice(2);
     const format = parseOutputFormat(flags["format"]);
@@ -795,7 +1112,7 @@ async function main() {
 }
 main().catch((err) => {
     if (err instanceof UsageError) {
-        process.stderr.write(`${err.message}\n`);
+        process.stderr.write(`${err.message} \n`);
         process.exit(1);
     }
     if (err instanceof DataikuError) {
@@ -806,10 +1123,10 @@ main().catch((err) => {
         };
         if (err.retryHint)
             payload.retryHint = err.retryHint;
-        process.stderr.write(`${JSON.stringify(payload, null, 2)}\n`);
+        process.stderr.write(`${JSON.stringify(payload, null, 2)} \n`);
         process.exit(err.category === "transient" ? 3 : 2);
     }
     const message = err instanceof Error ? err.message : String(err);
-    process.stderr.write(`${JSON.stringify({ error: message, }, null, 2)}\n`);
+    process.stderr.write(`${JSON.stringify({ error: message, }, null, 2)} \n`);
     process.exit(1);
 });

package/dist/src/config.d.ts

@@ -0,0 +1,11 @@
+export interface DssCredentials {
+    url: string;
+    apiKey: string;
+    projectKey?: string;
+}
+export declare function getConfigDir(): string;
+export declare function getCredentialsPath(): string;
+export declare function loadCredentials(): DssCredentials | null;
+export declare function saveCredentials(creds: DssCredentials): void;
+export declare function deleteCredentials(): void;
+export declare function maskApiKey(apiKey: string): string;

package/dist/src/config.js

@@ -0,0 +1,64 @@
+import { chmodSync, mkdirSync, readFileSync, unlinkSync, writeFileSync, } from "node:fs";
+import { homedir, } from "node:os";
+import { dirname, join, resolve, } from "node:path";
+export function getConfigDir() {
+    if (process.env.DSS_CONFIG_DIR)
+        return process.env.DSS_CONFIG_DIR;
+    if (process.env.XDG_CONFIG_HOME)
+        return resolve(process.env.XDG_CONFIG_HOME, "dataiku");
+    if (process.platform === "win32" && process.env.APPDATA) {
+        return resolve(process.env.APPDATA, "dataiku");
+    }
+    return resolve(homedir(), ".config", "dataiku");
+}
+export function getCredentialsPath() {
+    return join(getConfigDir(), "credentials.json");
+}
+export function loadCredentials() {
+    try {
+        const raw = readFileSync(getCredentialsPath(), "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed
+            || typeof parsed !== "object"
+            || Array.isArray(parsed)
+            || typeof parsed.url !== "string"
+            || typeof parsed.apiKey !== "string") {
+            return null;
+        }
+        const obj = parsed;
+        return {
+            url: obj.url,
+            apiKey: obj.apiKey,
+            projectKey: typeof obj.projectKey === "string" ? obj.projectKey : undefined,
+        };
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+export function saveCredentials(creds) {
+    const path = getCredentialsPath();
+    mkdirSync(dirname(path), { recursive: true, });
+    const data = { url: creds.url, apiKey: creds.apiKey, };
+    if (creds.projectKey)
+        data.projectKey = creds.projectKey;
+    writeFileSync(path, `${JSON.stringify(data, null, 2)}\n`, "utf-8");
+    chmodSync(path, 0o600);
+}
+export function deleteCredentials() {
+    try {
+        unlinkSync(getCredentialsPath());
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return;
+        throw err;
+    }
+}
+export function maskApiKey(apiKey) {
+    if (apiKey.length <= 12)
+        return "***";
+    return `${apiKey.slice(0, 6)}...${apiKey.slice(-6)}`;
+}

package/dist/src/index.d.ts

@@ -1,4 +1,6 @@
 export { DataikuClient, type DataikuClientConfig, } from "./client.js";
+export { validateCredentials, } from "./auth.js";
+export { deleteCredentials, type DssCredentials, getConfigDir, getCredentialsPath, loadCredentials, maskApiKey, saveCredentials, } from "./config.js";
 export { DataikuError, type DataikuErrorCategory, type DataikuErrorTaxonomy, type DataikuRetryMetadata, } from "./errors.js";
 export { CodeEnvsResource, } from "./resources/code-envs.js";
 export { ConnectionsResource, } from "./resources/connections.js";

package/dist/src/index.js

@@ -1,5 +1,8 @@
 // Client
 export { DataikuClient, } from "./client.js";
+// Auth & Config
+export { validateCredentials, } from "./auth.js";
+export { deleteCredentials, getConfigDir, getCredentialsPath, loadCredentials, maskApiKey, saveCredentials, } from "./config.js";
 // Errors
 export { DataikuError, } from "./errors.js";
 // Resources (for advanced use / extension)

package/dist/src/resources/recipes.d.ts

@@ -23,14 +23,22 @@ export declare class RecipesResource extends BaseResource {
      */
     update(recipeName: string, data: Record<string, unknown>, projectKey?: string): Promise<void>;
     /**
-     * Download a recipe code payload to a local file.
+    * Download a recipe code payload to a local file.
 
-     * Returns the path to the written file.
-     */
+    * Returns the path to the written file.
+    */
     downloadCode(recipeName: string, opts?: {
         outputPath?: string;
         projectKey?: string;
     }): Promise<string>;
+    /** Get only the code payload of a recipe as a raw string. */
+    getPayload(recipeName: string, opts?: {
+        projectKey?: string;
+    }): Promise<string>;
+    /** Replace only the code payload of a recipe. */
+    setPayload(recipeName: string, payload: string, opts?: {
+        projectKey?: string;
+    }): Promise<void>;
     /** Delete a recipe. */
     delete(recipeName: string, projectKey?: string): Promise<void>;
     /**

package/dist/src/resources/recipes.js

@@ -279,10 +279,10 @@ export class RecipesResource extends BaseResource {
         await this.client.put(`/public/api/projects/${enc}/recipes/${rnEnc}`, merged);
     }
     /**
-     * Download a recipe code payload to a local file.
+    * Download a recipe code payload to a local file.
 
-     * Returns the path to the written file.
-     */
+    * Returns the path to the written file.
+    */
     async downloadCode(recipeName, opts) {
         const result = await this.get(recipeName, {
             includePayload: true,
@@ -296,6 +296,30 @@ export class RecipesResource extends BaseResource {
         await writeFile(filePath, result.payload, "utf-8");
         return filePath;
     }
+    /** Get only the code payload of a recipe as a raw string. */
+    async getPayload(recipeName, opts) {
+        const result = await this.get(recipeName, {
+            includePayload: true,
+            projectKey: opts?.projectKey,
+        });
+        if (!result.payload) {
+            throw new Error(`Recipe "${recipeName}" has no code payload.`);
+        }
+        return result.payload;
+    }
+    /** Replace only the code payload of a recipe. */
+    async setPayload(recipeName, payload, opts) {
+        const current = await this.get(recipeName, {
+            includePayload: true,
+            projectKey: opts?.projectKey,
+        });
+        const enc = this.enc(opts?.projectKey);
+        const rnEnc = encodeURIComponent(recipeName);
+        await this.client.put(`/public/api/projects/${enc}/recipes/${rnEnc}`, {
+            ...current,
+            payload,
+        });
+    }
     /** Delete a recipe. */
     async delete(recipeName, projectKey) {
         const enc = this.enc(projectKey);

package/dist/src/skill.d.ts

@@ -0,0 +1,33 @@
+export interface AgentDef {
+    /** Display name */
+    name: string;
+    /** CLI binary name (for `which` detection) */
+    binary: string;
+    /** Config directory relative to HOME (for fallback detection) */
+    configDir: string;
+    /** Require config dir to exist even when binary is found (disambiguates shared binary names) */
+    configDirRequired?: boolean;
+    /** Skill path relative to HOME (global install) */
+    globalPath: (home: string) => string;
+    /** Skill path relative to CWD (project install). null = not supported. */
+    projectPath: string | null;
+    /** File to write inside the skill directory */
+    filename: string;
+    /** Content generator: standard SKILL.md or Cursor MDC */
+    content: () => string;
+}
+export declare const AGENTS: Record<string, AgentDef>;
+export interface DetectedAgent {
+    id: string;
+    def: AgentDef;
+    via: "binary" | "config-dir" | "flag";
+}
+export declare function detectAgents(): DetectedAgent[];
+export interface InstallResult {
+    agent: string;
+    path: string;
+}
+export declare function installSkill(agents: DetectedAgent[], opts: {
+    global: boolean;
+    cwd: string;
+}): InstallResult[];

package/dist/src/skill.js

@@ -0,0 +1,229 @@
+import { execFileSync, } from "node:child_process";
+import { existsSync, mkdirSync, writeFileSync, } from "node:fs";
+import { homedir, } from "node:os";
+import { join, } from "node:path";
+const SKILL_BODY = `# Dataiku DSS CLI
+
+The \`dss\` CLI (npm: dataiku-sdk) manages Dataiku DSS resources from the terminal.
+
+## When to use
+
+- Query, create, or modify DSS projects, datasets, recipes, jobs, or scenarios.
+- Build datasets or run scenarios and wait for completion.
+- Download or upload recipe code, dataset data, or managed folder files.
+- Run SQL queries against DSS connections.
+- Inspect project flows, job logs, or dataset schemas.
+
+## Installation
+
+Requires [Bun](https://bun.sh) runtime.
+
+\`\`\`bash
+bun add -g dataiku-sdk              # global install \u2014 provides the \`dss\` command
+\`\`\`
+
+Or run without installing:
+
+\`\`\`bash
+bunx dataiku-sdk <command>           # e.g. bunx dataiku-sdk auth login
+\`\`\`
+
+## Authentication
+
+\`\`\`bash
+dss auth login                       # interactive: prompts for URL, API key, project key
+dss auth login --url https://dss.example.com --api-key YOUR_KEY
+dss auth status                      # verify connection
+\`\`\`
+
+Credentials are saved to \`~/.dss/credentials.json\`. Alternatively set environment variables:
+
+\`\`\`bash
+export DATAIKU_URL=https://dss.example.com
+export DATAIKU_API_KEY=your-api-key
+export DATAIKU_PROJECT_KEY=MYPROJ    # optional default project
+\`\`\`
+
+## Workflows
+
+### Inspect a project
+
+\`\`\`bash
+dss project list                              # find the project key
+dss dataset list --project-key MYPROJ         # list its datasets
+dss dataset preview orders --max-rows 10      # peek at data
+dss dataset schema orders                     # inspect columns
+\`\`\`
+
+### Edit recipe code
+
+\`\`\`bash
+dss recipe download-code my-recipe -o code.py # download
+# ... edit code.py ...
+dss recipe diff my-recipe --file code.py      # review changes
+dss recipe set-payload my-recipe --file code.py  # upload
+\`\`\`
+
+### Build and monitor
+
+\`\`\`bash
+dss job build-and-wait my-dataset --include-logs  # build + wait + stream logs
+dss job list                                      # recent jobs
+dss job log <job-id>                               # full log output
+\`\`\`
+
+### Run a scenario
+
+\`\`\`bash
+dss scenario run my-scenario
+dss scenario status my-scenario               # check if finished
+\`\`\`
+
+## Command reference
+
+\`\`\`
+dss <resource> <action> [args...] [--flags]
+
+Resources: project, dataset, recipe, job, scenario, folder, notebook,
+           variable, code-env, connection, sql, auth, install-skill
+\`\`\`
+
+Use \`dss <resource> --help\` to see all actions and flags for any resource.
+
+## Key flags
+
+\`\`\`
+-f, --format FORMAT    json (default) | tsv | table | quiet
+-o, --output PATH      write output to file instead of stdout
+-v, --verbose          log HTTP requests to stderr
+    --project-key KEY  override default project for any command
+    --timeout MS       request timeout (default: 30000)
+    --stdin            read JSON input from stdin
+\`\`\`
+
+## Gotchas
+
+- **Most commands need a project key.** Set it once via \`dss auth login\` or \`DATAIKU_PROJECT_KEY\` to avoid passing \`--project-key\` on every call.
+- **Output is JSON by default.** Use \`-f table\` when showing results to a user; use \`-f tsv\` when piping to scripts.
+- **\`dss job build\` returns immediately.** Use \`dss job build-and-wait\` to block until the build finishes. Add \`--include-logs\` to stream log output.
+- **Folder commands accept names or IDs.** If a folder name contains spaces, quote it. The CLI resolves names to IDs automatically.
+- **Recipe set-payload overwrites the entire payload.** Always download first, edit, diff, then upload.
+- **Transient errors exit code 3, API errors exit code 2, usage errors exit code 1.** Check exit codes to distinguish retriable failures.
+`;
+const SKILL_FRONTMATTER = `---
+name: dataiku-dss
+description: >-
+  Interact with Dataiku DSS from the command line \u2014 list projects, query datasets,
+  download and upload recipe code, build datasets, run scenarios, and manage jobs.
+  Use when the user wants to work with Dataiku DSS resources, inspect a DSS project,
+  modify recipes, trigger builds, check job logs, or run SQL against DSS connections,
+  even if they don't explicitly mention the dss CLI.
+---
+
+`;
+function skillContent() {
+    return SKILL_FRONTMATTER + SKILL_BODY;
+}
+export const AGENTS = {
+    claude: {
+        name: "Claude Code",
+        binary: "claude",
+        configDir: ".claude",
+        globalPath: (home) => join(home, ".claude", "skills", "dataiku-dss"),
+        projectPath: ".claude/skills/dataiku-dss",
+        filename: "SKILL.md",
+        content: skillContent,
+    },
+    codex: {
+        name: "Codex",
+        binary: "codex",
+        configDir: ".codex",
+        globalPath: (home) => join(home, ".codex", "skills", "dataiku-dss"),
+        projectPath: ".codex/skills/dataiku-dss",
+        filename: "SKILL.md",
+        content: skillContent,
+    },
+    cursor: {
+        name: "Cursor",
+        binary: "cursor",
+        configDir: ".cursor",
+        globalPath: (home) => join(home, ".cursor", "skills", "dataiku-dss"),
+        projectPath: ".cursor/skills/dataiku-dss",
+        filename: "SKILL.md",
+        content: skillContent,
+    },
+    pi: {
+        name: "Pi",
+        binary: "pi",
+        configDir: ".pi",
+        globalPath: (home) => join(home, ".pi", "agent", "skills", "dataiku-dss"),
+        projectPath: ".pi/skills/dataiku-dss",
+        filename: "SKILL.md",
+        content: skillContent,
+    },
+    omp: {
+        name: "OhMyPi",
+        binary: "omp",
+        configDir: join(".omp", "agent"),
+        configDirRequired: true,
+        globalPath: (home) => join(home, ".omp", "agent", "skills", "dataiku-dss"),
+        projectPath: ".omp/skills/dataiku-dss",
+        filename: "SKILL.md",
+        content: skillContent,
+    },
+};
+// ---------------------------------------------------------------------------
+// Agent detection
+// ---------------------------------------------------------------------------
+function binaryExists(name) {
+    const cmd = process.platform === "win32" ? "where" : "which";
+    try {
+        execFileSync(cmd, [name,], { stdio: "pipe", });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function detectAgents() {
+    const home = homedir();
+    const found = [];
+    for (const [id, def,] of Object.entries(AGENTS)) {
+        const hasBinary = binaryExists(def.binary);
+        const hasConfigDir = existsSync(join(home, def.configDir));
+        if (hasBinary && (!def.configDirRequired || hasConfigDir)) {
+            found.push({ id, def, via: "binary", });
+        }
+        else if (hasConfigDir) {
+            found.push({ id, def, via: "config-dir", });
+        }
+    }
+    return found;
+}
+export function installSkill(agents, opts) {
+    const home = homedir();
+    const results = [];
+    for (const { id, def, } of agents) {
+        let dir;
+        if (opts.global) {
+            const globalDir = def.globalPath(home);
+            if (!globalDir) {
+                process.stderr.write(`  ${def.name}: skipped (no global path available)\n`);
+                continue;
+            }
+            dir = globalDir;
+        }
+        else {
+            if (!def.projectPath) {
+                process.stderr.write(`  ${def.name}: skipped (no project path available)\n`);
+                continue;
+            }
+            dir = join(opts.cwd, def.projectPath);
+        }
+        mkdirSync(dir, { recursive: true, });
+        const filePath = join(dir, def.filename);
+        writeFileSync(filePath, def.content(), "utf-8");
+        results.push({ agent: id, path: filePath, });
+    }
+    return results;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "dataiku-sdk",
-	"version": "0.1.2",
+	"version": "0.2.0",
 	"description": "Dataiku DSS SDK and CLI for programmatic access to DSS REST APIs",
 	"type": "module",
 	"workspaces": [