@kweaver-ai/kweaver-sdk 0.4.0

package/dist/commands/call.d.ts

@@ -0,0 +1,14 @@
+export interface CallInvocation {
+    url: string;
+    method: string;
+    headers: Headers;
+    body?: string;
+    pretty: boolean;
+    verbose: boolean;
+    businessDomain: string;
+}
+export declare function parseCallArgs(args: string[]): CallInvocation;
+export declare function formatCallOutput(text: string, pretty: boolean): string;
+export declare function stripSseDoneMarker(text: string, contentType?: string | null): string;
+export declare function formatVerboseRequest(invocation: CallInvocation): string[];
+export declare function runCallCommand(args: string[]): Promise<number>;

package/dist/commands/call.js

@@ -0,0 +1,151 @@
+import { ensureValidToken, formatHttpError } from "../auth/oauth.js";
+import { HttpError } from "../utils/http.js";
+export function parseCallArgs(args) {
+    const headers = new Headers();
+    let method = "GET";
+    let body;
+    let url;
+    let pretty = true;
+    let verbose = false;
+    let businessDomain = "bd_public";
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === "-X" || arg === "--request") {
+            method = (args[index + 1] ?? "").toUpperCase();
+            index += 1;
+            continue;
+        }
+        if (arg === "-H" || arg === "--header") {
+            const header = args[index + 1];
+            if (!header) {
+                throw new Error("Missing value for header flag");
+            }
+            const separatorIndex = header.indexOf(":");
+            if (separatorIndex === -1) {
+                throw new Error(`Invalid header format: ${header}`);
+            }
+            const name = header.slice(0, separatorIndex).trim();
+            const value = header.slice(separatorIndex + 1).trim();
+            headers.set(name, value);
+            index += 1;
+            continue;
+        }
+        if (arg === "-d" || arg === "--data" || arg === "--data-raw") {
+            body = args[index + 1] ?? "";
+            if (method === "GET") {
+                method = "POST";
+            }
+            index += 1;
+            continue;
+        }
+        if (arg === "--pretty") {
+            pretty = true;
+            continue;
+        }
+        if (arg === "--verbose") {
+            verbose = true;
+            continue;
+        }
+        if (arg === "-bd" || arg === "--biz-domain") {
+            businessDomain = args[index + 1] ?? "";
+            if (!businessDomain || businessDomain.startsWith("-")) {
+                throw new Error("Missing value for biz-domain flag");
+            }
+            index += 1;
+            continue;
+        }
+        if (arg === "--url") {
+            url = args[index + 1];
+            index += 1;
+            continue;
+        }
+        if (!arg.startsWith("-") && !url) {
+            url = arg;
+            continue;
+        }
+        throw new Error(`Unsupported call argument: ${arg}`);
+    }
+    if (!url) {
+        throw new Error("Missing request URL");
+    }
+    return { url, method, headers, body, pretty, verbose, businessDomain };
+}
+function injectAuthHeaders(headers, accessToken, businessDomain) {
+    if (!headers.has("authorization")) {
+        headers.set("authorization", `Bearer ${accessToken}`);
+    }
+    if (!headers.has("token")) {
+        headers.set("token", accessToken);
+    }
+    if (!headers.has("x-business-domain")) {
+        headers.set("x-business-domain", businessDomain);
+    }
+}
+export function formatCallOutput(text, pretty) {
+    if (!pretty || !text) {
+        return text;
+    }
+    try {
+        return JSON.stringify(JSON.parse(text), null, 2);
+    }
+    catch {
+        return text;
+    }
+}
+export function stripSseDoneMarker(text, contentType) {
+    if (!text || !contentType?.includes("text/event-stream")) {
+        return text;
+    }
+    const lines = text.split(/\r?\n/).filter((line) => line.trim() !== "data: [DONE]");
+    return lines.join("\n").trimEnd();
+}
+export function formatVerboseRequest(invocation) {
+    const lines = [
+        `Method: ${invocation.method}`,
+        `URL: ${invocation.url}`,
+        "Headers:",
+    ];
+    const entries = Array.from(invocation.headers.entries()).sort(([a], [b]) => a.localeCompare(b));
+    for (const [name, value] of entries) {
+        lines.push(`  ${name}: ${value}`);
+    }
+    lines.push(`Body: ${invocation.body ? "present" : "empty"}`);
+    return lines;
+}
+export async function runCallCommand(args) {
+    let invocation;
+    try {
+        invocation = parseCallArgs(args);
+    }
+    catch (error) {
+        console.error(formatHttpError(error));
+        return 1;
+    }
+    try {
+        const token = await ensureValidToken();
+        injectAuthHeaders(invocation.headers, token.accessToken, invocation.businessDomain);
+        if (invocation.verbose) {
+            for (const line of formatVerboseRequest(invocation)) {
+                console.error(line);
+            }
+        }
+        const response = await fetch(invocation.url, {
+            method: invocation.method,
+            headers: invocation.headers,
+            body: invocation.body,
+        });
+        const rawText = await response.text();
+        const text = stripSseDoneMarker(rawText, response.headers.get("content-type"));
+        if (!response.ok) {
+            throw new HttpError(response.status, response.statusText, text);
+        }
+        if (text) {
+            console.log(formatCallOutput(text, invocation.pretty));
+        }
+        return 0;
+    }
+    catch (error) {
+        console.error(formatHttpError(error));
+        return 1;
+    }
+}

package/dist/commands/context-loader.d.ts

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

package/dist/commands/context-loader.js

@@ -0,0 +1,383 @@
+import { ensureValidToken, formatHttpError } from "../auth/oauth.js";
+import { knSearch, knSchemaSearch, queryObjectInstance, queryInstanceSubgraph, getLogicPropertiesValues, getActionInfo, listTools, listResources, readResource, listResourceTemplates, listPrompts, getPrompt, } from "../api/context-loader.js";
+import { addContextLoaderEntry, getCurrentContextLoaderKn, getCurrentPlatform, loadContextLoaderConfig, removeContextLoaderEntry, setCurrentContextLoader, } from "../config/store.js";
+const MCP_NOT_CONFIGURED = "Context-loader MCP is not configured. Run: kweaver context-loader config set --kn-id <kn-id>";
+function ensureContextLoaderConfig() {
+    const platform = getCurrentPlatform();
+    if (!platform) {
+        throw new Error("No platform selected. Run: kweaver auth <platform-url>");
+    }
+    const kn = getCurrentContextLoaderKn();
+    if (!kn) {
+        throw new Error(MCP_NOT_CONFIGURED);
+    }
+    return {
+        mcpUrl: kn.mcpUrl,
+        knId: kn.knId,
+        accessToken: "", // filled by caller after ensureValidToken
+    };
+}
+function formatOutput(value, pretty) {
+    const json = JSON.stringify(value, null, pretty ? 2 : 0);
+    return json;
+}
+export async function runContextLoaderCommand(args) {
+    const [subcommand, ...rest] = args;
+    if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+        console.log(`kweaver context-loader
+
+Subcommands:
+  config set --kn-id <id> [--name n]   Add or update kn config (MCP URL derived from platform)
+  config use <name>                    Switch current config
+  config list                         List all configs and current
+  config remove <name>                 Remove a config
+  config show                         Show current config (knId + mcpUrl)
+  tools                               tools/list - list available tools
+  resources                           resources/list - list resources
+  resource <uri>                      resources/read - read resource by URI
+  templates                           resources/templates/list - list resource templates
+  prompts                             prompts/list - list prompts
+  prompt <name> [--args json]          prompts/get - get prompt by name
+  kn-search <query> [--only-schema]    Layer 1: Search schema (object_types, relation_types, action_types)
+  kn-schema-search <query> [--max N]   Layer 1: Discover candidate concepts
+  query-object-instance <json>         Layer 2: Query instances (args as JSON)
+  query-instance-subgraph <json>       Layer 2: Query subgraph (args as JSON)
+  get-logic-properties <json>          Layer 3: Get logic property values (args as JSON)
+  get-action-info <json>               Layer 3: Get action info (args as JSON)
+
+Examples:
+  kweaver context-loader config set --kn-id d5iv6c9818p72mpje8pg
+  kweaver context-loader config set --kn-id xyz123 --name project-a
+  kweaver context-loader kn-search "高血压 治疗 药品" --only-schema --pretty`);
+        return 0;
+    }
+    if (subcommand === "config") {
+        return runConfigCommand(rest);
+    }
+    const token = await ensureValidToken();
+    const base = ensureContextLoaderConfig();
+    const options = { ...base, accessToken: token.accessToken };
+    let pretty = true;
+    const prettyIdx = rest.indexOf("--pretty");
+    if (prettyIdx !== -1) {
+        pretty = true;
+        rest.splice(prettyIdx, 1);
+    }
+    try {
+        if (subcommand === "tools") {
+            return await runListTools(options, rest, pretty);
+        }
+        if (subcommand === "resources") {
+            return await runListResources(options, rest, pretty);
+        }
+        if (subcommand === "resource") {
+            return await runReadResource(options, rest, pretty);
+        }
+        if (subcommand === "templates") {
+            return await runListTemplates(options, rest, pretty);
+        }
+        if (subcommand === "prompts") {
+            return await runListPrompts(options, rest, pretty);
+        }
+        if (subcommand === "prompt") {
+            return await runGetPrompt(options, rest, pretty);
+        }
+        if (subcommand === "kn-search") {
+            return await runKnSearch(options, rest, pretty);
+        }
+        if (subcommand === "kn-schema-search") {
+            return await runKnSchemaSearch(options, rest, pretty);
+        }
+        if (subcommand === "query-object-instance") {
+            return await runQueryObjectInstance(options, rest, pretty);
+        }
+        if (subcommand === "query-instance-subgraph") {
+            return await runQueryInstanceSubgraph(options, rest, pretty);
+        }
+        if (subcommand === "get-logic-properties") {
+            return await runGetLogicProperties(options, rest, pretty);
+        }
+        if (subcommand === "get-action-info") {
+            return await runGetActionInfo(options, rest, pretty);
+        }
+    }
+    catch (error) {
+        console.error(formatHttpError(error));
+        return 1;
+    }
+    console.error(`Unknown context-loader subcommand: ${subcommand}`);
+    return 1;
+}
+async function runConfigCommand(args) {
+    const [action, ...rest] = args;
+    if (!action || action === "--help" || action === "-h") {
+        console.log(`kweaver context-loader config
+
+Subcommands:
+  set --kn-id <id> [--name <name>]   Add or update kn config (default name: default)
+  use <name>                         Switch current config
+  list                               List all configs and current
+  remove <name>                      Remove a config
+  show                               Show current config (knId + mcpUrl)`);
+        return 0;
+    }
+    const platform = getCurrentPlatform();
+    if (!platform) {
+        console.error("No platform selected. Run: kweaver auth <platform-url>");
+        return 1;
+    }
+    if (action === "show") {
+        const kn = getCurrentContextLoaderKn();
+        if (!kn) {
+            console.log("Context-loader MCP is not configured.");
+            console.log(MCP_NOT_CONFIGURED);
+            return 0;
+        }
+        console.log(JSON.stringify({ mcpUrl: kn.mcpUrl, knId: kn.knId }, null, 2));
+        return 0;
+    }
+    if (action === "list") {
+        const config = loadContextLoaderConfig();
+        if (!config || config.configs.length === 0) {
+            console.log("Context-loader MCP is not configured.");
+            console.log(MCP_NOT_CONFIGURED);
+            return 0;
+        }
+        for (const entry of config.configs) {
+            const mark = entry.name === config.current ? " (current)" : "";
+            console.log(`  ${entry.name}: ${entry.knId}${mark}`);
+        }
+        return 0;
+    }
+    if (action === "set") {
+        let knId;
+        let name = "default";
+        for (let i = 0; i < rest.length; i += 1) {
+            const arg = rest[i];
+            if ((arg === "--kn-id" || arg === "-k") && rest[i + 1]) {
+                knId = rest[i + 1];
+                i += 1;
+            }
+            else if ((arg === "--name" || arg === "-n") && rest[i + 1]) {
+                name = rest[i + 1];
+                i += 1;
+            }
+        }
+        if (!knId) {
+            console.error("Usage: kweaver context-loader config set --kn-id <id> [--name <name>]");
+            return 1;
+        }
+        addContextLoaderEntry(platform, name, knId);
+        console.log(`Context-loader config '${name}' saved.`);
+        return 0;
+    }
+    if (action === "use") {
+        const name = rest[0];
+        if (!name) {
+            console.error("Usage: kweaver context-loader config use <name>");
+            return 1;
+        }
+        try {
+            setCurrentContextLoader(platform, name);
+            console.log(`Switched to context-loader config '${name}'.`);
+            return 0;
+        }
+        catch (error) {
+            console.error(error instanceof Error ? error.message : String(error));
+            return 1;
+        }
+    }
+    if (action === "remove") {
+        const name = rest[0];
+        if (!name) {
+            console.error("Usage: kweaver context-loader config remove <name>");
+            return 1;
+        }
+        removeContextLoaderEntry(platform, name);
+        console.log(`Removed context-loader config '${name}'.`);
+        return 0;
+    }
+    console.error(`Unknown config subcommand: ${action}`);
+    return 1;
+}
+async function runListTools(options, args, pretty) {
+    let cursor;
+    for (let i = 0; i < args.length; i += 1) {
+        if ((args[i] === "--cursor" || args[i] === "-c") && args[i + 1]) {
+            cursor = args[i + 1];
+            i += 1;
+        }
+    }
+    const result = await listTools(options, cursor ? { cursor } : undefined);
+    console.log(formatOutput(result, pretty));
+    return 0;
+}
+async function runListResources(options, args, pretty) {
+    let cursor;
+    for (let i = 0; i < args.length; i += 1) {
+        if ((args[i] === "--cursor" || args[i] === "-c") && args[i + 1]) {
+            cursor = args[i + 1];
+            i += 1;
+        }
+    }
+    const result = await listResources(options, cursor ? { cursor } : undefined);
+    console.log(formatOutput(result, pretty));
+    return 0;
+}
+async function runReadResource(options, args, pretty) {
+    const uri = args.find((a) => !a.startsWith("-"));
+    if (!uri) {
+        console.error("Usage: kweaver context-loader resource <uri>");
+        return 1;
+    }
+    const result = await readResource(options, uri);
+    console.log(formatOutput(result, pretty));
+    return 0;
+}
+async function runListTemplates(options, args, pretty) {
+    let cursor;
+    for (let i = 0; i < args.length; i += 1) {
+        if ((args[i] === "--cursor" || args[i] === "-c") && args[i + 1]) {
+            cursor = args[i + 1];
+            i += 1;
+        }
+    }
+    const result = await listResourceTemplates(options, cursor ? { cursor } : undefined);
+    console.log(formatOutput(result, pretty));
+    return 0;
+}
+async function runListPrompts(options, args, pretty) {
+    let cursor;
+    for (let i = 0; i < args.length; i += 1) {
+        if ((args[i] === "--cursor" || args[i] === "-c") && args[i + 1]) {
+            cursor = args[i + 1];
+            i += 1;
+        }
+    }
+    const result = await listPrompts(options, cursor ? { cursor } : undefined);
+    console.log(formatOutput(result, pretty));
+    return 0;
+}
+async function runGetPrompt(options, args, pretty) {
+    const name = args.find((a) => !a.startsWith("-"));
+    if (!name) {
+        console.error("Usage: kweaver context-loader prompt <name> [--args json]");
+        return 1;
+    }
+    let promptArgs;
+    for (let i = 0; i < args.length; i += 1) {
+        if ((args[i] === "--args" || args[i] === "-a") && args[i + 1]) {
+            try {
+                promptArgs = JSON.parse(args[i + 1]);
+            }
+            catch {
+                console.error("Invalid --args JSON");
+                return 1;
+            }
+            i += 1;
+        }
+    }
+    const result = await getPrompt(options, name, promptArgs);
+    console.log(formatOutput(result, pretty));
+    return 0;
+}
+async function runKnSearch(options, args, pretty) {
+    let query;
+    let onlySchema = false;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (arg === "--only-schema") {
+            onlySchema = true;
+        }
+        else if (!arg.startsWith("-") && !query) {
+            query = arg;
+        }
+    }
+    if (!query) {
+        console.error("Usage: kweaver context-loader kn-search <query> [--only-schema]");
+        return 1;
+    }
+    const result = await knSearch(options, { query, only_schema: onlySchema });
+    console.log(formatOutput(result, pretty));
+    return 0;
+}
+async function runKnSchemaSearch(options, args, pretty) {
+    let query;
+    let maxConcepts;
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if ((arg === "--max" || arg === "-n") && args[i + 1]) {
+            maxConcepts = parseInt(args[i + 1], 10);
+            i += 1;
+        }
+        else if (!arg.startsWith("-") && !query) {
+            query = arg;
+        }
+    }
+    if (!query) {
+        console.error("Usage: kweaver context-loader kn-schema-search <query> [--max N]");
+        return 1;
+    }
+    const result = await knSchemaSearch(options, {
+        query,
+        max_concepts: maxConcepts,
+    });
+    console.log(formatOutput(result, pretty));
+    return 0;
+}
+function parseJsonArg(args) {
+    const raw = args.join(" ").trim();
+    if (!raw) {
+        throw new Error("Missing JSON argument");
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new Error("Invalid JSON argument");
+    }
+}
+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");
+        return 1;
+    }
+    const result = await queryObjectInstance(options, {
+        ot_id: body.ot_id,
+        limit: body.limit,
+        condition: body.condition,
+    });
+    console.log(formatOutput(result, pretty));
+    return 0;
+}
+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");
+        return 1;
+    }
+    const result = await queryInstanceSubgraph(options, body);
+    console.log(formatOutput(result, pretty));
+    return 0;
+}
+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");
+        return 1;
+    }
+    const result = await getLogicPropertiesValues(options, body);
+    console.log(formatOutput(result, pretty));
+    return 0;
+}
+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");
+        return 1;
+    }
+    const result = await getActionInfo(options, body);
+    console.log(formatOutput(result, pretty));
+    return 0;
+}

package/dist/commands/token.d.ts

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

package/dist/commands/token.js

@@ -0,0 +1,24 @@
+import { ensureValidToken, formatHttpError } from "../auth/oauth.js";
+export function parseTokenArgs(args) {
+    if (args.length > 0) {
+        throw new Error("Usage: kweaver token");
+    }
+}
+export async function runTokenCommand(args) {
+    try {
+        parseTokenArgs(args);
+    }
+    catch (error) {
+        console.error(formatHttpError(error));
+        return 1;
+    }
+    try {
+        const token = await ensureValidToken();
+        console.log(token.accessToken);
+        return 0;
+    }
+    catch (error) {
+        console.error(formatHttpError(error));
+        return 1;
+    }
+}

package/dist/config/store.d.ts

@@ -0,0 +1,77 @@
+export interface ClientConfig {
+    baseUrl: string;
+    clientId: string;
+    clientSecret: string;
+    redirectUri: string;
+    logoutRedirectUri: string;
+    scope: string;
+    lang?: string;
+    product?: string;
+    xForwardedPrefix?: string;
+}
+export interface TokenConfig {
+    baseUrl: string;
+    accessToken: string;
+    tokenType: string;
+    scope: string;
+    expiresIn?: number;
+    expiresAt?: string;
+    refreshToken?: string;
+    idToken?: string;
+    obtainedAt: string;
+}
+export interface CallbackSession {
+    baseUrl: string;
+    redirectUri: string;
+    code: string;
+    state: string;
+    scope?: string;
+    receivedAt: string;
+}
+/** Single context-loader entry (named kn_id). */
+export interface ContextLoaderEntry {
+    name: string;
+    knId: string;
+}
+/** Per-platform context-loader config: multiple kn entries, one current. */
+export interface ContextLoaderConfig {
+    configs: ContextLoaderEntry[];
+    current: string;
+}
+export interface PlatformSummary {
+    baseUrl: string;
+    hasToken: boolean;
+    isCurrent: boolean;
+    alias?: string;
+}
+export declare function getConfigDir(): string;
+export declare function getCurrentPlatform(): string | null;
+export declare function setCurrentPlatform(baseUrl: string): void;
+export declare function setPlatformAlias(baseUrl: string, alias: string): void;
+export declare function deletePlatformAlias(baseUrl: string): void;
+export declare function getPlatformAlias(baseUrl: string): string | null;
+export declare function resolvePlatformIdentifier(value: string): string | null;
+export declare function loadClientConfig(baseUrl?: string): ClientConfig | null;
+export declare function saveClientConfig(config: ClientConfig): void;
+export declare function loadTokenConfig(baseUrl?: string): TokenConfig | null;
+export declare function saveTokenConfig(config: TokenConfig): void;
+export declare function loadCallbackSession(baseUrl?: string): CallbackSession | null;
+export declare function saveCallbackSession(session: CallbackSession): void;
+export declare function loadContextLoaderConfig(baseUrl?: string): ContextLoaderConfig | null;
+export declare function saveContextLoaderConfig(baseUrl: string, config: ContextLoaderConfig): void;
+export interface CurrentContextLoaderKn {
+    mcpUrl: string;
+    knId: string;
+}
+export declare function getCurrentContextLoaderKn(baseUrl?: string): CurrentContextLoaderKn | null;
+export declare function addContextLoaderEntry(baseUrl: string, name: string, knId: string): void;
+export declare function setCurrentContextLoader(baseUrl: string, name: string): void;
+export declare function removeContextLoaderEntry(baseUrl: string, name: string): void;
+export declare function hasPlatform(baseUrl: string): boolean;
+/**
+ * Remove token and callback for a platform so the next auth will do a full login.
+ * Keeps client config so the same app registration can be reused.
+ */
+export declare function clearPlatformSession(baseUrl: string): void;
+export declare function deletePlatform(baseUrl: string): void;
+export declare function listPlatforms(): PlatformSummary[];