@kweaver-ai/kweaver-sdk 0.4.0 → 0.4.2

package/dist/commands/call.js

@@ -42,7 +42,7 @@ export function parseCallArgs(args) {
             pretty = true;
             continue;
         }
-        if (arg === "--verbose") {
+        if (arg === "-v" || arg === "--verbose") {
             verbose = true;
             continue;
         }
@@ -113,6 +113,21 @@ export function formatVerboseRequest(invocation) {
     return lines;
 }
 export async function runCallCommand(args) {
+    if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
+        console.log(`kweaver call <url> [-X METHOD] [-H "Name: value"] [-d BODY] [--pretty] [--verbose] [-bd value]
+
+Call an API with curl-style flags and auto-injected token headers.
+
+Options:
+  <url>              API path (e.g. /api/ontology-manager/v1/knowledge-networks)
+  -X, --request      HTTP method (default: GET)
+  -H, --header       Extra header (repeatable)
+  -d, --data         JSON request body
+  -bd, --biz-domain  Override x-business-domain (default: bd_public)
+  -v, --verbose      Print request info to stderr
+  --pretty           Pretty-print JSON output (default)`);
+        return 0;
+    }
     let invocation;
     try {
         invocation = parseCallArgs(args);
@@ -123,6 +138,10 @@ export async function runCallCommand(args) {
     }
     try {
         const token = await ensureValidToken();
+        // Prepend baseUrl when the URL is a relative path (no scheme)
+        if (invocation.url.startsWith("/")) {
+            invocation.url = token.baseUrl.replace(/\/+$/, "") + invocation.url;
+        }
         injectAuthHeaders(invocation.headers, token.accessToken, invocation.businessDomain);
         if (invocation.verbose) {
             for (const line of formatVerboseRequest(invocation)) {

package/dist/commands/context-loader.js

@@ -340,7 +340,7 @@ function parseJsonArg(args) {
 async function runQueryObjectInstance(options, args, pretty) {
     const body = parseJsonArg(args);
     if (!body.ot_id || !body.condition) {
-        console.error("JSON must include ot_id and condition. See ref/contextloader/examples.md");
+        console.error("JSON must include ot_id and condition. See references/json-formats.md#context-loader");
         return 1;
     }
     const result = await queryObjectInstance(options, {
@@ -354,7 +354,7 @@ async function runQueryObjectInstance(options, args, pretty) {
 async function runQueryInstanceSubgraph(options, args, pretty) {
     const body = parseJsonArg(args);
     if (!Array.isArray(body.relation_type_paths)) {
-        console.error("JSON must include relation_type_paths array. See ref/contextloader/examples.md");
+        console.error("JSON must include relation_type_paths array. See references/json-formats.md#context-loader");
         return 1;
     }
     const result = await queryInstanceSubgraph(options, body);
@@ -364,7 +364,7 @@ async function runQueryInstanceSubgraph(options, args, pretty) {
 async function runGetLogicProperties(options, args, pretty) {
     const body = parseJsonArg(args);
     if (!body.ot_id || !body.query || !body._instance_identities || !body.properties) {
-        console.error("JSON must include ot_id, query, _instance_identities, properties. See ref/contextloader/examples.md");
+        console.error("JSON must include ot_id, query, _instance_identities, properties. See references/json-formats.md#context-loader");
         return 1;
     }
     const result = await getLogicPropertiesValues(options, body);
@@ -374,7 +374,7 @@ async function runGetLogicProperties(options, args, pretty) {
 async function runGetActionInfo(options, args, pretty) {
     const body = parseJsonArg(args);
     if (!body.at_id || !body._instance_identity) {
-        console.error("JSON must include at_id and _instance_identity. See ref/contextloader/examples.md");
+        console.error("JSON must include at_id and _instance_identity. See references/json-formats.md#context-loader");
         return 1;
     }
     const result = await getActionInfo(options, body);

package/dist/commands/ds.d.ts

@@ -0,0 +1,7 @@
+export declare function runDsCommand(args: string[]): Promise<number>;
+export declare function parseDsListArgs(args: string[]): {
+    keyword?: string;
+    type?: string;
+    businessDomain: string;
+    pretty: boolean;
+};

package/dist/commands/ds.js

@@ -0,0 +1,283 @@
+import { createInterface } from "node:readline";
+import { ensureValidToken, formatHttpError } from "../auth/oauth.js";
+import { testDatasource, createDatasource, listDatasources, getDatasource, deleteDatasource, listTablesWithColumns, } from "../api/datasources.js";
+import { formatCallOutput } from "./call.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");
+        });
+    });
+}
+function extractDatasourceId(body) {
+    const parsed = JSON.parse(body);
+    const item = Array.isArray(parsed) ? parsed[0] : parsed;
+    if (!item || typeof item !== "object")
+        return "";
+    const id = item.id ?? item.ds_id;
+    return id != null ? String(id) : "";
+}
+export async function runDsCommand(args) {
+    const [subcommand, ...rest] = args;
+    if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+        console.log(`kweaver ds
+
+Subcommands:
+  list [--keyword X] [--type Y]     List datasources
+  get <id>                          Get datasource details
+  delete <id> [-y]                  Delete a datasource
+  tables <id> [--keyword X]         List tables with columns
+  connect <db_type> <host> <port> <database> --account X --password Y [--schema Z] [--name N]
+    Test connectivity, register datasource, and discover tables.`);
+        return 0;
+    }
+    try {
+        if (subcommand === "list") {
+            return runDsListCommand(rest);
+        }
+        if (subcommand === "get") {
+            return runDsGetCommand(rest);
+        }
+        if (subcommand === "delete") {
+            return runDsDeleteCommand(rest);
+        }
+        if (subcommand === "tables") {
+            return runDsTablesCommand(rest);
+        }
+        if (subcommand === "connect") {
+            return runDsConnectCommand(rest);
+        }
+        console.error(`Unknown ds subcommand: ${subcommand}`);
+        return 1;
+    }
+    catch (error) {
+        console.error(formatHttpError(error));
+        return 1;
+    }
+}
+export function parseDsListArgs(args) {
+    let keyword;
+    let type;
+    let businessDomain = "bd_public";
+    let pretty = true;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--help" || arg === "-h")
+            throw new Error("help");
+        if (arg === "--keyword" && args[i + 1]) {
+            keyword = args[++i];
+            continue;
+        }
+        if (arg === "--type" && args[i + 1]) {
+            type = args[++i];
+            continue;
+        }
+        if ((arg === "-bd" || arg === "--biz-domain") && args[i + 1]) {
+            businessDomain = args[++i];
+            continue;
+        }
+        if (arg === "--pretty") {
+            pretty = true;
+            continue;
+        }
+    }
+    return { keyword, type, businessDomain, pretty };
+}
+async function runDsListCommand(args) {
+    try {
+        const opts = parseDsListArgs(args);
+        const token = await ensureValidToken();
+        const body = await listDatasources({
+            baseUrl: token.baseUrl,
+            accessToken: token.accessToken,
+            keyword: opts.keyword,
+            type: opts.type,
+            businessDomain: opts.businessDomain,
+        });
+        console.log(formatCallOutput(body, opts.pretty));
+        return 0;
+    }
+    catch (error) {
+        if (error instanceof Error && error.message === "help") {
+            console.log(`kweaver ds list [options]
+
+Options:
+  --keyword <s>   Filter by keyword
+  --type <s>      Filter by database type
+  -bd, --biz-domain  Business domain (default: bd_public)
+  --pretty         Pretty-print JSON (default)`);
+            return 0;
+        }
+        throw error;
+    }
+}
+async function runDsGetCommand(args) {
+    const id = args.find((a) => !a.startsWith("-"));
+    if (!id) {
+        console.error("Usage: kweaver ds get <id>");
+        return 1;
+    }
+    const token = await ensureValidToken();
+    const body = await getDatasource({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        id,
+    });
+    console.log(formatCallOutput(body, true));
+    return 0;
+}
+async function runDsDeleteCommand(args) {
+    let id = "";
+    let yes = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--yes" || arg === "-y")
+            yes = true;
+        else if (!arg.startsWith("-"))
+            id = arg;
+    }
+    if (!id) {
+        console.error("Usage: kweaver ds delete <id> [-y]");
+        return 1;
+    }
+    if (!yes) {
+        const confirmed = await confirmYes("Are you sure you want to delete this datasource?");
+        if (!confirmed) {
+            console.error("Aborted.");
+            return 1;
+        }
+    }
+    const token = await ensureValidToken();
+    await deleteDatasource({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        id,
+    });
+    console.error(`Deleted ${id}`);
+    return 0;
+}
+async function runDsTablesCommand(args) {
+    let id = "";
+    let keyword;
+    let pretty = true;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--keyword" && args[i + 1]) {
+            keyword = args[++i];
+            continue;
+        }
+        if (arg === "--pretty") {
+            pretty = true;
+            continue;
+        }
+        if (!arg.startsWith("-"))
+            id = arg;
+    }
+    if (!id) {
+        console.error("Usage: kweaver ds tables <id> [--keyword X]");
+        return 1;
+    }
+    const token = await ensureValidToken();
+    const body = await listTablesWithColumns({
+        baseUrl: token.baseUrl,
+        accessToken: token.accessToken,
+        id,
+        keyword,
+    });
+    console.log(formatCallOutput(body, pretty));
+    return 0;
+}
+async function runDsConnectCommand(args) {
+    let dbType = "";
+    let host = "";
+    let port = 0;
+    let database = "";
+    let account = "";
+    let password = "";
+    let schema;
+    let name;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--account" && args[i + 1]) {
+            account = args[++i];
+            continue;
+        }
+        if (arg === "--password" && args[i + 1]) {
+            password = args[++i];
+            continue;
+        }
+        if (arg === "--schema" && args[i + 1]) {
+            schema = args[++i];
+            continue;
+        }
+        if (arg === "--name" && args[i + 1]) {
+            name = args[++i];
+            continue;
+        }
+        if (!arg.startsWith("-")) {
+            if (!dbType)
+                dbType = arg;
+            else if (!host)
+                host = arg;
+            else if (port === 0)
+                port = parseInt(arg, 10);
+            else if (!database)
+                database = arg;
+        }
+    }
+    if (!dbType || !host || !database || !account || !password) {
+        console.error("Usage: kweaver ds connect <db_type> <host> <port> <database> --account X --password Y [--schema Z] [--name N]");
+        return 1;
+    }
+    if (Number.isNaN(port) || port < 1) {
+        console.error("Invalid port");
+        return 1;
+    }
+    const token = await ensureValidToken();
+    const base = { baseUrl: token.baseUrl, accessToken: token.accessToken };
+    console.error("Testing connectivity ...");
+    await testDatasource({
+        ...base,
+        type: dbType,
+        host,
+        port,
+        database,
+        account,
+        password,
+        schema,
+    });
+    const dsName = name ?? database;
+    const createBody = await createDatasource({
+        ...base,
+        name: dsName,
+        type: dbType,
+        host,
+        port,
+        database,
+        account,
+        password,
+        schema,
+    });
+    const dsId = extractDatasourceId(createBody);
+    if (!dsId) {
+        console.error("Failed to get datasource ID from create response");
+        return 1;
+    }
+    const tablesBody = await listTablesWithColumns({
+        ...base,
+        id: dsId,
+    });
+    const tables = JSON.parse(tablesBody);
+    const output = {
+        datasource_id: dsId,
+        tables: tables.map((t) => ({
+            name: t.name,
+            columns: t.columns.map((c) => ({ name: c.name, type: c.type, comment: c.comment })),
+        })),
+    };
+    console.log(JSON.stringify(output, null, 2));
+    return 0;
+}

package/dist/commands/vega.d.ts

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