@kweaver-ai/kweaver-sdk 0.4.10 → 0.4.12

package/dist/commands/auth.js

@@ -4,19 +4,24 @@ export async function runAuthCommand(args) {
     const target = args[0];
     const rest = args.slice(1);
     if (!target || target === "--help" || target === "-h") {
-        console.log(`kweaver auth login <url> [--alias <name>] [-u user] [-p pass] [--playwright]
-kweaver auth <url>           Login (shorthand; same options as login)
-kweaver auth status [url|alias]
-kweaver auth list            List saved platforms
-kweaver auth use <url|alias> Switch active platform
-kweaver auth logout [url|alias]   Logout (clear local token)
-kweaver auth delete <url|alias>   Delete saved credentials
+        console.log(`kweaver auth login <url> [options]   Login to a platform (browser OAuth2 by default)
+kweaver auth <url>                   Login (shorthand; same options as login)
+kweaver auth status [url|alias]      Show current auth status
+kweaver auth list                    List saved platforms
+kweaver auth use <url|alias>         Switch active platform
+kweaver auth logout [url|alias]      Logout (clear local token)
+kweaver auth delete <url|alias>      Delete saved credentials
 
-Login options (browser OAuth2 by default; use -u/-p for headless Playwright):
-  --alias <name>   Short name for this platform (use with auth use / status / logout)
-  -u, --username   Username (with -p triggers Playwright login)
-  -p, --password   Password
-  --playwright     Force browser (Playwright) login even without -u/-p`);
+Login options:
+  --alias <name>         Save platform with a short alias (use with use / status / logout)
+  --client-id <id>       Use an existing OAuth2 client ID instead of registering a new one.
+                         Use the platform's web app client ID to get the same permissions
+                         as the browser. Find it in DevTools: /oauth2/auth?client_id=<id>
+  --client-secret <s>    Client secret (omit for public/PKCE clients)
+  -u, --username         Username (with -p triggers Playwright headless login)
+  -p, --password         Password
+  --playwright           Force Playwright browser login even without -u/-p
+  --insecure, -k         Skip TLS certificate verification (self-signed / dev HTTPS only)`);
         return 0;
     }
     if (target === "login") {
@@ -38,21 +43,33 @@ Login options (browser OAuth2 by default; use -u/-p for headless Playwright):
             const username = readOption(args, "--username") ?? readOption(args, "-u");
             const password = readOption(args, "--password") ?? readOption(args, "-p");
             const usePlaywright = args.includes("--playwright");
+            const clientId = readOption(args, "--client-id");
+            const clientSecret = readOption(args, "--client-secret");
+            const tlsInsecure = args.includes("--insecure") || args.includes("-k");
             let token;
             if (username && password) {
                 // Headless Playwright login with credentials
                 console.log("Logging in (headless)...");
-                token = await playwrightLogin(normalizedTarget, { username, password });
+                token = await playwrightLogin(normalizedTarget, { username, password, tlsInsecure });
             }
             else if (usePlaywright) {
                 // Explicit Playwright fallback
                 console.log("Opening browser for login (Playwright)...");
-                token = await playwrightLogin(normalizedTarget);
+                token = await playwrightLogin(normalizedTarget, { tlsInsecure });
             }
             else {
                 // Default: OAuth2 authorization code flow (supports refresh_token)
-                console.log("Opening browser for OAuth2 login...");
-                token = await oauth2Login(normalizedTarget);
+                if (clientId) {
+                    console.log(`Opening browser for OAuth2 login (client: ${clientId})...`);
+                }
+                else {
+                    console.log("Opening browser for OAuth2 login...");
+                }
+                token = await oauth2Login(normalizedTarget, {
+                    clientId: clientId ?? undefined,
+                    clientSecret: clientSecret ?? undefined,
+                    tlsInsecure,
+                });
             }
             if (alias) {
                 setPlatformAlias(normalizedTarget, alias);
@@ -106,6 +123,9 @@ Login options (browser OAuth2 by default; use -u/-p for headless Playwright):
             `Token present: yes`,
         ];
         lines.push(`Refresh token: ${token.refreshToken ? "yes (auto-refresh enabled)" : "no"}`);
+        if (token.tlsInsecure) {
+            lines.push(`TLS: certificate verification disabled (saved; dev only)`);
+        }
         if (token.expiresAt) {
             const expiry = new Date(token.expiresAt);
             const remainingMs = expiry.getTime() - Date.now();

package/dist/commands/bkn.js

@@ -8,11 +8,12 @@ import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/
 import { listKnowledgeNetworks, getKnowledgeNetwork, createKnowledgeNetwork, updateKnowledgeNetwork, deleteKnowledgeNetwork, listObjectTypes, listRelationTypes, listActionTypes, getObjectType, createObjectTypes, updateObjectType, deleteObjectTypes, getRelationType, createRelationTypes, updateRelationType, deleteRelationTypes, buildKnowledgeNetwork, getBuildStatus, } from "../api/knowledge-networks.js";
 import { objectTypeQuery, objectTypeProperties, subgraph, actionTypeQuery, actionTypeExecute, actionExecutionGet, actionLogsList, actionLogGet, actionLogCancel, } from "../api/ontology-query.js";
 import { semanticSearch } from "../api/semantic-search.js";
-import { listTablesWithColumns } from "../api/datasources.js";
-import { createDataView } from "../api/dataviews.js";
+import { listTablesWithColumns, scanMetadata, getDatasource } from "../api/datasources.js";
+import { createDataView, findDataView } from "../api/dataviews.js"; // used by runKnCreateFromDsCommand
 import { downloadBkn, uploadBkn } from "../api/bkn-backend.js";
 import { formatCallOutput } from "./call.js";
 import { resolveBusinessDomain } from "../config/store.js";
+import { runDsImportCsv } from "./ds.js";
 export function formatSimpleKnList(text, pretty, includeDetail = false) {
     const parsed = JSON.parse(text);
     const entries = Array.isArray(parsed.entries) ? parsed.entries : [];
@@ -600,6 +601,8 @@ Subcommands:
   get <kn-id> [options]   Get knowledge network detail (use --stats or --export)
   create [options]     Create a knowledge network (empty or from --body-file)
   create-from-ds <ds-id> --name X [--tables a,b] [--build]   Create KN from datasource
+  create-from-csv <ds-id> --files <glob> --name X [--table-prefix P] [--build]
+    Import CSVs then create knowledge network
   update <kn-id> [options]  Update a knowledge network
   delete <kn-id>       Delete a knowledge network
   build <kn-id> [--wait|--no-wait] [--timeout n]   Trigger full build
@@ -646,6 +649,8 @@ export async function runKnCommand(args) {
             return runKnCreateCommand(rest);
         if (subcommand === "create-from-ds")
             return runKnCreateFromDsCommand(rest);
+        if (subcommand === "create-from-csv")
+            return runKnCreateFromCsvCommand(rest);
         if (subcommand === "update")
             return runKnUpdateCommand(rest);
         if (subcommand === "delete")
@@ -1074,20 +1079,18 @@ export function parseKnActionTypeExecuteArgs(args) {
         timeout,
     };
 }
-const PK_CANDIDATES = new Set(["id", "pk", "key"]);
-const PK_TYPES = new Set(["integer", "unsigned integer", "string", "varchar", "bigint", "int"]);
 const DISPLAY_HINTS = ["name", "title", "label", "display_name", "description"];
-function detectPrimaryKey(table) {
-    for (const col of table.columns) {
-        if (PK_CANDIDATES.has(col.name.toLowerCase()) && PK_TYPES.has(col.type.toLowerCase())) {
-            return col.name;
-        }
-    }
-    for (const col of table.columns) {
-        if (PK_TYPES.has(col.type.toLowerCase())) {
-            return col.name;
+/** Detect primary key: first column (left-to-right) with all unique values in the sample. */
+function detectPrimaryKey(table, rows) {
+    if (rows && rows.length > 0) {
+        for (const col of table.columns) {
+            const values = rows.map((r) => r[col.name]);
+            const unique = new Set(values);
+            if (unique.size === rows.length)
+                return col.name;
         }
     }
+    // Fallback: first column
     return table.columns[0]?.name ?? "id";
 }
 function detectDisplayKey(table, primaryKey) {
@@ -2141,7 +2144,25 @@ function parseKnCreateFromDsArgs(args) {
         businessDomain = resolveBusinessDomain();
     return { dsId, name, tables, build, timeout, businessDomain, pretty };
 }
-async function runKnCreateFromDsCommand(args) {
+/** Sanitize a table name into a BKN-safe ID (alphanumeric + underscore). */
+function sanitizeBknId(name) {
+    return name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^(\d)/, "_$1");
+}
+/** Generate a BKN ObjectType YAML markdown file for a table. */
+function generateObjectTypeBkn(tableName, dvId, pk, dk, columns) {
+    const safeId = sanitizeBknId(tableName);
+    const header = `## ObjectType: ${safeId}\n\n**${tableName}**\n`;
+    const dsTable = `### Data Source\n\n| Type | ID | Name |\n|------|-----|------|\n| data_view | ${dvId} | ${tableName} |\n`;
+    const dpHeader = `### Data Properties\n\n| Property | Display Name | Type | Primary Key | Display Key |\n|----------|-------------|------|-------------|-------------|\n`;
+    const dpRows = columns.map((c) => {
+        const isPk = c.name === pk ? "yes" : "no";
+        const isDk = c.name === dk ? "yes" : "no";
+        return `| ${c.name} | ${c.name} | string | ${isPk} | ${isDk} |`;
+    }).join("\n");
+    const frontmatter = `---\ntype: object_type\nid: ${safeId}\nname: ${tableName}\n---\n\n`;
+    return `${frontmatter}${header}\n${dsTable}\n${dpHeader}${dpRows}\n`;
+}
+async function runKnCreateFromDsCommand(args, sampleRows) {
     let options;
     try {
         options = parseKnCreateFromDsArgs(args);
@@ -2170,17 +2191,28 @@ async function runKnCreateFromDsCommand(args) {
             console.error("No tables available");
             return 1;
         }
+        // Phase 1: Create DataViews for each table
+        console.error(`Creating data views for ${targetTables.length} table(s) ...`);
         const viewMap = {};
         for (const t of targetTables) {
-            const dvId = await createDataView({
+            const found = await findDataView({
                 ...base,
                 name: t.name,
                 datasourceId: options.dsId,
-                table: t.name,
-                fields: t.columns.map((c) => ({ name: c.name, type: c.type })),
+                exact: true,
+                wait: true,
             });
+            const dvId = found[0]?.id ??
+                (await createDataView({
+                    ...base,
+                    name: t.name,
+                    datasourceId: options.dsId,
+                    table: t.name,
+                    fields: t.columns.map((c) => ({ name: c.name, type: c.type })),
+                }));
             viewMap[t.name] = dvId;
         }
+        // Phase 2: Create the KN record
         const knBody = JSON.stringify({
             name: options.name,
             branch: "main",
@@ -2193,20 +2225,25 @@ async function runKnCreateFromDsCommand(args) {
         const knParsed = JSON.parse(knResponse);
         const knItem = Array.isArray(knParsed) ? knParsed[0] : knParsed;
         const knId = String(knItem?.id ?? "");
+        console.error(`Knowledge network created: ${knId}`);
+        // Phase 3: Create object types via REST API
+        console.error(`Creating ${targetTables.length} object type(s) ...`);
         const otResults = [];
         for (const t of targetTables) {
-            const pk = detectPrimaryKey(t);
+            const pk = detectPrimaryKey(t, sampleRows?.[t.name]);
             const dk = detectDisplayKey(t, pk);
+            const uniqueProps = [pk, dk].filter((x, i, a) => a.indexOf(x) === i);
             const entry = {
                 branch: "main",
                 name: t.name,
                 data_source: { type: "data_view", id: viewMap[t.name] },
                 primary_keys: [pk],
                 display_key: dk,
-                data_properties: [pk, dk].filter((x, i, a) => a.indexOf(x) === i).map((n) => ({
-                    name: n,
-                    display_name: n,
+                data_properties: t.columns.map((c) => ({
+                    name: c.name,
+                    display_name: c.name,
                     type: "string",
+                    mapped_field: { name: c.name, type: c.type || "varchar" },
                 })),
             };
             const otBody = JSON.stringify({ entries: [entry] });
@@ -2222,6 +2259,16 @@ async function runKnCreateFromDsCommand(args) {
                 id: otItem?.id ?? "",
                 field_count: t.columns.length,
             });
+            console.error(`  Created: ${t.name} (${t.columns.length} fields, pk=${pk}, dk=${dk})`);
+        }
+        if (otResults.length === 0) {
+            const errorOutput = {
+                kn_id: knId,
+                kn_name: options.name,
+                error: "No object types were created",
+            };
+            console.log(JSON.stringify(errorOutput, null, options.pretty ? 2 : 0));
+            return 1;
         }
         let statusStr = "skipped";
         if (options.build) {
@@ -2749,3 +2796,149 @@ async function runKnSearchCommand(args) {
         return 1;
     }
 }
+const KN_CREATE_FROM_CSV_HELP = `kweaver bkn create-from-csv <ds-id> --files <glob> --name X [options]
+
+Import CSV files into datasource, then create a knowledge network.
+
+Options:
+  --files <s>          CSV file paths (comma-separated or glob, required)
+  --name <s>           Knowledge network name (required)
+  --table-prefix <s>   Table name prefix (default: none)
+  --batch-size <n>     Rows per batch (default: 500)
+  --tables <a,b>       Tables to include in KN (default: all imported)
+  --build (default)    Build after creation
+  --no-build           Skip build
+  --timeout <n>        Build timeout in seconds (default: 300)
+  -bd, --biz-domain    Business domain (default: bd_public)`;
+function parseKnCreateFromCsvArgs(args) {
+    let dsId = "";
+    let files = "";
+    let name = "";
+    let tablePrefix = "";
+    let batchSize = 500;
+    let tablesStr = "";
+    let build = true;
+    let timeout = 300;
+    let businessDomain = "";
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h")
+            throw new Error("help");
+        if (arg === "--files" && args[i + 1]) {
+            files = args[++i];
+            continue;
+        }
+        if (arg === "--name" && args[i + 1]) {
+            name = args[++i];
+            continue;
+        }
+        if (arg === "--table-prefix" && args[i + 1]) {
+            tablePrefix = args[++i];
+            continue;
+        }
+        if (arg === "--batch-size" && args[i + 1]) {
+            batchSize = parseInt(args[++i], 10);
+            if (Number.isNaN(batchSize) || batchSize < 1)
+                batchSize = 500;
+            continue;
+        }
+        if (arg === "--tables" && args[i + 1]) {
+            tablesStr = args[++i];
+            continue;
+        }
+        if (arg === "--build") {
+            build = true;
+            continue;
+        }
+        if (arg === "--no-build") {
+            build = false;
+            continue;
+        }
+        if (arg === "--timeout" && args[i + 1]) {
+            timeout = parseInt(args[++i], 10);
+            if (Number.isNaN(timeout) || timeout < 1)
+                timeout = 300;
+            continue;
+        }
+        if ((arg === "-bd" || arg === "--biz-domain") && args[i + 1]) {
+            businessDomain = args[++i];
+            continue;
+        }
+        if (!arg.startsWith("-") && !dsId) {
+            dsId = arg;
+        }
+    }
+    const tables = tablesStr ? tablesStr.split(",").map((s) => s.trim()).filter(Boolean) : [];
+    if (!dsId || !files || !name) {
+        throw new Error("Usage: kweaver bkn create-from-csv <ds-id> --files <glob> --name X [options]");
+    }
+    if (!businessDomain)
+        businessDomain = resolveBusinessDomain();
+    return { dsId, files, name, tablePrefix, batchSize, tables, build, timeout, businessDomain };
+}
+async function runKnCreateFromCsvCommand(args) {
+    let options;
+    try {
+        options = parseKnCreateFromCsvArgs(args);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "help") {
+            console.log(KN_CREATE_FROM_CSV_HELP);
+            return 0;
+        }
+        console.error(formatHttpError(error));
+        return 1;
+    }
+    // Phase 1: Import CSVs
+    console.error("Phase 1: Importing CSVs ...");
+    const importArgs = [
+        options.dsId,
+        "--files", options.files,
+        "--table-prefix", options.tablePrefix,
+        "--batch-size", String(options.batchSize),
+        "-bd", options.businessDomain,
+    ];
+    const importResult = await runDsImportCsv(importArgs);
+    if (importResult.code !== 0) {
+        console.error("CSV import failed — aborting KN creation");
+        return importResult.code;
+    }
+    // Phase 1.5: Scan datasource metadata so platform discovers newly imported tables
+    console.error("Scanning datasource metadata ...");
+    try {
+        const token = await ensureValidToken();
+        const dsBody = await getDatasource({
+            baseUrl: token.baseUrl,
+            accessToken: token.accessToken,
+            id: options.dsId,
+            businessDomain: options.businessDomain,
+        });
+        const dsParsed = JSON.parse(dsBody);
+        await scanMetadata({
+            baseUrl: token.baseUrl,
+            accessToken: token.accessToken,
+            id: options.dsId,
+            dsType: dsParsed.type ?? "mysql",
+            businessDomain: options.businessDomain,
+        });
+    }
+    catch (err) {
+        console.error(`Scan warning (continuing): ${String(err)}`);
+    }
+    // Phase 2: Create KN from datasource
+    console.error("Phase 2: Creating knowledge network ...");
+    const tableNames = options.tables.length > 0 ? options.tables : importResult.tables;
+    if (tableNames.length === 0) {
+        console.error("No tables available for KN creation — aborting");
+        return 1;
+    }
+    const knArgs = [
+        options.dsId,
+        "--name", options.name,
+        "--tables", tableNames.join(","),
+        options.build ? "--build" : "--no-build",
+        "--timeout", String(options.timeout),
+        "-bd", options.businessDomain,
+    ];
+    return runKnCreateFromDsCommand(knArgs, importResult.sampleRows);
+}

package/dist/commands/dataview.d.ts

@@ -0,0 +1 @@
+export declare function runDataviewCommand(args: string[]): Promise<number>;

package/dist/commands/dataview.js

@@ -0,0 +1,244 @@
+import { createInterface } from "node:readline";
+import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/oauth.js";
+import { deleteDataView, findDataView, getDataView, listDataViews, } from "../api/dataviews.js";
+import { formatCallOutput } from "./call.js";
+import { resolveBusinessDomain } from "../config/store.js";
+function confirmYes(prompt) {
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: process.stdin, output: process.stdout });
+        rl.question(`${prompt} [y/N] `, (answer) => {
+            rl.close();
+            const trimmed = answer.trim().toLowerCase();
+            resolve(trimmed === "y" || trimmed === "yes");
+        });
+    });
+}
+export async function runDataviewCommand(args) {
+    const [subcommand, ...rest] = args;
+    if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+        console.log(`kweaver dataview
+
+Subcommands:
+  list   [--datasource-id <id>] [--type <atomic|custom>] [--limit <n>] [-bd value] [--pretty]
+  find   --name <name> [--exact] [--datasource-id <id>] [--wait] [--no-wait] [--timeout <ms>] [-bd value] [--pretty]
+  get    <id> [-bd value] [--pretty]
+  delete <id> [-y] [-bd value]
+
+  list  — list all data views (no keyword search)
+  find  — search by name; default fuzzy, --exact for strict match, --wait to poll`);
+        return 0;
+    }
+    const dispatch = () => {
+        if (subcommand === "list")
+            return runDataviewListCommand(rest);
+        if (subcommand === "find")
+            return runDataviewFindCommand(rest);
+        if (subcommand === "get")
+            return runDataviewGetCommand(rest);
+        if (subcommand === "delete")
+            return runDataviewDeleteCommand(rest);
+        return Promise.resolve(-1);
+    };
+    try {
+        return await with401RefreshRetry(async () => {
+            const code = await dispatch();
+            if (code === -1) {
+                console.error(`Unknown dataview subcommand: ${subcommand}`);
+                return 1;
+            }
+            return code;
+        });
+    }
+    catch (error) {
+        console.error(formatHttpError(error));
+        return 1;
+    }
+}
+function parseDataviewCommonArgs(args) {
+    let businessDomain = "";
+    let pretty = true;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if ((arg === "-bd" || arg === "--biz-domain") && args[i + 1]) {
+            businessDomain = args[++i];
+            continue;
+        }
+        if (arg === "--pretty") {
+            pretty = true;
+            continue;
+        }
+    }
+    if (!businessDomain)
+        businessDomain = resolveBusinessDomain();
+    return { businessDomain, pretty };
+}
+async function runDataviewListCommand(args) {
+    let datasourceId;
+    let type;
+    let limit;
+    const { businessDomain, pretty } = parseDataviewCommonArgs(args);
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "-bd" || arg === "--biz-domain") {
+            i += 1;
+            continue;
+        }
+        if (arg === "--pretty")
+            continue;
+        if (arg === "--datasource-id" && args[i + 1]) {
+            datasourceId = args[++i];
+            continue;
+        }
+        if (arg === "--type" && args[i + 1]) {
+            type = args[++i];
+            continue;
+        }
+        if (arg === "--limit" && args[i + 1]) {
+            const n = Number.parseInt(args[++i], 10);
+            if (!Number.isNaN(n))
+                limit = n;
+            continue;
+        }
+    }
+    const token = await ensureValidToken();
+    const views = await listDataViews({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        businessDomain,
+        datasourceId,
+        type,
+        limit,
+    });
+    console.log(formatCallOutput(JSON.stringify(views), pretty));
+    return 0;
+}
+async function runDataviewFindCommand(args) {
+    let datasourceId;
+    let name;
+    let exact = false;
+    let wait = false;
+    let timeoutMs = 30_000;
+    const { businessDomain, pretty } = parseDataviewCommonArgs(args);
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "-bd" || arg === "--biz-domain") {
+            i += 1;
+            continue;
+        }
+        if (arg === "--pretty")
+            continue;
+        if (arg === "--datasource-id" && args[i + 1]) {
+            datasourceId = args[++i];
+            continue;
+        }
+        if (arg === "--name" && args[i + 1]) {
+            name = args[++i];
+            continue;
+        }
+        if (arg === "--exact") {
+            exact = true;
+            continue;
+        }
+        if (arg === "--wait") {
+            wait = true;
+            continue;
+        }
+        if (arg === "--no-wait") {
+            wait = false;
+            continue;
+        }
+        if (arg === "--timeout" && args[i + 1]) {
+            timeoutMs = Number(args[++i]);
+            if (Number.isNaN(timeoutMs) || timeoutMs < 0) {
+                console.error("Invalid --timeout value");
+                return 1;
+            }
+            continue;
+        }
+    }
+    if (!name) {
+        console.error("Usage: kweaver dataview find --name <name> [--exact] [--datasource-id <id>] [--wait] [--timeout <ms>] [-bd value] [--pretty]");
+        return 1;
+    }
+    const token = await ensureValidToken();
+    const views = await findDataView({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        businessDomain,
+        name,
+        datasourceId,
+        exact,
+        wait,
+        timeoutMs,
+    });
+    console.log(formatCallOutput(JSON.stringify(views), pretty));
+    return 0;
+}
+async function runDataviewGetCommand(args) {
+    const { businessDomain, pretty } = parseDataviewCommonArgs(args);
+    let id = "";
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "-bd" || arg === "--biz-domain") {
+            i += 1;
+            continue;
+        }
+        if (arg === "--pretty")
+            continue;
+        if (!arg.startsWith("-")) {
+            id = arg;
+            break;
+        }
+    }
+    if (!id) {
+        console.error("Usage: kweaver dataview get <id> [-bd value] [--pretty]");
+        return 1;
+    }
+    const token = await ensureValidToken();
+    const view = await getDataView({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        businessDomain,
+        id,
+    });
+    console.log(formatCallOutput(JSON.stringify(view), pretty));
+    return 0;
+}
+async function runDataviewDeleteCommand(args) {
+    let id = "";
+    let yes = false;
+    let businessDomain = "";
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--yes" || arg === "-y")
+            yes = true;
+        else if ((arg === "-bd" || arg === "--biz-domain") && args[i + 1]) {
+            businessDomain = args[++i];
+            continue;
+        }
+        else if (!arg.startsWith("-"))
+            id = arg;
+    }
+    if (!businessDomain)
+        businessDomain = resolveBusinessDomain();
+    if (!id) {
+        console.error("Usage: kweaver dataview delete <id> [-y] [-bd value]");
+        return 1;
+    }
+    if (!yes) {
+        const confirmed = await confirmYes("Are you sure you want to delete this data view?");
+        if (!confirmed) {
+            console.error("Aborted.");
+            return 1;
+        }
+    }
+    const token = await ensureValidToken();
+    await deleteDataView({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        businessDomain,
+        id,
+    });
+    console.error(`Deleted ${id}`);
+    return 0;
+}

package/dist/commands/ds.d.ts

@@ -5,3 +5,19 @@ export declare function parseDsListArgs(args: string[]): {
     businessDomain: string;
     pretty: boolean;
 };
+export declare function parseImportCsvArgs(args: string[]): {
+    datasourceId: string;
+    files: string;
+    tablePrefix: string;
+    batchSize: number;
+    businessDomain: string;
+};
+export declare function resolveFiles(pattern: string): Promise<string[]>;
+export interface ImportCsvResult {
+    code: number;
+    tables: string[];
+    tableColumns: Record<string, string[]>;
+    sampleRows: Record<string, Array<Record<string, string | null>>>;
+}
+export declare function runDsImportCsv(args: string[]): Promise<ImportCsvResult>;
+export declare function runDsImportCsvCommand(args: string[]): Promise<number>;