@kweaver-ai/kweaver-sdk 0.7.4 → 0.8.2

package/dist/commands/ds.js

@@ -3,9 +3,11 @@ import { statSync } from "node:fs";
 import { glob } from "node:fs/promises";
 import { resolve as resolvePath } from "node:path";
 import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/oauth.js";
-import { testDatasource, createDatasource, listDatasources, getDatasource, deleteDatasource, listTablesWithColumns, scanMetadata, } from "../api/datasources.js";
+import { testDatasource, createDatasource, listDatasources, getDatasource, deleteDatasource, } from "../api/datasources.js";
+import { listTablesWithColumns, scanMetadata } from "../api/vega.js";
 import { formatCallOutput } from "./call.js";
 import { resolveBusinessDomain } from "../config/store.js";
+import { assertVegaCatalogId } from "./bkn-utils.js";
 import { parseCsvFile, buildTableName, splitBatches, buildFieldMappings, buildDagBody, } from "./import-csv.js";
 import { executeDataflow } from "../api/dataflow.js";
 function confirmYes(prompt) {
@@ -196,9 +198,12 @@ async function runDsTablesCommand(args) {
             id = arg;
     }
     if (!id) {
-        console.error("Usage: kweaver ds tables <id> [--keyword X]");
+        console.error("Usage: kweaver ds tables <vega-catalog-id> [--keyword X]\n" +
+            "  <vega-catalog-id> is a vega catalog id (use `kweaver vega catalog list` to find one;\n" +
+            "  legacy data-connection datasource UUIDs are no longer accepted).");
         return 1;
     }
+    assertVegaCatalogId(id);
     const token = await ensureValidToken();
     const body = await listTablesWithColumns({
         baseUrl: token.baseUrl,

package/dist/commands/skill.d.ts

@@ -1,4 +1,4 @@
-import { type SkillStatus } from "../api/skills.js";
+import { type SkillCategory, type SkillStatus } from "../api/skills.js";
 interface BaseOptions {
     businessDomain: string;
     pretty: boolean;
@@ -20,7 +20,27 @@ interface RegisterOptions extends BaseOptions {
     source?: string;
     extendInfo?: Record<string, unknown>;
 }
+interface UpdateMetadataOptions extends BaseOptions {
+    skillId: string;
+    name: string;
+    description: string;
+    category: SkillCategory;
+    source?: string;
+    extendInfo?: Record<string, unknown>;
+}
+interface UpdatePackageOptions extends BaseOptions {
+    skillId: string;
+    contentFile?: string;
+    zipFile?: string;
+}
+interface HistoryVersionOptions extends BaseOptions {
+    skillId: string;
+    version: string;
+}
 export declare function parseSkillListArgs(args: string[]): ListOptions;
 export declare function parseSkillRegisterArgs(args: string[]): RegisterOptions;
+export declare function parseSkillUpdateMetadataArgs(args: string[]): UpdateMetadataOptions;
+export declare function parseSkillUpdatePackageArgs(args: string[]): UpdatePackageOptions;
+export declare function parseSkillHistoryVersionArgs(args: string[], commandName: string): HistoryVersionOptions;
 export declare function runSkillCommand(args: string[]): Promise<number>;
 export {};

package/dist/commands/skill.js

@@ -2,7 +2,7 @@ import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { basename, dirname, resolve } from "node:path";
 import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/oauth.js";
 import { resolveBusinessDomain } from "../config/store.js";
-import { deleteSkill, downloadSkill, fetchSkillContent, fetchSkillFile, getSkill, getSkillContentIndex, installSkillArchive, listSkillMarket, listSkills, readSkillFile, registerSkillZip, updateSkillStatus, } from "../api/skills.js";
+import { deleteSkill, downloadSkill, downloadSkillManagementArchive, fetchSkillContent, fetchSkillFile, getSkill, getSkillMarketDetail, getSkillContentIndex, getSkillManagementContent, installSkillArchive, listSkillMarket, listSkillHistory, listSkills, publishSkillHistory, readSkillFile, readSkillManagementFile, republishSkillHistory, registerSkillZip, updateSkillMetadata, updateSkillPackageContent, updateSkillPackageZip, updateSkillStatus, } from "../api/skills.js";
 import { bundleSkillDirectoryToZip, bundleSkillFileToZip } from "../utils/skill-bundle.js";
 function printSkillHelp(subcommand) {
     if (subcommand === "list") {
@@ -19,6 +19,10 @@ function printSkillHelp(subcommand) {
         console.log("kweaver skill get <skill-id> [-bd value] [--pretty|--compact]");
         return;
     }
+    if (subcommand === "market-get") {
+        console.log("kweaver skill market-get <skill-id> [-bd value] [--pretty|--compact]");
+        return;
+    }
     if (subcommand === "register") {
         console.log(`kweaver skill register (--content-file <path> | --zip-file <path>)
                        [--source src] [--extend-info json] [-bd value] [--pretty|--compact]
@@ -40,6 +44,28 @@ function printSkillHelp(subcommand) {
         console.log("kweaver skill delete <skill-id> [-y|--yes] [-bd value] [--pretty|--compact]");
         return;
     }
+    if (subcommand === "update-metadata") {
+        console.log(`kweaver skill update-metadata <skill-id> --name <name> --description <text> --category <other_category|system>
+                         [--source <custom|internal>] [--extend-info json] [-bd value] [--pretty|--compact]`);
+        return;
+    }
+    if (subcommand === "update-package") {
+        console.log(`kweaver skill update-package <skill-id> (--content-file <path> | --zip-file <path>)
+                        [-bd value] [--pretty|--compact]`);
+        return;
+    }
+    if (subcommand === "history") {
+        console.log("kweaver skill history <skill-id> [-bd value] [--pretty|--compact]");
+        return;
+    }
+    if (subcommand === "republish") {
+        console.log("kweaver skill republish <skill-id> --version <version> [-bd value] [--pretty|--compact]");
+        return;
+    }
+    if (subcommand === "publish-history") {
+        console.log("kweaver skill publish-history <skill-id> --version <version> [-bd value] [--pretty|--compact]");
+        return;
+    }
     if (subcommand === "content") {
         console.log("kweaver skill content <skill-id> [--raw] [--output file] [-bd value] [--pretty|--compact]");
         return;
@@ -56,24 +82,48 @@ function printSkillHelp(subcommand) {
         console.log("kweaver skill install <skill-id> [directory] [--force] [-bd value] [--pretty|--compact]");
         return;
     }
+    if (subcommand === "management-content") {
+        console.log("kweaver skill management-content <skill-id> [--raw] [--response-mode url|content] [--output file] [-bd value] [--pretty|--compact]");
+        return;
+    }
+    if (subcommand === "management-read-file") {
+        console.log("kweaver skill management-read-file <skill-id> <rel-path> [--response-mode url|content] [--output file] [-bd value] [--pretty|--compact]");
+        return;
+    }
+    if (subcommand === "management-download") {
+        console.log("kweaver skill management-download <skill-id> [--response-mode url|content] [--output file] [-bd value] [--pretty|--compact]");
+        return;
+    }
     console.log(`kweaver skill
 
 Subcommands:
   list [--name kw] [--status status] [--page N] [--page-size N] [-bd value]
   market [--name kw] [--source src] [--page N] [--page-size N] [-bd value]
   get <skill-id> [-bd value]
+  market-get <skill-id> [-bd value]
   register --content-file <path> | --zip-file <path> [--source src] [--extend-info json]
            (--content-file accepts a file named SKILL.md or a directory; both auto-zip)
   set-status <skill-id> <unpublish|published|offline> [-bd value]
   delete <skill-id> [-y] [-bd value]
+  update-metadata <skill-id> --name <name> --description <text> --category <other_category|system> [--source <custom|internal>] [--extend-info json]
+  update-package <skill-id> (--content-file <path> | --zip-file <path>) [-bd value]
+  history <skill-id> [-bd value]
+  republish <skill-id> --version <version> [-bd value]
+  publish-history <skill-id> --version <version> [-bd value]
   content <skill-id> [--raw] [--output file] [-bd value]
   read-file <skill-id> <rel-path> [--raw] [--output file] [-bd value]
   download <skill-id> [--output file] [-bd value]
   install <skill-id> [directory] [--force] [-bd value]
+  management-content <skill-id> [--raw] [--response-mode url|content] [--output file] [-bd value]
+  management-read-file <skill-id> <rel-path> [--response-mode url|content] [--output file] [-bd value]
+  management-download <skill-id> [--response-mode url|content] [--output file] [-bd value]
 
 Examples:
   kweaver skill list --name kweaver
   kweaver skill register --zip-file ./demo-skill.zip --source upload_zip
+  kweaver skill update-metadata skill-123 --name "Demo" --description "Demo skill" --category system
+  kweaver skill update-package skill-123 --content-file ./SKILL.md
+  kweaver skill history skill-123
   kweaver skill content skill-123 --raw
   kweaver skill read-file skill-123 references/guide.md --output ./guide.md
   kweaver skill install skill-123 ./skills/demo-skill --force`);
@@ -276,6 +326,108 @@ function parseSkillGetArgs(args) {
     }
     return { ...base.opts, skillId };
 }
+export function parseSkillUpdateMetadataArgs(args) {
+    const skillId = args[0];
+    if (!skillId || skillId.startsWith("-"))
+        throw new Error("Missing skill-id");
+    let name;
+    let description;
+    let category;
+    let source;
+    let extendInfo;
+    const base = parseBaseArgs(args, 1);
+    for (let i = 1; i < base.args.length; i += 1) {
+        const arg = base.args[i];
+        if (arg === "--help" || arg === "-h")
+            throw new Error("help");
+        if (arg === "--name") {
+            name = base.args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg === "--description") {
+            description = base.args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg === "--category") {
+            const value = base.args[i + 1];
+            if (value !== "other_category" && value !== "system") {
+                throw new Error("Invalid --category. Expected other_category|system");
+            }
+            category = value;
+            i += 1;
+            continue;
+        }
+        if (arg === "--source") {
+            source = base.args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg === "--extend-info") {
+            extendInfo = parseJsonFlag(base.args[i + 1], "--extend-info");
+            i += 1;
+            continue;
+        }
+        throw new Error(`Unsupported skill update-metadata argument: ${arg}`);
+    }
+    if (!name)
+        throw new Error("Missing --name");
+    if (!description)
+        throw new Error("Missing --description");
+    if (!category)
+        throw new Error("Missing --category");
+    return { ...base.opts, skillId, name, description, category, source, extendInfo };
+}
+export function parseSkillUpdatePackageArgs(args) {
+    const skillId = args[0];
+    if (!skillId || skillId.startsWith("-"))
+        throw new Error("Missing skill-id");
+    let contentFile;
+    let zipFile;
+    const base = parseBaseArgs(args, 1);
+    for (let i = 1; i < base.args.length; i += 1) {
+        const arg = base.args[i];
+        if (arg === "--help" || arg === "-h")
+            throw new Error("help");
+        if (arg === "--content-file") {
+            contentFile = base.args[i + 1];
+            i += 1;
+            continue;
+        }
+        if (arg === "--zip-file") {
+            zipFile = base.args[i + 1];
+            i += 1;
+            continue;
+        }
+        throw new Error(`Unsupported skill update-package argument: ${arg}`);
+    }
+    if ((contentFile ? 1 : 0) + (zipFile ? 1 : 0) !== 1) {
+        throw new Error("Use exactly one of --content-file or --zip-file");
+    }
+    return { ...base.opts, skillId, contentFile, zipFile };
+}
+export function parseSkillHistoryVersionArgs(args, commandName) {
+    const skillId = args[0];
+    if (!skillId || skillId.startsWith("-"))
+        throw new Error("Missing skill-id");
+    let version;
+    const base = parseBaseArgs(args, 1);
+    for (let i = 1; i < base.args.length; i += 1) {
+        const arg = base.args[i];
+        if (arg === "--help" || arg === "-h")
+            throw new Error("help");
+        if (arg === "--version") {
+            version = base.args[i + 1];
+            i += 1;
+            continue;
+        }
+        throw new Error(`Unsupported skill ${commandName} argument: ${arg}`);
+    }
+    if (!version)
+        throw new Error("Missing --version");
+    return { ...base.opts, skillId, version };
+}
 function parseSkillReadFileArgs(args) {
     const skillId = args[0];
     const relPath = args[1];
@@ -325,6 +477,101 @@ function parseSkillInstallArgs(args) {
     }
     return { ...base.opts, skillId, directory, force };
 }
+function parseManagementContentArgs(args) {
+    const skillId = args[0];
+    if (!skillId || skillId.startsWith("-"))
+        throw new Error("Missing skill-id");
+    let responseMode;
+    let fetchRaw = false;
+    let output;
+    const base = parseBaseArgs(args, 1);
+    for (let i = 1; i < base.args.length; i += 1) {
+        const arg = base.args[i];
+        if (arg === "--help" || arg === "-h")
+            throw new Error("help");
+        if (arg === "--raw") {
+            fetchRaw = true;
+            continue;
+        }
+        if (arg === "--response-mode") {
+            const value = base.args[i + 1];
+            if (value !== "url" && value !== "content") {
+                throw new Error("Invalid --response-mode. Expected url|content");
+            }
+            responseMode = value;
+            i += 1;
+            continue;
+        }
+        if (arg === "--output" || arg === "-o") {
+            output = base.args[i + 1];
+            i += 1;
+            continue;
+        }
+        throw new Error(`Unsupported skill management-content argument: ${arg}`);
+    }
+    return { ...base.opts, skillId, responseMode, fetchRaw, output };
+}
+function parseManagementReadFileArgs(args) {
+    const skillId = args[0];
+    const relPath = args[1];
+    if (!skillId || skillId.startsWith("-"))
+        throw new Error("Missing skill-id");
+    if (!relPath || relPath.startsWith("-"))
+        throw new Error("Missing rel-path");
+    let responseMode;
+    let output;
+    const base = parseBaseArgs(args, 2);
+    for (let i = 2; i < base.args.length; i += 1) {
+        const arg = base.args[i];
+        if (arg === "--help" || arg === "-h")
+            throw new Error("help");
+        if (arg === "--response-mode") {
+            const value = base.args[i + 1];
+            if (value !== "url" && value !== "content") {
+                throw new Error("Invalid --response-mode. Expected url|content");
+            }
+            responseMode = value;
+            i += 1;
+            continue;
+        }
+        if (arg === "--output" || arg === "-o") {
+            output = base.args[i + 1];
+            i += 1;
+            continue;
+        }
+        throw new Error(`Unsupported skill management-read-file argument: ${arg}`);
+    }
+    return { ...base.opts, skillId, relPath, responseMode, output };
+}
+function parseManagementDownloadArgs(args) {
+    const skillId = args[0];
+    if (!skillId || skillId.startsWith("-"))
+        throw new Error("Missing skill-id");
+    let responseMode;
+    let output;
+    const base = parseBaseArgs(args, 1);
+    for (let i = 1; i < base.args.length; i += 1) {
+        const arg = base.args[i];
+        if (arg === "--help" || arg === "-h")
+            throw new Error("help");
+        if (arg === "--response-mode") {
+            const value = base.args[i + 1];
+            if (value !== "url" && value !== "content") {
+                throw new Error("Invalid --response-mode. Expected url|content");
+            }
+            responseMode = value;
+            i += 1;
+            continue;
+        }
+        if (arg === "--output" || arg === "-o") {
+            output = base.args[i + 1];
+            i += 1;
+            continue;
+        }
+        throw new Error(`Unsupported skill management-download argument: ${arg}`);
+    }
+    return { ...base.opts, skillId, responseMode, output };
+}
 function parseStatusArgs(args) {
     const skillId = args[0];
     const status = args[1];
@@ -401,6 +648,16 @@ export async function runSkillCommand(args) {
                 console.log(format(result, opts.pretty));
                 return 0;
             }
+            if (subcommand === "market-get") {
+                const opts = parseSkillGetArgs(rest);
+                const result = await getSkillMarketDetail({
+                    ...token,
+                    businessDomain: opts.businessDomain,
+                    skillId: opts.skillId,
+                });
+                console.log(format(result, opts.pretty));
+                return 0;
+            }
             if (subcommand === "register") {
                 const opts = parseSkillRegisterArgs(rest);
                 if (opts.contentFile) {
@@ -463,6 +720,79 @@ export async function runSkillCommand(args) {
                 console.log(format(result, opts.pretty));
                 return 0;
             }
+            if (subcommand === "update-metadata") {
+                const opts = parseSkillUpdateMetadataArgs(rest);
+                const result = await updateSkillMetadata({
+                    ...token,
+                    businessDomain: opts.businessDomain,
+                    skillId: opts.skillId,
+                    name: opts.name,
+                    description: opts.description,
+                    category: opts.category,
+                    source: opts.source,
+                    extendInfo: opts.extendInfo,
+                });
+                console.log(format(result, opts.pretty));
+                return 0;
+            }
+            if (subcommand === "update-package") {
+                const opts = parseSkillUpdatePackageArgs(rest);
+                if (opts.contentFile) {
+                    const content = readFileSync(resolve(opts.contentFile), "utf8");
+                    const result = await updateSkillPackageContent({
+                        ...token,
+                        businessDomain: opts.businessDomain,
+                        skillId: opts.skillId,
+                        content,
+                    });
+                    console.log(format(result, opts.pretty));
+                    return 0;
+                }
+                if (opts.zipFile) {
+                    const bytes = new Uint8Array(readFileSync(resolve(opts.zipFile)));
+                    const result = await updateSkillPackageZip({
+                        ...token,
+                        businessDomain: opts.businessDomain,
+                        skillId: opts.skillId,
+                        filename: basename(resolve(opts.zipFile)),
+                        bytes,
+                    });
+                    console.log(format(result, opts.pretty));
+                    return 0;
+                }
+            }
+            if (subcommand === "history") {
+                const opts = parseSkillGetArgs(rest);
+                const result = await listSkillHistory({
+                    ...token,
+                    businessDomain: opts.businessDomain,
+                    skillId: opts.skillId,
+                });
+                console.log(format(result, opts.pretty));
+                return 0;
+            }
+            if (subcommand === "republish") {
+                const opts = parseSkillHistoryVersionArgs(rest, "republish");
+                const result = await republishSkillHistory({
+                    ...token,
+                    businessDomain: opts.businessDomain,
+                    skillId: opts.skillId,
+                    version: opts.version,
+                });
+                console.log(format(result, opts.pretty));
+                return 0;
+            }
+            if (subcommand === "publish-history") {
+                const opts = parseSkillHistoryVersionArgs(rest, "publish-history");
+                const result = await publishSkillHistory({
+                    ...token,
+                    businessDomain: opts.businessDomain,
+                    skillId: opts.skillId,
+                    version: opts.version,
+                });
+                console.log(format(result, opts.pretty));
+                return 0;
+            }
             if (subcommand === "content") {
                 const opts = parseSkillContentArgs(rest);
                 if (opts.fetchRaw || opts.output) {
@@ -533,6 +863,64 @@ export async function runSkillCommand(args) {
                 console.log(`Installed ${opts.skillId} to ${result.directory}`);
                 return 0;
             }
+            if (subcommand === "management-content") {
+                const opts = parseManagementContentArgs(rest);
+                if (opts.fetchRaw || opts.responseMode === "content" || opts.output) {
+                    const result = await getSkillManagementContent({
+                        ...token,
+                        businessDomain: opts.businessDomain,
+                        skillId: opts.skillId,
+                        responseMode: opts.responseMode,
+                    });
+                    if (opts.output && result.content) {
+                        ensureDirectoryForFile(resolve(opts.output));
+                        writeFileSync(resolve(opts.output), result.content, "utf8");
+                        console.log(`Saved ${opts.skillId} management content to ${resolve(opts.output)}`);
+                    }
+                    else if (opts.fetchRaw && result.content) {
+                        process.stdout.write(result.content);
+                        if (!result.content.endsWith("\n"))
+                            process.stdout.write("\n");
+                    }
+                    else {
+                        console.log(format(result, opts.pretty));
+                    }
+                    return 0;
+                }
+                const result = await getSkillManagementContent({
+                    ...token,
+                    businessDomain: opts.businessDomain,
+                    skillId: opts.skillId,
+                    responseMode: opts.responseMode,
+                });
+                console.log(format(result, opts.pretty));
+                return 0;
+            }
+            if (subcommand === "management-read-file") {
+                const opts = parseManagementReadFileArgs(rest);
+                const result = await readSkillManagementFile({
+                    ...token,
+                    businessDomain: opts.businessDomain,
+                    skillId: opts.skillId,
+                    relPath: opts.relPath,
+                });
+                console.log(format(result, opts.pretty));
+                return 0;
+            }
+            if (subcommand === "management-download") {
+                const opts = parseManagementDownloadArgs(rest);
+                const result = await downloadSkillManagementArchive({
+                    ...token,
+                    businessDomain: opts.businessDomain,
+                    skillId: opts.skillId,
+                    responseMode: opts.responseMode,
+                });
+                const output = resolve(opts.output ?? result.fileName);
+                ensureDirectoryForFile(output);
+                writeFileSync(output, result.bytes);
+                console.log(`Saved ${opts.skillId} management archive to ${output}`);
+                return 0;
+            }
             console.error(`Unknown skill subcommand: ${subcommand}`);
             return 1;
         });

package/dist/commands/trace.d.ts

@@ -0,0 +1,39 @@
+export interface ParsedTraceArgs {
+    subcommand: "diagnose" | "rules-validate" | "eval-set-build" | "eval-set-test" | "schema-validate" | "help";
+    mode?: "single" | "batch";
+    conversationId?: string;
+    traces?: string;
+    rulePath?: string;
+    out: string | null;
+    rulesDir: string | null;
+    noBuiltin: boolean;
+    noLlm: boolean;
+    noArtifacts: boolean;
+    maxParallel: number;
+    format: 'yaml' | 'markdown' | 'both' | null;
+    lang: 'en' | 'zh' | null;
+    baseUrl: string | null;
+    token: string | null;
+    businessDomain: string | null;
+    queriesPath?: string;
+    diagnosisPath?: string;
+    onConflict?: "fail" | "skip" | "overwrite";
+    redactionRules?: string;
+    evalSetId?: string;
+    schemaValidatePath?: string;
+    schemaKind?: string;
+    evalSetPath?: string;
+    candidateAgentId?: string;
+    candidateAgentVersion?: string;
+}
+export declare function parseTraceArgs(argv: string[]): ParsedTraceArgs;
+export declare function runTraceCommand(rest: string[]): Promise<number>;
+export declare class SchemaKindRequiredError extends Error {
+    constructor(filePath: string);
+}
+export declare function inferKind(filePath: string): string | null;
+export interface RunSchemaValidateOpts {
+    filePath: string;
+    kind: string | undefined;
+}
+export declare function runSchemaValidate(opts: RunSchemaValidateOpts): Promise<number>;