@kweaver-ai/kweaver-sdk 0.4.11 → 0.4.13

package/dist/commands/dataview.js

@@ -0,0 +1,303 @@
+import { createInterface } from "node:readline";
+import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/oauth.js";
+import { deleteDataView, findDataView, getDataView, listDataViews, queryDataView, } 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]
+  query  <id> [--sql <sql>] [--limit <n>] [--offset <n>] [--need-total] [-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
+  query — run SQL query against a data view (mdl-uniquery); omit --sql to use view default SQL`);
+        return 0;
+    }
+    const dispatch = () => {
+        if (subcommand === "list")
+            return runDataviewListCommand(rest);
+        if (subcommand === "find")
+            return runDataviewFindCommand(rest);
+        if (subcommand === "get")
+            return runDataviewGetCommand(rest);
+        if (subcommand === "query")
+            return runDataviewQueryCommand(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 runDataviewQueryCommand(args) {
+    const { businessDomain, pretty } = parseDataviewCommonArgs(args);
+    let sql;
+    let limit = 50;
+    let offset = 0;
+    let needTotal = false;
+    if (args.length === 0 || args[0].startsWith("-")) {
+        console.error("Usage: kweaver dataview query <id> [--sql <sql>] [--limit <n>] [--offset <n>] [--need-total] [-bd value] [--pretty]");
+        return 1;
+    }
+    const id = args[0];
+    const tail = args.slice(1);
+    for (let i = 0; i < tail.length; i += 1) {
+        const arg = tail[i];
+        if (arg === "-bd" || arg === "--biz-domain") {
+            i += 1;
+            continue;
+        }
+        if (arg === "--pretty")
+            continue;
+        if ((arg === "--sql" || arg === "-s") && tail[i + 1]) {
+            sql = tail[++i];
+            continue;
+        }
+        if (arg === "--limit" && tail[i + 1]) {
+            const n = Number.parseInt(tail[++i], 10);
+            if (!Number.isNaN(n))
+                limit = n;
+            continue;
+        }
+        if (arg === "--offset" && tail[i + 1]) {
+            const n = Number.parseInt(tail[++i], 10);
+            if (!Number.isNaN(n))
+                offset = n;
+            continue;
+        }
+        if (arg === "--need-total") {
+            needTotal = true;
+            continue;
+        }
+    }
+    const token = await ensureValidToken();
+    const result = await queryDataView({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        businessDomain,
+        id,
+        sql,
+        offset,
+        limit,
+        needTotal,
+    });
+    console.log(formatCallOutput(JSON.stringify(result), 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/vega.js

@@ -219,14 +219,14 @@ async function runCatalogList(args) {
 
 Options:
   --status <s>    Filter by status
-  --limit <n>     Max results
+  --limit <n>     Max results (default: 30)
   --offset <n>    Offset
   -bd, --biz-domain  Business domain (default: bd_public)
   --pretty         Pretty-print JSON (default)`);
         return 0;
     }
     let status;
-    let limit;
+    let limit = 30;
     let offset;
     const { remaining, businessDomain, pretty } = parseCommonFlags(args);
     for (let i = 0; i < remaining.length; i += 1) {
@@ -383,11 +383,11 @@ async function runCatalogResources(args) {
 
 Options:
   --category <s>   Filter by category
-  --limit <n>      Max results`);
+  --limit <n>      Max results (default: 30)`);
         return 0;
     }
     let category;
-    let limit;
+    let limit = 30;
     const { remaining, businessDomain, pretty } = parseCommonFlags(args);
     const positionals = [];
     for (let i = 0; i < remaining.length; i += 1) {
@@ -458,7 +458,7 @@ Options:
   --catalog-id <s>  Filter by catalog
   --category <s>    Filter by category
   --status <s>      Filter by status
-  --limit <n>       Max results
+  --limit <n>       Max results (default: 30)
   --offset <n>      Offset
   -bd, --biz-domain  Business domain (default: bd_public)
   --pretty           Pretty-print JSON (default)`);
@@ -467,7 +467,7 @@ Options:
     let catalogId;
     let category;
     let status;
-    let limit;
+    let limit = 30;
     let offset;
     const { remaining, businessDomain, pretty } = parseCommonFlags(args);
     for (let i = 0; i < remaining.length; i += 1) {
@@ -579,7 +579,7 @@ async function runResourcePreview(args) {
         console.log(`kweaver vega resource preview <id> [--limit N]
 
 Options:
-  --limit <n>   Number of rows to preview (default: 10)`);
+  --limit <n>   Number of rows to preview (default: 50)`);
         return 0;
     }
     let limit;

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, QueryDataViewOptions, DataViewQueryResult, } from "./api/dataviews.js";
+export { parseDataView, createDataView, getDataView, listDataViews, deleteDataView, findDataView, queryDataView, } 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, queryDataView, } 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,37 @@
+import type { DataView, DataViewQueryResult } 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>;
+    query(id: string, opts?: {
+        sql?: string;
+        offset?: number;
+        limit?: number;
+        needTotal?: boolean;
+        outputFields?: string[];
+        filters?: Record<string, unknown>;
+        sort?: Array<Record<string, unknown>>;
+    }): Promise<DataViewQueryResult>;
+}

package/dist/resources/dataviews.js

@@ -0,0 +1,47 @@
+import { createDataView, deleteDataView, findDataView, getDataView, listDataViews, queryDataView, } 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 });
+    }
+    async query(id, opts) {
+        return queryDataView({
+            ...this.ctx.base(),
+            id,
+            sql: opts?.sql,
+            offset: opts?.offset,
+            limit: opts?.limit,
+            needTotal: opts?.needTotal,
+            outputFields: opts?.outputFields,
+            filters: opts?.filters,
+            sort: opts?.sort,
+        });
+    }
+}

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[]>;
+}