@kweaver-ai/kweaver-sdk 0.7.3 → 0.7.4

package/dist/commands/bkn-utils.d.ts

@@ -43,6 +43,35 @@ export declare function detectPrimaryKey(table: {
         type: string;
     }>;
 }, rows?: Array<Record<string, string | null>>): PkDetectionResult;
+export interface PkResolution {
+    /** Resolved PK column name, or null when caller must fail-fast. */
+    pk: string | null;
+    /** Origin of the resolution — used by callers for messaging and warnings. */
+    source: "override" | "schema" | "sample" | "ambiguous";
+    /** For 'sample' source: cardinality candidates from `detectPrimaryKey`. */
+    candidates?: PkCandidate[];
+    /** For 'sample' source: rows seen, propagated for error formatting. */
+    sampleSize?: number;
+    /** For 'ambiguous' source: schema-declared composite PK columns. */
+    ambiguous?: string[];
+}
+/**
+ * Resolve a single PK for a BKN object type, in priority order:
+ *   1. caller-provided override (e.g. --pk-map)
+ *   2. schema-declared single PK from datasource metadata
+ *   3. sample-based detection (CSV / schemaless sources)
+ * Composite SQL PKs intentionally surface as `source: "ambiguous"` — BKN
+ * object types take a single PK, so the caller must pick via --pk-map.
+ */
+export declare function resolvePrimaryKey(table: {
+    name: string;
+    columns: Array<{
+        name: string;
+        type: string;
+        isPrimaryKey?: boolean;
+    }>;
+    primaryKeys?: string[];
+}, sampleRows?: Array<Record<string, string | null>>, override?: string | null): PkResolution;
 /** Format a user-facing error message when PK auto-detection fails. */
 export declare function formatPkDetectionError(tableName: string, result: PkDetectionResult): string;
 /**

package/dist/commands/bkn-utils.js

@@ -98,6 +98,43 @@ export function detectPrimaryKey(table, rows) {
         sampleSize: rows.length,
     };
 }
+/**
+ * Resolve a single PK for a BKN object type, in priority order:
+ *   1. caller-provided override (e.g. --pk-map)
+ *   2. schema-declared single PK from datasource metadata
+ *   3. sample-based detection (CSV / schemaless sources)
+ * Composite SQL PKs intentionally surface as `source: "ambiguous"` — BKN
+ * object types take a single PK, so the caller must pick via --pk-map.
+ */
+export function resolvePrimaryKey(table, sampleRows, override) {
+    if (override) {
+        return { pk: override, source: "override" };
+    }
+    const schemaPks = collectSchemaPks(table);
+    if (schemaPks.length === 1) {
+        return { pk: schemaPks[0], source: "schema" };
+    }
+    if (schemaPks.length > 1) {
+        return { pk: null, source: "ambiguous", ambiguous: schemaPks };
+    }
+    const sample = detectPrimaryKey(table, sampleRows);
+    return {
+        pk: sample.pk,
+        source: "sample",
+        candidates: sample.candidates,
+        sampleSize: sample.sampleSize,
+    };
+}
+function collectSchemaPks(table) {
+    // Filter against the actual column list — schema metadata can drift (stale
+    // catalog, post-rename) and an unusable PK should fall through cleanly to
+    // sample/fail rather than poison downstream object-type creation.
+    const colNames = new Set(table.columns.map((c) => c.name));
+    if (Array.isArray(table.primaryKeys) && table.primaryKeys.length > 0) {
+        return table.primaryKeys.filter((n) => colNames.has(n));
+    }
+    return table.columns.filter((c) => c.isPrimaryKey === true).map((c) => c.name);
+}
 /** Format a user-facing error message when PK auto-detection fails. */
 export function formatPkDetectionError(tableName, result) {
     const lines = [`Cannot auto-detect primary key for table '${tableName}'.`];

package/dist/commands/bkn.js

@@ -7,6 +7,7 @@ import { resolveBusinessDomain } from "../config/store.js";
 import { runKnObjectTypeCommand, runKnRelationTypeCommand, runKnActionTypeCommand, runKnConceptGroupCommand, } from "./bkn-schema.js";
 import { runKnSubgraphCommand, runKnActionExecutionCommand, runKnActionLogCommand, runKnSearchCommand, runKnRelationTypePathsCommand, runKnResourcesCommand, } from "./bkn-query.js";
 import { runKnBuildCommand, runKnValidateCommand, runKnPushCommand, runKnPullCommand, runKnCreateFromDsCommand, runKnCreateFromCsvCommand, runKnActionScheduleCommand, runKnJobCommand, } from "./bkn-ops.js";
+import { runKnMetricCommand } from "./bkn-metric.js";
 // Re-export shared utils for backward compatibility (tests import from bkn.js)
 export { pollWithBackoff, parseOntologyQueryFlags, parseJsonObject, parseSearchAfterArray, confirmYes, DISPLAY_HINTS, detectPrimaryKey, detectDisplayKey, } from "./bkn-utils.js";
 // Re-export schema types and parse functions for backward compatibility
@@ -404,6 +405,7 @@ Subcommands:
   job list|get|tasks|delete <kn-id> ...
   relation-type-paths <kn-id> '<json>'   Query relation type paths between OTs
   resources                              List available resources
+  metric list|get|create|search|validate|update|delete|query|dry-run <kn-id> ...   BKN metrics (definitions + data)
 
 Use 'kweaver bkn <subcommand> --help' for subcommand options.`;
 export async function runKnCommand(args) {
@@ -463,6 +465,8 @@ export async function runKnCommand(args) {
             return runKnRelationTypePathsCommand(rest);
         if (subcommand === "resources")
             return runKnResourcesCommand(rest);
+        if (subcommand === "metric")
+            return runKnMetricCommand(rest);
         return Promise.resolve(-1);
     };
     try {

package/dist/commands/ds.js

@@ -389,7 +389,13 @@ async function printDsConnectOutput(base, dsId) {
         datasource_id: dsId,
         tables: tables.map((t) => ({
             name: t.name,
-            columns: t.columns.map((c) => ({ name: c.name, type: c.type, comment: c.comment })),
+            ...(t.primaryKeys && t.primaryKeys.length > 0 ? { primary_keys: t.primaryKeys } : {}),
+            columns: t.columns.map((c) => ({
+                name: c.name,
+                type: c.type,
+                comment: c.comment,
+                ...(c.isPrimaryKey ? { is_primary_key: true } : {}),
+            })),
         })),
     };
     console.log(JSON.stringify(output, null, 2));

package/dist/commands/explore-chat.js

@@ -175,7 +175,7 @@ export function registerChatRoutes(getToken, businessDomain) {
                 return;
             }
             const t = await getToken();
-            const raw = await getTracesByConversation({
+            const result = await getTracesByConversation({
                 baseUrl: t.baseUrl,
                 accessToken: t.accessToken,
                 agentId,
@@ -183,7 +183,7 @@ export function registerChatRoutes(getToken, businessDomain) {
                 businessDomain,
             });
             res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
-            res.end(raw);
+            res.end(JSON.stringify(result));
         }
         catch (error) {
             handleApiError(res, error);

package/dist/commands/model.d.ts

@@ -0,0 +1,72 @@
+export interface ModelGlobalParse {
+    rest: string[];
+    businessDomain: string;
+    mfManagerBaseUrl?: string;
+    mfApiBaseUrl?: string;
+    pretty: boolean;
+}
+/** Strip global flags; fill default business domain. */
+export declare function parseModelGlobalFlags(args: string[]): ModelGlobalParse;
+/** Sparse flags for model llm edit (after leading model_id). Exported for unit tests. */
+export interface ParsedLlmSparseEditFlags {
+    name?: string;
+    modelSeries?: string;
+    modelType?: string;
+    maxModelLen?: number;
+    quota?: boolean;
+    modelConfigFile?: string;
+    upstreamUrl?: string;
+    apiModel?: string;
+    apiKey?: string;
+    apiKeyFile?: string;
+}
+/** Exported for unit tests. */
+export declare function parsedLlmSparseEditHasUpdates(p: ParsedLlmSparseEditFlags): boolean;
+/** Exported for unit tests. */
+export declare function parseLlmSparseEditFlags(tail: string[]): ParsedLlmSparseEditFlags;
+/**
+ * Normalize GET /llm/get JSON into a body suitable for POST /llm/edit.
+ * Exported for unit tests.
+ */
+export declare function llmModelGetToEditBase(raw: unknown): Record<string, unknown>;
+/** Apply sparse llm edit flags onto a normalized record from GET. Exported for unit tests. */
+export declare function mergeLlmEditOntoExistingBase(base: Record<string, unknown>, p: ParsedLlmSparseEditFlags): Promise<Record<string, unknown>>;
+/**
+ * Returns registry **model_name** from ``GET /llm/get`` JSON when present. Exported for unit tests.
+ */
+export declare function llmGetRecordModelName(raw: unknown): string;
+/** Registry **model_name** from ``GET /small-model/get``. Exported for unit tests. */
+export declare function smallGetRecordModelName(raw: unknown): string;
+export interface ParsedSmallAddFlags {
+    name?: string;
+    modelType?: "embedding" | "reranker";
+    batchSize?: number;
+    maxTokens?: number;
+    embeddingDim?: number;
+    modelConfigFile?: string;
+    adapter?: boolean;
+    adapterCodeFile?: string;
+    bodyFile?: string;
+    /** Outbound HTTP API base or full path (stored in model_config.api_url). */
+    upstreamUrl?: string;
+    /** Third-party model id / deployment name (model_config.api_model). */
+    apiModel?: string;
+    /** Inline API secret — prefer --api-key-file (shell history risk). */
+    apiKey?: string;
+    apiKeyFile?: string;
+}
+/** True when sparse CLI flags should perform an edit (excluding --body-file). Exported for unit tests. */
+export declare function parsedSmallFlagsHasEditUpdates(p: ParsedSmallAddFlags): boolean;
+/**
+ * Normalize GET /small-model/get JSON into a body suitable for POST /small-model/edit.
+ * Exported for unit tests.
+ */
+export declare function smallModelGetToEditBase(raw: unknown): Record<string, unknown>;
+/**
+ * Apply sparse edit flags onto a normalized small-model record (from GET). Exported for unit tests.
+ */
+export declare function mergeSmallEditOntoExistingBase(base: Record<string, unknown>, p: ParsedSmallAddFlags): Promise<Record<string, unknown>>;
+/** Parse small-model add/edit flags from argv tail (after action). Exported for unit tests. */
+export declare function parseSmallAddFlags(tail: string[]): ParsedSmallAddFlags;
+export declare function buildSmallBodyFromFlags(p: ParsedSmallAddFlags, modelId?: string): Promise<Record<string, unknown>>;
+export declare function runModelCommand(args: string[]): Promise<number>;