@kweaver-ai/kweaver-sdk 0.4.0 → 0.4.1

package/dist/api/dataviews.js

@@ -0,0 +1,72 @@
+import { createHash } from "node:crypto";
+import { HttpError } from "../utils/http.js";
+function buildHeaders(accessToken, businessDomain) {
+    return {
+        accept: "application/json, text/plain, */*",
+        "accept-language": "zh-cn",
+        authorization: `Bearer ${accessToken}`,
+        token: accessToken,
+        "x-business-domain": businessDomain,
+        "x-language": "zh-cn",
+    };
+}
+function extractViewId(data) {
+    if (Array.isArray(data) && data.length > 0) {
+        const item = data[0];
+        if (typeof item === "string")
+            return item;
+        if (item && typeof item === "object" && "id" in item) {
+            return String(item.id ?? "");
+        }
+    }
+    if (data && typeof data === "object" && "id" in data) {
+        return String(data.id ?? "");
+    }
+    return null;
+}
+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);
+    const body = JSON.stringify([
+        {
+            id: viewId,
+            name,
+            technical_name: table,
+            type: "atomic",
+            query_type: "SQL",
+            data_source_id: datasourceId,
+            group_id: datasourceId,
+            fields,
+        },
+    ]);
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/mdl-data-model/v1/data-views`;
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    const createdId = extractViewId(JSON.parse(responseBody));
+    return createdId ?? viewId;
+}
+export async function getDataView(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: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}

package/dist/api/knowledge-networks.d.ts

@@ -55,3 +55,87 @@ export interface ListSchemaTypesOptions {
 export declare function listObjectTypes(options: ListSchemaTypesOptions): Promise<string>;
 export declare function listRelationTypes(options: ListSchemaTypesOptions): Promise<string>;
 export declare function listActionTypes(options: ListSchemaTypesOptions): Promise<string>;
+export interface GetObjectTypeOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    otId: string;
+    businessDomain?: string;
+    branch?: string;
+}
+export declare function getObjectType(options: GetObjectTypeOptions): Promise<string>;
+export interface CreateObjectTypesOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    body: string;
+    businessDomain?: string;
+    branch?: string;
+}
+export declare function createObjectTypes(options: CreateObjectTypesOptions): Promise<string>;
+export interface UpdateObjectTypeOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    otId: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function updateObjectType(options: UpdateObjectTypeOptions): Promise<string>;
+export interface DeleteObjectTypesOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    otIds: string;
+    businessDomain?: string;
+}
+export declare function deleteObjectTypes(options: DeleteObjectTypesOptions): Promise<void>;
+export interface GetRelationTypeOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    rtId: string;
+    businessDomain?: string;
+    branch?: string;
+}
+export declare function getRelationType(options: GetRelationTypeOptions): Promise<string>;
+export interface CreateRelationTypesOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    body: string;
+    businessDomain?: string;
+    branch?: string;
+}
+export declare function createRelationTypes(options: CreateRelationTypesOptions): Promise<string>;
+export interface UpdateRelationTypeOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    rtId: string;
+    body: string;
+    businessDomain?: string;
+}
+export declare function updateRelationType(options: UpdateRelationTypeOptions): Promise<string>;
+export interface DeleteRelationTypesOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    rtIds: string;
+    businessDomain?: string;
+}
+export declare function deleteRelationTypes(options: DeleteRelationTypesOptions): Promise<void>;
+export interface BuildKnowledgeNetworkOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    businessDomain?: string;
+}
+export declare function buildKnowledgeNetwork(options: BuildKnowledgeNetworkOptions): Promise<void>;
+export interface GetBuildStatusOptions {
+    baseUrl: string;
+    accessToken: string;
+    knId: string;
+    businessDomain?: string;
+}
+export declare function getBuildStatus(options: GetBuildStatusOptions): Promise<string>;

package/dist/api/knowledge-networks.js

@@ -156,3 +156,170 @@ export async function listActionTypes(options) {
     }
     return body;
 }
+export async function getObjectType(options) {
+    const { baseUrl, accessToken, knId, otId, businessDomain = "bd_public", branch = "main", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/object-types/${encodeURIComponent(otId)}`);
+    url.searchParams.set("branch", branch);
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}
+export async function createObjectTypes(options) {
+    const { baseUrl, accessToken, knId, body, businessDomain = "bd_public", branch = "main", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/object-types`);
+    url.searchParams.set("branch", branch);
+    const response = await fetch(url.toString(), {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function updateObjectType(options) {
+    const { baseUrl, accessToken, knId, otId, body, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/object-types/${encodeURIComponent(otId)}`;
+    const response = await fetch(url, {
+        method: "PUT",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function deleteObjectTypes(options) {
+    const { baseUrl, accessToken, knId, otIds, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/object-types/${encodeURIComponent(otIds)}`;
+    const response = await fetch(url, {
+        method: "DELETE",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new HttpError(response.status, response.statusText, body);
+    }
+}
+export async function getRelationType(options) {
+    const { baseUrl, accessToken, knId, rtId, businessDomain = "bd_public", branch = "main", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/relation-types/${encodeURIComponent(rtId)}`);
+    url.searchParams.set("branch", branch);
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}
+export async function createRelationTypes(options) {
+    const { baseUrl, accessToken, knId, body, businessDomain = "bd_public", branch = "main", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/relation-types`);
+    url.searchParams.set("branch", branch);
+    const response = await fetch(url.toString(), {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function updateRelationType(options) {
+    const { baseUrl, accessToken, knId, rtId, body, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/relation-types/${encodeURIComponent(rtId)}`;
+    const response = await fetch(url, {
+        method: "PUT",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body,
+    });
+    const responseBody = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+    return responseBody;
+}
+export async function deleteRelationTypes(options) {
+    const { baseUrl, accessToken, knId, rtIds, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/relation-types/${encodeURIComponent(rtIds)}`;
+    const response = await fetch(url, {
+        method: "DELETE",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    if (!response.ok) {
+        const body = await response.text();
+        throw new HttpError(response.status, response.statusText, body);
+    }
+}
+export async function buildKnowledgeNetwork(options) {
+    const { baseUrl, accessToken, knId, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = `${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/jobs`;
+    const body = JSON.stringify({
+        name: `sdk_build_${knId.slice(0, 8)}`,
+        job_type: "full",
+    });
+    const response = await fetch(url, {
+        method: "POST",
+        headers: {
+            ...buildHeaders(accessToken, businessDomain),
+            "content-type": "application/json",
+        },
+        body,
+    });
+    if (!response.ok) {
+        const responseBody = await response.text();
+        throw new HttpError(response.status, response.statusText, responseBody);
+    }
+}
+export async function getBuildStatus(options) {
+    const { baseUrl, accessToken, knId, businessDomain = "bd_public", } = options;
+    const base = baseUrl.replace(/\/+$/, "");
+    const url = new URL(`${base}/api/ontology-manager/v1/knowledge-networks/${encodeURIComponent(knId)}/jobs`);
+    url.searchParams.set("limit", "1");
+    url.searchParams.set("direction", "desc");
+    const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: buildHeaders(accessToken, businessDomain),
+    });
+    const body = await response.text();
+    if (!response.ok) {
+        throw new HttpError(response.status, response.statusText, body);
+    }
+    return body;
+}

package/dist/cli.js

@@ -3,6 +3,7 @@ import { runAuthCommand } from "./commands/auth.js";
 import { runKnCommand } from "./commands/bkn.js";
 import { runCallCommand } from "./commands/call.js";
 import { runContextLoaderCommand } from "./commands/context-loader.js";
+import { runDsCommand } from "./commands/ds.js";
 import { runTokenCommand } from "./commands/token.js";
 function printHelp() {
     console.log(`kweaver
@@ -20,6 +21,10 @@ Usage:
   kweaver call <url> [-X METHOD] [-H "Name: value"] [-d BODY] [--pretty] [--verbose] [-bd value]
   kweaver agent chat <agent_id> [-m "message"] [--version value] [--conversation-id id] [--stream] [--no-stream] [--verbose] [-bd value]
   kweaver agent list [options]
+  kweaver agent get <agent_id> [options]
+  kweaver ds list [options]
+  kweaver ds get <id>
+  kweaver ds connect <db_type> <host> <port> <database> --account X --password Y
   kweaver bkn list [options]
   kweaver bkn get <kn-id> [options]
   kweaver bkn search <kn-id> <query> [options]
@@ -33,6 +38,7 @@ Commands:
   auth           Login, list, inspect, and switch saved platform auth profiles
   token          Print the current access token, refreshing it first if needed
   call           Call an API with curl-style flags and auto-injected token headers
+  ds             Manage datasources (list, get, delete, tables, connect)
   agent          Chat with a KWeaver agent (agent chat <id>), list published agents (agent list)
   bkn           Business knowledge network (list/get/create/update/delete/export/stats; object-type, subgraph, action-type, action-log)
   context-loader Call context-loader MCP (tools, resources, prompts; kn-search, query-*, etc.)
@@ -50,6 +56,9 @@ export async function run(argv) {
     if (command === "call" || command === "curl") {
         return runCallCommand(rest);
     }
+    if (command === "ds") {
+        return runDsCommand(rest);
+    }
     if (command === "token") {
         return runTokenCommand(rest);
     }

package/dist/commands/agent.d.ts

@@ -26,3 +26,10 @@ export interface AgentHistoryOptions {
 }
 export declare function parseAgentHistoryArgs(args: string[]): AgentHistoryOptions;
 export declare function runAgentCommand(args: string[]): Promise<number>;
+export interface AgentGetOptions {
+    agentId: string;
+    businessDomain: string;
+    pretty: boolean;
+    verbose: boolean;
+}
+export declare function parseAgentGetArgs(args: string[]): AgentGetOptions;

package/dist/commands/agent.js

@@ -1,6 +1,6 @@
 import { ensureValidToken, formatHttpError } from "../auth/oauth.js";
 import { runAgentChatCommand } from "./agent-chat.js";
-import { listAgents } from "../api/agent-list.js";
+import { listAgents, getAgent } from "../api/agent-list.js";
 import { listConversations, listMessages } from "../api/conversations.js";
 import { formatCallOutput } from "./call.js";
 function readStringField(value, ...keys) {
@@ -222,6 +222,7 @@ Subcommands:
        [--verbose]                   Print request details to stderr
        [-bd|--biz-domain value]      Override x-business-domain (default: bd_public)
   list [options]                    List published agents
+  get <agent_id> [--verbose]         Get agent details
   sessions <agent_id>                List all conversations for an agent
        [--limit n] [-bd domain] [--pretty]
   history <conversation_id>          Show message history for a conversation
@@ -255,6 +256,20 @@ Options:
         }
         return runAgentChatCommand(rest);
     }
+    if (subcommand === "get") {
+        if (rest.length === 1 && (rest[0] === "--help" || rest[0] === "-h")) {
+            console.log(`kweaver agent get <agent_id> [options]
+
+Get agent details from the agent-factory API.
+
+Options:
+  --verbose, -v             Show full JSON response
+  -bd, --biz-domain <value>  Business domain (default: bd_public)
+  --pretty                   Pretty-print JSON output (default)`);
+            return Promise.resolve(0);
+        }
+        return runAgentGetCommand(rest);
+    }
     if (subcommand === "list") {
         if (rest.length === 1 && (rest[0] === "--help" || rest[0] === "-h")) {
             console.log(`kweaver agent list [options]
@@ -306,6 +321,92 @@ Options:
     console.error(`Unknown agent subcommand: ${subcommand}`);
     return Promise.resolve(1);
 }
+export function parseAgentGetArgs(args) {
+    const agentId = args[0];
+    if (!agentId || agentId.startsWith("-")) {
+        throw new Error("Missing agent_id. Usage: kweaver agent get <agent_id> [options]");
+    }
+    let businessDomain = "bd_public";
+    let pretty = true;
+    let verbose = false;
+    for (let i = 1; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h") {
+            throw new Error("help");
+        }
+        if (arg === "-bd" || arg === "--biz-domain") {
+            businessDomain = args[i + 1] ?? "bd_public";
+            if (!businessDomain || businessDomain.startsWith("-")) {
+                throw new Error("Missing value for biz-domain flag");
+            }
+            i += 1;
+            continue;
+        }
+        if (arg === "--pretty") {
+            pretty = true;
+            continue;
+        }
+        if (arg === "--verbose" || arg === "-v") {
+            verbose = true;
+            continue;
+        }
+        throw new Error(`Unsupported agent get argument: ${arg}`);
+    }
+    return { agentId, businessDomain, pretty, verbose };
+}
+function formatSimpleAgentGet(text, pretty) {
+    const parsed = JSON.parse(text);
+    const config = parsed.config ?? {};
+    const ds = config.data_source ?? {};
+    const kg = ds.kg ?? [];
+    const knIds = parsed.kn_ids ?? kg.map((k) => String(k.kg_id ?? "")).filter(Boolean);
+    const simplified = {
+        id: parsed.id,
+        name: parsed.name,
+        description: parsed.profile ?? parsed.description ?? "",
+        status: parsed.status,
+        kn_ids: knIds,
+    };
+    return JSON.stringify(simplified, null, pretty ? 2 : 0);
+}
+async function runAgentGetCommand(args) {
+    let options;
+    try {
+        options = parseAgentGetArgs(args);
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "help") {
+            console.log(`kweaver agent get <agent_id> [options]
+
+Get agent details from the agent-factory API.
+
+Options:
+  --verbose, -v             Show full JSON response
+  -bd, --biz-domain <value>  Business domain (default: bd_public)
+  --pretty                   Pretty-print JSON output (default)`);
+            return 0;
+        }
+        console.error(formatHttpError(error));
+        return 1;
+    }
+    try {
+        const token = await ensureValidToken();
+        const body = await getAgent({
+            baseUrl: token.baseUrl,
+            accessToken: token.accessToken,
+            agentId: options.agentId,
+            businessDomain: options.businessDomain,
+        });
+        if (body) {
+            console.log(options.verbose ? formatCallOutput(body, options.pretty) : formatSimpleAgentGet(body, options.pretty));
+        }
+        return 0;
+    }
+    catch (error) {
+        console.error(formatHttpError(error));
+        return 1;
+    }
+}
 async function runAgentListCommand(args) {
     let options;
     try {

package/dist/commands/bkn.d.ts

@@ -60,6 +60,12 @@ export interface KnActionTypeExecuteOptions {
     timeout: number;
 }
 export declare function parseKnActionTypeExecuteArgs(args: string[]): KnActionTypeExecuteOptions;
+export declare function parseKnBuildArgs(args: string[]): {
+    knId: string;
+    wait: boolean;
+    timeout: number;
+    businessDomain: string;
+};
 export declare function parseKnSearchArgs(args: string[]): {
     knId: string;
     query: string;