@kweaver-ai/kweaver-sdk 0.4.11 → 0.4.12

package/README.md

@@ -90,6 +90,29 @@ const graph     = await client.bkn.querySubgraph("bkn-id", { /* path spec */ });
 await client.bkn.executeAction("bkn-id", "at-id", { /* params */ });
 const logs      = await client.bkn.listActionLogs("bkn-id");
 
+// Data sources & data views
+const dsList = await client.datasources.list();
+const tables = await client.datasources.listTables("ds-id");
+const viewId = await client.dataviews.create({ name: "v", datasourceId: "ds-id", table: "orders" });
+const views = await client.dataviews.list({ datasourceId: "ds-id" });
+const fuzzy = await client.dataviews.find("BOM", { wait: false });
+const exact = await client.dataviews.find("orders", {
+  datasourceId: "ds-id",
+  exact: true,
+  wait: true,
+});
+const dv = await client.dataviews.get(viewId);
+
+// Dataflow automation (CSV import pipeline, etc.)
+const result = await client.dataflows.execute({
+  title: "import", trigger_config: { operator: "manual" },
+  steps: [{ id: "s1", title: "load", operator: "csv_import", parameters: {} }],
+});
+
+// Vega observability
+const catalogs = await client.vega.listCatalogs();
+const health   = await client.vega.health();
+
 // Context Loader (semantic search over a BKN via MCP)
 const cl      = client.contextLoader(mcpUrl, "bkn-id");
 const results = await cl.search({ query: "hypertension treatment" });
@@ -100,14 +123,22 @@ const results = await cl.search({ query: "hypertension treatment" });
 ```
 kweaver auth login <url> [--alias name] [-u user] [-p pass] [--playwright] [--insecure|-k] — also: status, list, use, delete, logout
 kweaver token
+kweaver config show / set-bd <value>
+kweaver ds list/get/delete/tables/connect
+kweaver ds import-csv <ds_id> --files <glob> [--table-prefix <p>] [--batch-size 500]
+kweaver dataview list/find/get/delete
 kweaver bkn list/get/stats/export/create/update/delete
+kweaver bkn create-from-ds <ds_id> --name <name> [--tables t1,t2] [--build]
+kweaver bkn create-from-csv <ds_id> --files <glob> --name <name> [--build]
+kweaver bkn validate/push/pull
 kweaver bkn object-type list/get/create/update/delete/query/properties
 kweaver bkn relation-type list/get/create/update/delete
 kweaver bkn action-type list/query/execute
-kweaver bkn subgraph
+kweaver bkn subgraph / search
 kweaver bkn action-execution get
 kweaver bkn action-log list/get/cancel
-kweaver agent list/get/chat/sessions/history
+kweaver agent list/get/create/update/delete/chat/sessions/history/publish/unpublish
+kweaver vega health/stats/inspect/catalog/resource/connector-type
 kweaver context-loader config set/use/list/show
 kweaver context-loader kn-search/query-object-instance/...
 kweaver call <path> [-X METHOD] [-d BODY] [-H header]

package/README.zh.md

@@ -90,6 +90,18 @@ const graph     = await client.bkn.querySubgraph("bkn-id", { /* 路径规格 */
 await client.bkn.executeAction("bkn-id", "at-id", { /* 参数 */ });
 const logs      = await client.bkn.listActionLogs("bkn-id");
 
+// 数据源与数据视图
+const dsList = await client.datasources.list();
+const viewId = await client.dataviews.create({ name: "v", datasourceId: "ds-id", table: "orders" });
+const views = await client.dataviews.list({ datasourceId: "ds-id" });
+const fuzzy = await client.dataviews.find("BOM", { wait: false });
+const exact = await client.dataviews.find("orders", {
+  datasourceId: "ds-id",
+  exact: true,
+  wait: true,
+});
+const dv = await client.dataviews.get(viewId);
+
 // Context Loader（通过 MCP 对 BKN 做语义搜索）
 const cl      = client.contextLoader(mcpUrl, "bkn-id");
 const results = await cl.search({ query: "高血压 治疗" });
@@ -100,6 +112,8 @@ const results = await cl.search({ query: "高血压 治疗" });
 ```
 kweaver auth login <url> [--alias name] [-u user] [-p pass] [--playwright] [--insecure|-k] — 另有 status、list、use、delete、logout
 kweaver token
+kweaver ds list/get/delete/tables/connect
+kweaver dataview list/find/get/delete
 kweaver bkn list/get/stats/export/create/update/delete
 kweaver bkn object-type list/get/create/update/delete/query/properties
 kweaver bkn relation-type list/get/create/update/delete

package/dist/api/dataviews.d.ts

@@ -1,3 +1,19 @@
+/** Field metadata returned by the data-views API. */
+export interface ViewField {
+    name: string;
+    type: string;
+    display_name?: string;
+    comment?: string;
+}
+/** Normalized data view model (mdl-data-model). */
+export interface DataView {
+    id: string;
+    name: string;
+    query_type: string;
+    datasource_id: string;
+    fields: ViewField[];
+}
+export declare function parseDataView(raw: Record<string, unknown>): DataView;
 export interface CreateDataViewOptions {
     baseUrl: string;
     accessToken: string;
@@ -11,10 +27,51 @@ export interface CreateDataViewOptions {
     businessDomain?: string;
 }
 export declare function createDataView(options: CreateDataViewOptions): Promise<string>;
+export interface ListDataViewsOptions {
+    baseUrl: string;
+    accessToken: string;
+    businessDomain?: string;
+    /** Filter by data source id. */
+    datasourceId?: string;
+    /** Server-side keyword filter (fuzzy). */
+    name?: string;
+    /** View type filter (e.g. atomic, custom). */
+    type?: string;
+    /** Max items; default -1 (all). */
+    limit?: number;
+}
+export declare function listDataViews(options: ListDataViewsOptions): Promise<DataView[]>;
+export interface DeleteDataViewOptions {
+    baseUrl: string;
+    accessToken: string;
+    id: string;
+    businessDomain?: string;
+}
+export declare function deleteDataView(options: DeleteDataViewOptions): Promise<void>;
 export interface GetDataViewOptions {
     baseUrl: string;
     accessToken: string;
     id: string;
     businessDomain?: string;
 }
-export declare function getDataView(options: GetDataViewOptions): Promise<string>;
+export declare function getDataView(options: GetDataViewOptions): Promise<DataView>;
+export interface FindDataViewOptions {
+    baseUrl: string;
+    accessToken: string;
+    businessDomain?: string;
+    /** View name to search for (sent as keyword to server). */
+    name: string;
+    /** Filter by data source id. */
+    datasourceId?: string;
+    /** When true, apply client-side exact name match after keyword search (default false). */
+    exact?: boolean;
+    /** When true, poll until a result appears or timeout (default false). */
+    wait?: boolean;
+    /** Total wait budget in ms (default 30000). Only used when wait is true. */
+    timeoutMs?: number;
+}
+/**
+ * Find data views by name. Uses server-side keyword filtering; when `exact` is true,
+ * applies client-side `name ===` filter. Optional polling with exponential backoff.
+ */
+export declare function findDataView(options: FindDataViewOptions): Promise<DataView[]>;

package/dist/api/dataviews.js

@@ -24,6 +24,41 @@ function extractViewId(data) {
     }
     return null;
 }
+export function parseDataView(raw) {
+    const fieldsRaw = raw.fields;
+    const fields = [];
+    if (Array.isArray(fieldsRaw)) {
+        for (const f of fieldsRaw) {
+            if (f && typeof f === "object") {
+                const fr = f;
+                fields.push({
+                    name: String(fr.name ?? ""),
+                    type: String(fr.type ?? "varchar"),
+                    display_name: fr.display_name != null ? String(fr.display_name) : undefined,
+                    comment: fr.comment != null ? String(fr.comment) : undefined,
+                });
+            }
+        }
+    }
+    return {
+        id: String(raw.id ?? ""),
+        name: String(raw.name ?? ""),
+        query_type: String(raw.query_type ?? "SQL"),
+        datasource_id: String(raw.data_source_id ?? raw.group_id ?? ""),
+        fields,
+    };
+}
+function extractListPayload(data) {
+    if (Array.isArray(data))
+        return data;
+    if (data && typeof data === "object") {
+        const obj = data;
+        const items = obj.entries ?? obj.data;
+        if (Array.isArray(items))
+            return items;
+    }
+    return [];
+}
 export async function createDataView(options) {
     const { baseUrl, accessToken, name, datasourceId, table, fields = [], businessDomain = "bd_public", } = options;
     const viewId = createHash("md5").update(`${datasourceId}:${table}`).digest("hex").slice(0, 35);
@@ -84,26 +119,56 @@ export async function createDataView(options) {
     return createdId ?? viewId;
 }
 async function findDataViewByName(options) {
-    const base = options.baseUrl.replace(/\/+$/, "");
+    const list = await listDataViews({
+        baseUrl: options.baseUrl,
+        accessToken: options.accessToken,
+        businessDomain: options.businessDomain,
+        name: options.name,
+    });
+    const match = list.find((e) => e.name === options.name && e.datasource_id === options.groupId);
+    return match?.id ?? null;
+}
+export async function listDataViews(options) {
+    const { baseUrl, accessToken, businessDomain = "bd_public", datasourceId, name, type, limit = -1, } = options;
+    const base = baseUrl.replace(/\/+$/, "");
     const url = new URL(`${base}/api/mdl-data-model/v1/data-views`);
-    url.searchParams.set("keyword", options.name);
+    url.searchParams.set("limit", String(limit));
+    if (datasourceId)
+        url.searchParams.set("data_source_id", datasourceId);
+    if (name)
+        url.searchParams.set("keyword", name);
+    if (type)
+        url.searchParams.set("type", type);
     const response = await fetch(url.toString(), {
         method: "GET",
-        headers: buildHeaders(options.accessToken, options.businessDomain),
+        headers: buildHeaders(accessToken, businessDomain),
     });
-    if (!response.ok)
-        return null;
-    const body = JSON.parse(await response.text());
-    const match = body.entries?.find((e) => e.name === options.name && e.group_id === options.groupId);
-    return match?.id ?? null;
+    const bodyText = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, bodyText);
+    }
+    const parsed = JSON.parse(bodyText);
+    const items = extractListPayload(parsed);
+    const out = [];
+    for (const item of items) {
+        if (item && typeof item === "object") {
+            out.push(parseDataView(item));
+        }
+    }
+    return out;
 }
-async function deleteDataView(options) {
-    const base = options.baseUrl.replace(/\/+$/, "");
-    const url = `${base}/api/mdl-data-model/v1/data-views/${encodeURIComponent(options.id)}`;
-    await fetch(url, {
+export async function deleteDataView(options) {
+    const { baseUrl, accessToken, id, businessDomain = "bd_public" } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/mdl-data-model/v1/data-views/${encodeURIComponent(id)}`;
+    const response = await fetch(url, {
         method: "DELETE",
-        headers: buildHeaders(options.accessToken, options.businessDomain),
+        headers: buildHeaders(accessToken, businessDomain),
     });
+    const bodyText = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, bodyText);
+    }
 }
 export async function getDataView(options) {
     const { baseUrl, accessToken, id, businessDomain = "bd_public", } = options;
@@ -117,5 +182,40 @@ export async function getDataView(options) {
     if (!response.ok) {
         throw new HttpError(response.status, response.statusText, body);
     }
-    return body;
+    let parsed = JSON.parse(body);
+    if (Array.isArray(parsed) && parsed.length > 0) {
+        parsed = parsed[0];
+    }
+    if (!parsed || typeof parsed !== "object") {
+        throw new HttpError(500, "Invalid response", body);
+    }
+    return parseDataView(parsed);
+}
+function sleepMs(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Find data views by name. Uses server-side keyword filtering; when `exact` is true,
+ * applies client-side `name ===` filter. Optional polling with exponential backoff.
+ */
+export async function findDataView(options) {
+    const { baseUrl, accessToken, businessDomain = "bd_public", name, datasourceId, exact = false, wait = false, timeoutMs = 30_000, } = options;
+    const deadline = Date.now() + timeoutMs;
+    let attempt = 0;
+    while (true) {
+        const list = await listDataViews({
+            baseUrl,
+            accessToken,
+            businessDomain,
+            datasourceId,
+            name,
+            limit: -1,
+        });
+        const results = exact ? list.filter((v) => v.name === name) : list;
+        if (results.length > 0 || !wait || Date.now() >= deadline)
+            return results;
+        const delayMs = Math.min(5000, 1000 * 2 ** attempt);
+        attempt += 1;
+        await sleepMs(delayMs);
+    }
 }

package/dist/cli.js

@@ -6,6 +6,7 @@ import { runCallCommand } from "./commands/call.js";
 import { runConfigCommand } from "./commands/config.js";
 import { runContextLoaderCommand } from "./commands/context-loader.js";
 import { runDsCommand } from "./commands/ds.js";
+import { runDataviewCommand } from "./commands/dataview.js";
 import { runTokenCommand } from "./commands/token.js";
 import { runVegaCommand } from "./commands/vega.js";
 function printHelp() {
@@ -47,6 +48,11 @@ Usage:
   kweaver ds tables <id> [--keyword X] [--pretty]
   kweaver ds connect <db_type> <host> <port> <database> --account X --password Y [--schema S] [--name N]
 
+  kweaver dataview list [--datasource-id id] [--type atomic|custom] [--limit n] [-bd value] [--pretty]
+  kweaver dataview find --name <name> [--exact] [--datasource-id id] [--wait] [--timeout ms] [-bd value] [--pretty]
+  kweaver dataview get <id> [-bd value] [--pretty]
+  kweaver dataview delete <id> [-y] [-bd value]
+
   kweaver bkn list [options]
   kweaver bkn get <kn-id> [options]
   kweaver bkn search <kn-id> <query> [--max-concepts N] [--mode M] [--pretty] [-bd value]
@@ -90,6 +96,7 @@ Commands:
   call (curl)    Call an API with curl-style flags and auto-injected token headers
   agent          Agent CRUD, chat, sessions, history, publish/unpublish
   ds             Manage datasources (list, get, delete, tables, connect)
+  dataview       List, find, get, delete data views (atomic / custom)
   bkn            Knowledge network (CRUD, build, validate, export, stats, push/pull,
                  object-type, relation-type, subgraph, action-type, action-execution, action-log)
   config         Per-platform configuration (business domain)
@@ -120,6 +127,9 @@ export async function run(argv) {
     if (command === "ds") {
         return runDsCommand(rest);
     }
+    if (command === "dataview") {
+        return runDataviewCommand(rest);
+    }
     if (command === "token") {
         return runTokenCommand(rest);
     }

package/dist/client.d.ts

@@ -1,8 +1,12 @@
 import { AgentsResource } from "./resources/agents.js";
 import { ConversationsResource } from "./resources/conversations.js";
 import { ContextLoaderResource } from "./resources/context-loader.js";
+import { DataflowsResource } from "./resources/dataflows.js";
+import { DataSourcesResource } from "./resources/datasources.js";
+import { DataViewsResource } from "./resources/dataviews.js";
 import { KnowledgeNetworksResource } from "./resources/knowledge-networks.js";
 import { BknResource } from "./resources/bkn.js";
+import { VegaResource } from "./resources/vega.js";
 /**
  * Shared credentials passed to every resource method.
  * Internal — use KWeaverClient.
@@ -78,6 +82,14 @@ export declare class KWeaverClient implements ClientContext {
     readonly bkn: BknResource;
     /** Conversation and message history. */
     readonly conversations: ConversationsResource;
+    /** Dataflow DAG automation (create/run/poll/delete). */
+    readonly dataflows: DataflowsResource;
+    /** Data source management (connect, test, list tables). */
+    readonly datasources: DataSourcesResource;
+    /** Data view creation and retrieval. */
+    readonly dataviews: DataViewsResource;
+    /** Vega observability platform (catalogs, resources, connector types). */
+    readonly vega: VegaResource;
     constructor(opts?: KWeaverClientOptions);
     /**
      * Async factory that auto-refreshes expired or revoked tokens.

package/dist/client.js

@@ -4,8 +4,12 @@ import { ensureValidToken } from "./auth/oauth.js";
 import { AgentsResource } from "./resources/agents.js";
 import { ConversationsResource } from "./resources/conversations.js";
 import { ContextLoaderResource } from "./resources/context-loader.js";
+import { DataflowsResource } from "./resources/dataflows.js";
+import { DataSourcesResource } from "./resources/datasources.js";
+import { DataViewsResource } from "./resources/dataviews.js";
 import { KnowledgeNetworksResource } from "./resources/knowledge-networks.js";
 import { BknResource } from "./resources/bkn.js";
+import { VegaResource } from "./resources/vega.js";
 // ── KWeaverClient ─────────────────────────────────────────────────────────────
 /**
  * Main entry point for the KWeaver TypeScript SDK.
@@ -47,6 +51,14 @@ export class KWeaverClient {
     bkn;
     /** Conversation and message history. */
     conversations;
+    /** Dataflow DAG automation (create/run/poll/delete). */
+    dataflows;
+    /** Data source management (connect, test, list tables). */
+    datasources;
+    /** Data view creation and retrieval. */
+    dataviews;
+    /** Vega observability platform (catalogs, resources, connector types). */
+    vega;
     constructor(opts = {}) {
         const envDomain = process.env.KWEAVER_BUSINESS_DOMAIN;
         let baseUrl;
@@ -98,6 +110,10 @@ export class KWeaverClient {
         this.agents = new AgentsResource(this);
         this.bkn = new BknResource(this);
         this.conversations = new ConversationsResource(this);
+        this.dataflows = new DataflowsResource(this);
+        this.datasources = new DataSourcesResource(this);
+        this.dataviews = new DataViewsResource(this);
+        this.vega = new VegaResource(this);
     }
     /**
      * Async factory that auto-refreshes expired or revoked tokens.

package/dist/commands/bkn.js

@@ -9,7 +9,7 @@ import { listKnowledgeNetworks, getKnowledgeNetwork, createKnowledgeNetwork, upd
 import { objectTypeQuery, objectTypeProperties, subgraph, actionTypeQuery, actionTypeExecute, actionExecutionGet, actionLogsList, actionLogGet, actionLogCancel, } from "../api/ontology-query.js";
 import { semanticSearch } from "../api/semantic-search.js";
 import { listTablesWithColumns, scanMetadata, getDatasource } from "../api/datasources.js";
-import { createDataView } from "../api/dataviews.js"; // used by runKnCreateFromDsCommand
+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";
@@ -2195,13 +2195,21 @@ async function runKnCreateFromDsCommand(args, sampleRows) {
         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

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/index.d.ts

@@ -49,6 +49,9 @@ export type { AgentConfig, AgentInput, AgentInputField, AgentOutput, AgentLlmCon
 export { BknResource } from "./resources/bkn.js";
 export { ConversationsResource } from "./resources/conversations.js";
 export { ContextLoaderResource } from "./resources/context-loader.js";
+export type { ViewField, DataView, CreateDataViewOptions, GetDataViewOptions, ListDataViewsOptions, DeleteDataViewOptions, FindDataViewOptions, } from "./api/dataviews.js";
+export { parseDataView, createDataView, getDataView, listDataViews, deleteDataView, findDataView, } from "./api/dataviews.js";
+export { DataViewsResource } from "./resources/dataviews.js";
 export { HttpError, NetworkRequestError, fetchTextOrThrow } from "./utils/http.js";
 export type { TokenConfig, ContextLoaderEntry, ContextLoaderConfig, } from "./config/store.js";
 export { getConfigDir, getCurrentPlatform } from "./config/store.js";

package/dist/index.js

@@ -39,6 +39,8 @@ export { AgentsResource } from "./resources/agents.js";
 export { BknResource } from "./resources/bkn.js";
 export { ConversationsResource } from "./resources/conversations.js";
 export { ContextLoaderResource } from "./resources/context-loader.js";
+export { parseDataView, createDataView, getDataView, listDataViews, deleteDataView, findDataView, } from "./api/dataviews.js";
+export { DataViewsResource } from "./resources/dataviews.js";
 // ── HTTP utilities ────────────────────────────────────────────────────────────
 export { HttpError, NetworkRequestError, fetchTextOrThrow } from "./utils/http.js";
 export { getConfigDir, getCurrentPlatform } from "./config/store.js";

package/dist/resources/dataflows.d.ts

@@ -0,0 +1,17 @@
+import { type DataflowCreateBody, type DataflowResult } from "../api/dataflow.js";
+import type { ClientContext } from "../client.js";
+export declare class DataflowsResource {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    create(body: DataflowCreateBody): Promise<string>;
+    run(dagId: string): Promise<void>;
+    poll(dagId: string, opts?: {
+        interval?: number;
+        timeout?: number;
+    }): Promise<DataflowResult>;
+    delete(dagId: string): Promise<void>;
+    execute(body: DataflowCreateBody, opts?: {
+        interval?: number;
+        timeout?: number;
+    }): Promise<DataflowResult>;
+}

package/dist/resources/dataflows.js

@@ -0,0 +1,22 @@
+import { createDataflow, runDataflow, pollDataflowResults, deleteDataflow, executeDataflow, } from "../api/dataflow.js";
+export class DataflowsResource {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async create(body) {
+        return createDataflow({ ...this.ctx.base(), body });
+    }
+    async run(dagId) {
+        return runDataflow({ ...this.ctx.base(), dagId });
+    }
+    async poll(dagId, opts = {}) {
+        return pollDataflowResults({ ...this.ctx.base(), dagId, ...opts });
+    }
+    async delete(dagId) {
+        return deleteDataflow({ ...this.ctx.base(), dagId });
+    }
+    async execute(body, opts = {}) {
+        return executeDataflow({ ...this.ctx.base(), body, ...opts });
+    }
+}

package/dist/resources/datasources.d.ts

@@ -0,0 +1,52 @@
+import type { ClientContext } from "../client.js";
+export declare class DataSourcesResource {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    test(opts: {
+        type: string;
+        host: string;
+        port: number;
+        database: string;
+        account: string;
+        password: string;
+        schema?: string;
+    }): Promise<void>;
+    create(opts: {
+        name: string;
+        type: string;
+        host: string;
+        port: number;
+        database: string;
+        account: string;
+        password: string;
+        schema?: string;
+        comment?: string;
+    }): Promise<unknown>;
+    list(opts?: {
+        keyword?: string;
+        type?: string;
+    }): Promise<unknown[]>;
+    get(id: string): Promise<unknown>;
+    delete(id: string): Promise<void>;
+    listTables(id: string, opts?: {
+        keyword?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<unknown[]>;
+    listTablesWithColumns(id: string, opts?: {
+        keyword?: string;
+        limit?: number;
+        offset?: number;
+        autoScan?: boolean;
+    }): Promise<Array<{
+        name: string;
+        columns: Array<{
+            name: string;
+            type: string;
+            comment?: string;
+        }>;
+    }>>;
+    scanMetadata(id: string, opts?: {
+        dsType?: string;
+    }): Promise<string>;
+}

package/dist/resources/datasources.js

@@ -0,0 +1,54 @@
+import { testDatasource, createDatasource, listDatasources, getDatasource, deleteDatasource, listTables, listTablesWithColumns, scanMetadata, } from "../api/datasources.js";
+export class DataSourcesResource {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async test(opts) {
+        await testDatasource({ ...this.ctx.base(), ...opts });
+    }
+    async create(opts) {
+        const raw = await createDatasource({ ...this.ctx.base(), ...opts });
+        return JSON.parse(raw);
+    }
+    async list(opts = {}) {
+        const raw = await listDatasources({ ...this.ctx.base(), ...opts });
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed))
+            return parsed;
+        if (parsed && typeof parsed === "object") {
+            const obj = parsed;
+            const items = obj.entries ?? obj.data ?? obj.records;
+            if (Array.isArray(items))
+                return items;
+        }
+        return [];
+    }
+    async get(id) {
+        const raw = await getDatasource({ ...this.ctx.base(), id });
+        return JSON.parse(raw);
+    }
+    async delete(id) {
+        await deleteDatasource({ ...this.ctx.base(), id });
+    }
+    async listTables(id, opts = {}) {
+        const raw = await listTables({ ...this.ctx.base(), id, ...opts });
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed))
+            return parsed;
+        if (parsed && typeof parsed === "object") {
+            const obj = parsed;
+            const items = obj.entries ?? obj.data;
+            if (Array.isArray(items))
+                return items;
+        }
+        return [];
+    }
+    async listTablesWithColumns(id, opts = {}) {
+        const raw = await listTablesWithColumns({ ...this.ctx.base(), id, ...opts });
+        return JSON.parse(raw);
+    }
+    async scanMetadata(id, opts = {}) {
+        return scanMetadata({ ...this.ctx.base(), id, ...opts });
+    }
+}

package/dist/resources/dataviews.d.ts

@@ -0,0 +1,28 @@
+import type { DataView } from "../api/dataviews.js";
+import type { ClientContext } from "../client.js";
+export declare class DataViewsResource {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    create(opts: {
+        name: string;
+        datasourceId: string;
+        table: string;
+        fields?: Array<{
+            name: string;
+            type: string;
+        }>;
+    }): Promise<string>;
+    get(id: string): Promise<DataView>;
+    list(opts?: {
+        datasourceId?: string;
+        type?: string;
+        limit?: number;
+    }): Promise<DataView[]>;
+    find(name: string, opts?: {
+        datasourceId?: string;
+        exact?: boolean;
+        wait?: boolean;
+        timeoutMs?: number;
+    }): Promise<DataView[]>;
+    delete(id: string): Promise<void>;
+}

package/dist/resources/dataviews.js

@@ -0,0 +1,34 @@
+import { createDataView, deleteDataView, findDataView, getDataView, listDataViews, } from "../api/dataviews.js";
+export class DataViewsResource {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async create(opts) {
+        return createDataView({ ...this.ctx.base(), ...opts });
+    }
+    async get(id) {
+        return getDataView({ ...this.ctx.base(), id });
+    }
+    async list(opts = {}) {
+        return listDataViews({
+            ...this.ctx.base(),
+            datasourceId: opts.datasourceId,
+            type: opts.type,
+            limit: opts.limit,
+        });
+    }
+    async find(name, opts) {
+        return findDataView({
+            ...this.ctx.base(),
+            name,
+            datasourceId: opts?.datasourceId,
+            exact: opts?.exact,
+            wait: opts?.wait,
+            timeoutMs: opts?.timeoutMs,
+        });
+    }
+    async delete(id) {
+        await deleteDataView({ ...this.ctx.base(), id });
+    }
+}

package/dist/resources/vega.d.ts

@@ -0,0 +1,41 @@
+import type { ClientContext } from "../client.js";
+export declare class VegaResource {
+    private readonly ctx;
+    constructor(ctx: ClientContext);
+    health(): Promise<unknown>;
+    listCatalogs(opts?: {
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<unknown[]>;
+    getCatalog(id: string): Promise<unknown>;
+    catalogHealthStatus(ids: string): Promise<unknown>;
+    testCatalogConnection(id: string): Promise<unknown>;
+    discoverCatalog(id: string, opts?: {
+        wait?: boolean;
+    }): Promise<unknown>;
+    listCatalogResources(id: string, opts?: {
+        category?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<unknown[]>;
+    listResources(opts?: {
+        catalogId?: string;
+        category?: string;
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<unknown[]>;
+    getResource(id: string): Promise<unknown>;
+    queryResourceData(id: string, body: string): Promise<unknown>;
+    previewResource(id: string, opts?: {
+        limit?: number;
+    }): Promise<unknown>;
+    listConnectorTypes(): Promise<unknown[]>;
+    getConnectorType(type: string): Promise<unknown>;
+    listDiscoverTasks(opts?: {
+        status?: string;
+        limit?: number;
+        offset?: number;
+    }): Promise<unknown[]>;
+}

package/dist/resources/vega.js

@@ -0,0 +1,80 @@
+import { vegaHealth, listVegaCatalogs, getVegaCatalog, vegaCatalogHealthStatus, testVegaCatalogConnection, discoverVegaCatalog, listVegaCatalogResources, listVegaResources, getVegaResource, queryVegaResourceData, previewVegaResource, listVegaConnectorTypes, getVegaConnectorType, listVegaDiscoverTasks, } from "../api/vega.js";
+function unwrapArray(raw) {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed))
+        return parsed;
+    if (parsed && typeof parsed === "object") {
+        const obj = parsed;
+        const items = obj.entries ?? obj.data ?? obj.records;
+        if (Array.isArray(items))
+            return items;
+    }
+    return [];
+}
+export class VegaResource {
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    // ── Health ──────────────────────────────────────────────────────────────────
+    async health() {
+        const raw = await vegaHealth(this.ctx.base());
+        return JSON.parse(raw);
+    }
+    // ── Catalogs ────────────────────────────────────────────────────────────────
+    async listCatalogs(opts = {}) {
+        const raw = await listVegaCatalogs({ ...this.ctx.base(), ...opts });
+        return unwrapArray(raw);
+    }
+    async getCatalog(id) {
+        const raw = await getVegaCatalog({ ...this.ctx.base(), id });
+        return JSON.parse(raw);
+    }
+    async catalogHealthStatus(ids) {
+        const raw = await vegaCatalogHealthStatus({ ...this.ctx.base(), ids });
+        return JSON.parse(raw);
+    }
+    async testCatalogConnection(id) {
+        const raw = await testVegaCatalogConnection({ ...this.ctx.base(), id });
+        return JSON.parse(raw);
+    }
+    async discoverCatalog(id, opts = {}) {
+        const raw = await discoverVegaCatalog({ ...this.ctx.base(), id, ...opts });
+        return JSON.parse(raw);
+    }
+    async listCatalogResources(id, opts = {}) {
+        const raw = await listVegaCatalogResources({ ...this.ctx.base(), id, ...opts });
+        return unwrapArray(raw);
+    }
+    // ── Resources ───────────────────────────────────────────────────────────────
+    async listResources(opts = {}) {
+        const raw = await listVegaResources({ ...this.ctx.base(), ...opts });
+        return unwrapArray(raw);
+    }
+    async getResource(id) {
+        const raw = await getVegaResource({ ...this.ctx.base(), id });
+        return JSON.parse(raw);
+    }
+    async queryResourceData(id, body) {
+        const raw = await queryVegaResourceData({ ...this.ctx.base(), id, body });
+        return JSON.parse(raw);
+    }
+    async previewResource(id, opts = {}) {
+        const raw = await previewVegaResource({ ...this.ctx.base(), id, ...opts });
+        return JSON.parse(raw);
+    }
+    // ── Connector Types ─────────────────────────────────────────────────────────
+    async listConnectorTypes() {
+        const raw = await listVegaConnectorTypes(this.ctx.base());
+        return unwrapArray(raw);
+    }
+    async getConnectorType(type) {
+        const raw = await getVegaConnectorType({ ...this.ctx.base(), type });
+        return JSON.parse(raw);
+    }
+    // ── Discover Tasks ──────────────────────────────────────────────────────────
+    async listDiscoverTasks(opts = {}) {
+        const raw = await listVegaDiscoverTasks({ ...this.ctx.base(), ...opts });
+        return unwrapArray(raw);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kweaver-ai/kweaver-sdk",
-  "version": "0.4.11",
+  "version": "0.4.12",
   "description": "KWeaver TypeScript SDK — CLI tool and programmatic API for knowledge networks and Decision Agents.",
   "type": "module",
   "main": "./dist/index.js",