dataiku-sdk 0.2.2 → 0.2.4

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

@@ -14,9 +14,9 @@ export type SafeParseResult<T> = {
     errors: string[];
 };
 /**
- * Validate `data` against a TypeBox schema without throwing.
- * Always returns the data (cast as T) — on mismatch, includes human-readable
- * error strings so callers can warn instead of crash.
+ * Validate `data` against a TypeBox schema without throwing, even when invalid
+ * values are not JSON-serializable. Always returns the original data (cast as T)
+ * and includes human-readable error strings so callers can warn instead of crash.
  */
 export declare function safeParseSchema<S extends TSchema>(schema: S, data: unknown): SafeParseResult<Static<S>>;
 export declare const ProjectSummarySchema: import("@sinclair/typebox").TObject<{

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

@@ -12,15 +12,65 @@ export function parseSchema(schema, data) {
     return data;
 }
 /**
- * Validate `data` against a TypeBox schema without throwing.
- * Always returns the data (cast as T) — on mismatch, includes human-readable
- * error strings so callers can warn instead of crash.
+ * Format invalid values for validation errors without throwing on BigInt, circular,
+ * function, symbol, or other non-JSON-serializable input.
+ */
+function formatInvalidValue(value) {
+    if (value === undefined)
+        return "undefined";
+    if (typeof value === "bigint")
+        return `${value.toString()}n`;
+    if (typeof value === "symbol") {
+        return value.description === undefined ? "Symbol()" : `Symbol(${value.description})`;
+    }
+    if (typeof value === "function") {
+        return value.name ? `[Function ${value.name}]` : "[Function anonymous]";
+    }
+    const seen = new WeakSet();
+    try {
+        const json = JSON.stringify(value, (_key, nestedValue) => {
+            if (typeof nestedValue === "bigint")
+                return `${nestedValue.toString()}n`;
+            if (typeof nestedValue === "symbol") {
+                return nestedValue.description === undefined
+                    ? "Symbol()"
+                    : `Symbol(${nestedValue.description})`;
+            }
+            if (typeof nestedValue === "function") {
+                return nestedValue.name
+                    ? `[Function ${nestedValue.name}]`
+                    : "[Function anonymous]";
+            }
+            if (nestedValue !== null && typeof nestedValue === "object") {
+                if (seen.has(nestedValue))
+                    return "[Circular]";
+                seen.add(nestedValue);
+            }
+            return nestedValue;
+        });
+        if (json !== undefined)
+            return json;
+    }
+    catch {
+        // Ignore serialization failures and fall back to a safer summary below.
+    }
+    try {
+        return Object.prototype.toString.call(value);
+    }
+    catch {
+        return "[Unformattable value]";
+    }
+}
+/**
+ * Validate `data` against a TypeBox schema without throwing, even when invalid
+ * values are not JSON-serializable. Always returns the original data (cast as T)
+ * and includes human-readable error strings so callers can warn instead of crash.
  */
 export function safeParseSchema(schema, data) {
     if (Value.Check(schema, data)) {
         return { success: true, data: data, };
     }
-    const errors = [...Value.Errors(schema, data),].map((e) => `${e.path}: ${e.message} (got ${JSON.stringify(e.value)})`);
+    const errors = [...Value.Errors(schema, data),].map((e) => `${e.path}: ${e.message} (got ${formatInvalidValue(e.value)})`);
     return { success: false, data: data, errors, };
 }
 // ---------------------------------------------------------------------------

package/dist/src/auth.d.ts

@@ -1,4 +1,7 @@
-export declare function validateCredentials(url: string, apiKey: string): Promise<{
+import { DataikuError } from "./errors.js";
+export interface CredentialValidationResult {
     valid: boolean;
     error?: string;
-}>;
+    dataikuError?: DataikuError;
+}
+export declare function validateCredentials(url: string, apiKey: string): Promise<CredentialValidationResult>;

package/dist/src/auth.js

@@ -13,7 +13,7 @@ export async function validateCredentials(url, apiKey) {
     }
     catch (err) {
         if (err instanceof DataikuError) {
-            return { valid: false, error: err.message, };
+            return { valid: false, error: err.message, dataikuError: err, };
         }
         return { valid: false, error: err instanceof Error ? err.message : String(err), };
     }

package/dist/src/cli.js

@@ -9,7 +9,7 @@ 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";
+import { AGENTS, detectAgents, findWorkspaceRoot, installSkill, } from "./skill.js";
 // ---------------------------------------------------------------------------
 // Utility helpers
 // ---------------------------------------------------------------------------
@@ -150,7 +150,18 @@ function writeCommandResult(result, format) {
 // ---------------------------------------------------------------------------
 // Arg parsing
 // ---------------------------------------------------------------------------
-const BOOLEAN_FLAGS = new Set(["help", "verbose", "version", "stdin", "global", "list-agents",]);
+const BOOLEAN_FLAGS = new Set([
+    "help",
+    "verbose",
+    "version",
+    "stdin",
+    "global",
+    "list-agents",
+    "include-raw",
+    "include-payload",
+    "include-logs",
+    "replace",
+]);
 const SHORT_FLAGS = {
     h: "help",
     v: "verbose",
@@ -162,6 +173,15 @@ const SHORT_FLAGS = {
 const FLAG_ALIASES = {
     project: "project-key",
 };
+function isNegativeNumberToken(value) {
+    return value.startsWith("-") && Number.isFinite(Number(value));
+}
+function requireFlagValue(flagLabel, next) {
+    if (next === undefined || (next.startsWith("-") && !isNegativeNumberToken(next))) {
+        throw new UsageError(`Flag ${flagLabel} requires a value.`);
+    }
+    return next;
+}
 function parseArgs(argv) {
     const positional = [];
     const flags = {};
@@ -179,19 +199,15 @@ function parseArgs(argv) {
                 flags[FLAG_ALIASES[raw] ?? raw] = arg.slice(eqIdx + 1);
             }
             else {
-                const flagName = FLAG_ALIASES[arg.slice(2)] ?? arg.slice(2);
+                const rawFlagName = arg.slice(2);
+                const flagName = FLAG_ALIASES[rawFlagName] ?? rawFlagName;
                 if (BOOLEAN_FLAGS.has(flagName)) {
                     flags[flagName] = true;
                 }
                 else {
-                    const next = argv[i + 1];
-                    if (next !== undefined && !next.startsWith("-")) {
-                        flags[flagName] = next;
-                        i++;
-                    }
-                    else {
-                        flags[flagName] = true;
-                    }
+                    const next = requireFlagValue(`--${rawFlagName}`, argv[i + 1]);
+                    flags[flagName] = next;
+                    i++;
                 }
             }
         }
@@ -202,14 +218,9 @@ function parseArgs(argv) {
                     flags[long] = true;
                 }
                 else {
-                    const next = argv[i + 1];
-                    if (next !== undefined && !next.startsWith("-")) {
-                        flags[long] = next;
-                        i++;
-                    }
-                    else {
-                        flags[long] = true;
-                    }
+                    const next = requireFlagValue(`-${arg[1]}`, argv[i + 1]);
+                    flags[long] = next;
+                    i++;
                 }
             }
             else {
@@ -886,6 +897,8 @@ const AUTH_ACTIONS = {
             const result = await validateCredentials(url, apiKey);
             if (!result.valid) {
                 process.stderr.write(`✗ Failed\n`);
+                if (result.dataikuError)
+                    throw result.dataikuError;
                 throw new DataikuError(0, "Authentication Failed", result.error ?? "Credential validation failed");
             }
             process.stderr.write("\u2713 Connected\n");
@@ -1021,13 +1034,14 @@ async function main() {
     if (resource === "install-skill") {
         if (flags["help"] === true) {
             const lines = [
-                "Usage: dss install-skill [--global] [--agent NAME] [--list-agents]",
+                "Usage: dss install-skill [--global] [--agent NAME] [--target PATH] [--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",
+                "  --target PATH    Project directory to install into (default: workspace root)",
                 "  --list-agents    Print detected agents and exit",
             ];
             process.stderr.write(`${lines.join("\n")}\n`);
@@ -1036,6 +1050,7 @@ async function main() {
         const listOnly = flags["list-agents"] === true;
         const agentFilter = typeof flags["agent"] === "string" ? flags["agent"] : undefined;
         const isGlobal = flags["global"] === true;
+        const targetDir = typeof flags["target"] === "string" ? flags["target"] : undefined;
         // Resolve target agents
         let targets;
         if (agentFilter) {
@@ -1064,8 +1079,9 @@ async function main() {
             throw new UsageError("No coding agents detected. Install one (claude, codex, cursor, pi, omp) or use --agent NAME.");
         }
         const scope = isGlobal ? "global" : "project";
+        const cwd = targetDir ?? (isGlobal ? process.cwd() : findWorkspaceRoot(process.cwd()));
         process.stderr.write(`Installing dataiku-dss skill (${scope} scope):\n`);
-        const results = installSkill(targets, { global: isGlobal, cwd: process.cwd(), });
+        const results = installSkill(targets, { global: isGlobal, cwd, });
         for (const r of results) {
             process.stderr.write(`  ${r.agent}  \u2192  ${r.path}\n`);
         }

package/dist/src/client.d.ts

@@ -81,9 +81,10 @@ export declare class DataikuClient {
      */
     parse<S extends TSchema>(schema: S, data: unknown): Static<S>;
     /**
-     * Validate raw data against a TypeBox schema without throwing.
-     * Always returns the data. On mismatch, fires onValidationWarning callback
-     * with the method name and error details.
+     * Validate raw data against a TypeBox schema without throwing, even when
+     * mismatched values are not JSON-serializable. Always returns the original
+     * data, and on mismatch emits onValidationWarning with the method name and
+     * error details. If the callback throws, that error still propagates.
      */
     safeParse<S extends TSchema>(schema: S, data: unknown, method: string): Static<S>;
     /** Emit a validation warning via the configured callback. */

package/dist/src/client.js

@@ -223,9 +223,10 @@ export class DataikuClient {
         return data;
     }
     /**
-     * Validate raw data against a TypeBox schema without throwing.
-     * Always returns the data. On mismatch, fires onValidationWarning callback
-     * with the method name and error details.
+     * Validate raw data against a TypeBox schema without throwing, even when
+     * mismatched values are not JSON-serializable. Always returns the original
+     * data, and on mismatch emits onValidationWarning with the method name and
+     * error details. If the callback throws, that error still propagates.
      */
     safeParse(schema, data, method) {
         const result = safeParseSchema(schema, data);

package/dist/src/skill.d.ts

@@ -23,6 +23,11 @@ export interface DetectedAgent {
     via: "binary" | "config-dir" | "flag";
 }
 export declare function detectAgents(): DetectedAgent[];
+/**
+ * Walk upward from startDir looking for common workspace markers.
+ * Returns the first directory containing a marker, or startDir if none found.
+ */
+export declare function findWorkspaceRoot(startDir: string): string;
 export interface InstallResult {
     agent: string;
     path: string;

package/dist/src/skill.js

@@ -1,7 +1,7 @@
 import { execFileSync, } from "node:child_process";
 import { existsSync, mkdirSync, writeFileSync, } from "node:fs";
 import { homedir, } from "node:os";
-import { join, } from "node:path";
+import { dirname, join, } from "node:path";
 const SKILL_BODY = `# Dataiku DSS CLI
 
 The \`dss\` CLI (npm: dataiku-sdk) manages Dataiku DSS resources from the terminal.
@@ -36,7 +36,7 @@ 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:
+Credentials are saved to \`~/.config/dataiku/credentials.json\`. Alternatively set environment variables:
 
 \`\`\`bash
 export DATAIKU_URL=https://dss.example.com
@@ -200,6 +200,31 @@ export function detectAgents() {
     }
     return found;
 }
+// ---------------------------------------------------------------------------
+// Skill installation
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// Workspace root detection
+// ---------------------------------------------------------------------------
+const WORKSPACE_MARKERS = [".git", ".cursor", ".claude", ".codex", ".pi", ".omp", ".vscode",];
+/**
+ * Walk upward from startDir looking for common workspace markers.
+ * Returns the first directory containing a marker, or startDir if none found.
+ */
+export function findWorkspaceRoot(startDir) {
+    let dir = startDir;
+    for (let i = 0; i < 20; i++) {
+        for (const marker of WORKSPACE_MARKERS) {
+            if (existsSync(join(dir, marker)))
+                return dir;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return startDir;
+}
 export function installSkill(agents, opts) {
     const home = homedir();
     const results = [];

package/package.json

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

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

@@ -14,9 +14,9 @@ export type SafeParseResult<T> = {
     errors: string[];
 };
 /**
- * Validate `data` against a TypeBox schema without throwing.
- * Always returns the data (cast as T) — on mismatch, includes human-readable
- * error strings so callers can warn instead of crash.
+ * Validate `data` against a TypeBox schema without throwing, even when invalid
+ * values are not JSON-serializable. Always returns the original data (cast as T)
+ * and includes human-readable error strings so callers can warn instead of crash.
  */
 export declare function safeParseSchema<S extends TSchema>(schema: S, data: unknown): SafeParseResult<Static<S>>;
 export declare const ProjectSummarySchema: import("@sinclair/typebox").TObject<{

package/packages/types/dist/index.js

@@ -12,15 +12,65 @@ export function parseSchema(schema, data) {
     return data;
 }
 /**
- * Validate `data` against a TypeBox schema without throwing.
- * Always returns the data (cast as T) — on mismatch, includes human-readable
- * error strings so callers can warn instead of crash.
+ * Format invalid values for validation errors without throwing on BigInt, circular,
+ * function, symbol, or other non-JSON-serializable input.
+ */
+function formatInvalidValue(value) {
+    if (value === undefined)
+        return "undefined";
+    if (typeof value === "bigint")
+        return `${value.toString()}n`;
+    if (typeof value === "symbol") {
+        return value.description === undefined ? "Symbol()" : `Symbol(${value.description})`;
+    }
+    if (typeof value === "function") {
+        return value.name ? `[Function ${value.name}]` : "[Function anonymous]";
+    }
+    const seen = new WeakSet();
+    try {
+        const json = JSON.stringify(value, (_key, nestedValue) => {
+            if (typeof nestedValue === "bigint")
+                return `${nestedValue.toString()}n`;
+            if (typeof nestedValue === "symbol") {
+                return nestedValue.description === undefined
+                    ? "Symbol()"
+                    : `Symbol(${nestedValue.description})`;
+            }
+            if (typeof nestedValue === "function") {
+                return nestedValue.name
+                    ? `[Function ${nestedValue.name}]`
+                    : "[Function anonymous]";
+            }
+            if (nestedValue !== null && typeof nestedValue === "object") {
+                if (seen.has(nestedValue))
+                    return "[Circular]";
+                seen.add(nestedValue);
+            }
+            return nestedValue;
+        });
+        if (json !== undefined)
+            return json;
+    }
+    catch {
+        // Ignore serialization failures and fall back to a safer summary below.
+    }
+    try {
+        return Object.prototype.toString.call(value);
+    }
+    catch {
+        return "[Unformattable value]";
+    }
+}
+/**
+ * Validate `data` against a TypeBox schema without throwing, even when invalid
+ * values are not JSON-serializable. Always returns the original data (cast as T)
+ * and includes human-readable error strings so callers can warn instead of crash.
  */
 export function safeParseSchema(schema, data) {
     if (Value.Check(schema, data)) {
         return { success: true, data: data, };
     }
-    const errors = [...Value.Errors(schema, data),].map((e) => `${e.path}: ${e.message} (got ${JSON.stringify(e.value)})`);
+    const errors = [...Value.Errors(schema, data),].map((e) => `${e.path}: ${e.message} (got ${formatInvalidValue(e.value)})`);
     return { success: false, data: data, errors, };
 }
 // ---------------------------------------------------------------------------