@kweaver-ai/kweaver-sdk 0.7.2 → 0.7.4

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

@@ -18,14 +18,67 @@ export declare function parseOntologyQueryFlags(args: string[]): {
     businessDomain: string;
 };
 export declare const DISPLAY_HINTS: string[];
-/** Detect primary key: first column (left-to-right) with all unique values in the sample. */
+export interface PkCandidate {
+    name: string;
+    cardinality: number;
+}
+export interface PkDetectionResult {
+    /** Detected PK column name, or null when detection is not confident. */
+    pk: string | null;
+    /** All columns sorted by cardinality desc. Empty when no sample. */
+    candidates: PkCandidate[];
+    /** 0 when no sample data was provided. */
+    sampleSize: number;
+}
+export declare const PK_NAME_HINTS: string[];
+/**
+ * Detect primary key from a row sample. Returns null pk when no column has
+ * unique values across the sample — caller must fail-fast and prompt for --pk-map.
+ * Among columns that ARE fully unique, prefers PK-like names (id, *_id, pk).
+ */
 export declare function detectPrimaryKey(table: {
     name: string;
     columns: Array<{
         name: string;
         type: string;
     }>;
-}, rows?: Array<Record<string, string | null>>): 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;
+/**
+ * Parse --pk-map string into a Record<table, field>.
+ * Format: "<table>:<field>[,<table>:<field>...]". Throws on invalid input.
+ */
+export declare function parsePkMap(input: string): Record<string, string>;
 export declare function detectDisplayKey(table: {
     name: string;
     columns: Array<{

package/dist/commands/bkn-utils.js

@@ -68,18 +68,112 @@ export function parseOntologyQueryFlags(args) {
 }
 // ── Schema detection helpers ─────────────────────────────────────────────────
 export const DISPLAY_HINTS = ["name", "title", "label", "display_name", "description"];
-/** Detect primary key: first column (left-to-right) with all unique values in the sample. */
+export const PK_NAME_HINTS = ["id", "_id", "pk"];
+/**
+ * Detect primary key from a row sample. Returns null pk when no column has
+ * unique values across the sample — caller must fail-fast and prompt for --pk-map.
+ * Among columns that ARE fully unique, prefers PK-like names (id, *_id, pk).
+ */
 export function detectPrimaryKey(table, rows) {
-    if (rows && rows.length > 0) {
-        for (const col of table.columns) {
-            const values = rows.map((r) => r[col.name]);
-            const unique = new Set(values);
-            if (unique.size === rows.length)
-                return col.name;
+    if (!rows || rows.length === 0) {
+        return { pk: null, candidates: [], sampleSize: 0 };
+    }
+    const candidates = table.columns
+        .map((col) => {
+        const unique = new Set(rows.map((r) => r[col.name]));
+        return { name: col.name, cardinality: unique.size };
+    })
+        .sort((a, b) => b.cardinality - a.cardinality);
+    const fullCardinality = candidates.filter((c) => c.cardinality === rows.length);
+    if (fullCardinality.length === 0) {
+        return { pk: null, candidates, sampleSize: rows.length };
+    }
+    const named = fullCardinality.find((c) => {
+        const lower = c.name.toLowerCase();
+        return PK_NAME_HINTS.some((h) => lower === h || lower.endsWith(`_${h}`));
+    });
+    return {
+        pk: named?.name ?? fullCardinality[0].name,
+        candidates,
+        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}'.`];
+    if (result.sampleSize === 0) {
+        lines.push(`  No sample data available — chain with 'kweaver ds import-csv' or use --pk-map.`);
+    }
+    else {
+        lines.push(`  No column has unique values in the ${result.sampleSize}-row sample.`);
+        lines.push(`  Top candidates by cardinality:`);
+        const top = result.candidates.slice(0, 5);
+        const maxNameLen = Math.max(...top.map((c) => c.name.length));
+        for (const c of top) {
+            lines.push(`    ${c.name.padEnd(maxNameLen)}  ${c.cardinality} unique`);
+        }
+    }
+    lines.push(``);
+    lines.push(`  Re-run with --pk-map to specify explicitly:`);
+    lines.push(`    --pk-map ${tableName}:<column>`);
+    return lines.join("\n");
+}
+/**
+ * Parse --pk-map string into a Record<table, field>.
+ * Format: "<table>:<field>[,<table>:<field>...]". Throws on invalid input.
+ */
+export function parsePkMap(input) {
+    const result = {};
+    for (const pair of input.split(",").map((s) => s.trim()).filter(Boolean)) {
+        const idx = pair.indexOf(":");
+        if (idx <= 0 || idx >= pair.length - 1) {
+            throw new Error(`Invalid --pk-map entry '${pair}'. Expected '<table>:<field>[,<table>:<field>...]'`);
+        }
+        const table = pair.slice(0, idx).trim();
+        const field = pair.slice(idx + 1).trim();
+        if (!table || !field) {
+            throw new Error(`Invalid --pk-map entry '${pair}'. Expected '<table>:<field>[,<table>:<field>...]'`);
         }
+        result[table] = field;
     }
-    // Fallback: first column
-    return table.columns[0]?.name ?? "id";
+    return result;
 }
 export function detectDisplayKey(table, primaryKey) {
     for (const col of table.columns) {

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/dataflow.js

@@ -7,6 +7,9 @@ import { ensureValidToken, formatHttpError, with401RefreshRetry } from "../auth/
 import { resolveBusinessDomain } from "../config/store.js";
 import { getDataflowLogsPage, listDataflowRuns, listDataflows, runDataflowWithFile, runDataflowWithRemoteUrl, } from "../api/dataflow2.js";
 import { createDataflow } from "../api/dataflow.js";
+import { createVegaResource } from "../api/vega.js";
+import { createKnowledgeNetwork } from "../api/knowledge-networks.js";
+import { loadTemplate, listTemplates, renderTemplate, generateSourceIdentifier, getTemplatesDir, } from "../utils/template-loader.js";
 function renderTable(rows) {
     if (rows.length === 0)
         return "";
@@ -101,26 +104,6 @@ export async function runDataflowCommand(args) {
         .strict()
         .fail((message, error) => {
         throw error ?? new Error(message);
-    })
-        .command("create <json>", "Create a new dataflow (DAG) from a JSON definition", (command) => command
-        .positional("json", {
-        type: "string",
-        describe: "JSON body string or @file-path to read from file",
-    })
-        .option("biz-domain", { alias: "bd", type: "string" }), async (argv) => {
-        exitCode = await with401RefreshRetry(async () => {
-            const base = await requireTokenAndBusinessDomain(argv.bizDomain);
-            let raw = argv.json;
-            if (raw.startsWith("@")) {
-                const filePath = raw.slice(1);
-                await access(filePath, constants.R_OK);
-                raw = (await readFile(filePath, "utf8")).toString();
-            }
-            const body = JSON.parse(raw);
-            const dagId = await createDataflow({ ...base, body });
-            console.log(JSON.stringify({ id: dagId }, null, 2));
-            return 0;
-        });
     })
         .command("list", "List all dataflows", (command) => command
         .option("biz-domain", {
@@ -280,6 +263,197 @@ export async function runDataflowCommand(args) {
             }
             return 0;
         });
+    })
+        .command("templates", "List all available templates", {
+        json: { type: "boolean", default: false, describe: "Output as JSON" },
+    }, (argv) => {
+        const templatesDir = getTemplatesDir();
+        return Promise.all([
+            listTemplates("dataset", templatesDir),
+            listTemplates("bkn", templatesDir),
+            listTemplates("dataflow", templatesDir),
+        ]).then(([datasetTemplates, bknTemplates, dataflowTemplates]) => {
+            if (argv.json) {
+                console.log(JSON.stringify({
+                    dataset: datasetTemplates,
+                    bkn: bknTemplates,
+                    dataflow: dataflowTemplates,
+                }, null, 2));
+            }
+            else {
+                console.log("Dataset Templates:");
+                for (const t of datasetTemplates) {
+                    console.log(`  - ${t.name.padEnd(18)} ${t.description}`);
+                }
+                console.log("");
+                console.log("BKN Templates:");
+                for (const t of bknTemplates) {
+                    console.log(`  - ${t.name.padEnd(18)} ${t.description}`);
+                }
+                console.log("");
+                console.log("Dataflow Templates:");
+                for (const t of dataflowTemplates) {
+                    console.log(`  - ${t.name.padEnd(18)} ${t.description}`);
+                }
+            }
+        });
+    })
+        .command("create-dataset", "Create a dataset from a template", (command) => command
+        .option("template", { type: "string", demandOption: true, describe: "Template name" })
+        .option("set", { type: "array", string: true, describe: "Set parameter (key=value), can be used multiple times" })
+        .option("json", { type: "boolean", default: false, describe: "Output as JSON" })
+        .option("biz-domain", { alias: "bd", type: "string" }), async (argv) => {
+        exitCode = await with401RefreshRetry(async () => {
+            const base = await requireTokenAndBusinessDomain(argv.bizDomain);
+            const templatesDir = getTemplatesDir();
+            // Parse --set arguments
+            const args = {};
+            if (argv.set) {
+                for (const item of argv.set) {
+                    const eqIdx = item.indexOf("=");
+                    if (eqIdx > 0) {
+                        const key = item.slice(0, eqIdx);
+                        const value = item.slice(eqIdx + 1);
+                        args[key] = value;
+                    }
+                }
+            }
+            // Load template
+            const loaded = await loadTemplate(argv.template, "dataset", templatesDir);
+            if (!loaded) {
+                console.error(`Template not found: ${argv.template}`);
+                return 1;
+            }
+            // Auto-generate source_identifier if not provided
+            if (!args["source_identifier"]) {
+                const prefixMap = {
+                    "document": "dataflow_document",
+                    "document-content": "dataflow_content",
+                    "document-element": "dataflow_element",
+                };
+                const prefix = prefixMap[loaded.manifest.name] || "dataflow";
+                args["source_identifier"] = generateSourceIdentifier(prefix);
+            }
+            // Render template
+            const rendered = renderTemplate(loaded.template, loaded.manifest, args);
+            // Create dataset via API
+            const response = await createVegaResource({
+                ...base,
+                body: JSON.stringify(rendered),
+            });
+            const result = JSON.parse(response);
+            if (argv.json) {
+                console.log(JSON.stringify({ success: true, id: result.id, name: args.name }, null, 2));
+            }
+            else {
+                console.log(`dataset created: id=${result.id}`);
+            }
+            return 0;
+        });
+    })
+        .command("create-bkn", "Create a BKN (knowledge network) from a template", (command) => command
+        .option("template", { type: "string", demandOption: true, describe: "Template name" })
+        .option("set", { type: "array", string: true, describe: "Set parameter (key=value), can be used multiple times" })
+        .option("json", { type: "boolean", default: false, describe: "Output as JSON" })
+        .option("biz-domain", { alias: "bd", type: "string" }), async (argv) => {
+        exitCode = await with401RefreshRetry(async () => {
+            const base = await requireTokenAndBusinessDomain(argv.bizDomain);
+            const templatesDir = getTemplatesDir();
+            // Parse --set arguments
+            const args = {};
+            if (argv.set) {
+                for (const item of argv.set) {
+                    const eqIdx = item.indexOf("=");
+                    if (eqIdx > 0) {
+                        const key = item.slice(0, eqIdx);
+                        const value = item.slice(eqIdx + 1);
+                        args[key] = value;
+                    }
+                }
+            }
+            // Load template
+            const loaded = await loadTemplate(argv.template, "bkn", templatesDir);
+            if (!loaded) {
+                console.error(`Template not found: ${argv.template}`);
+                return 1;
+            }
+            // Render template
+            const rendered = renderTemplate(loaded.template, loaded.manifest, args);
+            rendered.business_domain = base.businessDomain;
+            // Create BKN via API
+            const response = await createKnowledgeNetwork({
+                ...base,
+                body: JSON.stringify(rendered),
+                validate_dependency: false,
+            });
+            const result = JSON.parse(response);
+            if (argv.json) {
+                console.log(JSON.stringify({ success: true, id: result.id, name: args.name }, null, 2));
+            }
+            else {
+                console.log(`bkn created: id=${result.id}`);
+            }
+            return 0;
+        });
+    })
+        .command("create [json]", "Create a new dataflow (DAG) from a JSON definition or template", (command) => command
+        .positional("json", {
+        type: "string",
+        describe: "JSON body string or @file-path to read from file",
+    })
+        .option("template", { type: "string", describe: "Template name (use instead of json)" })
+        .option("set", { type: "array", string: true, describe: "Set parameter (key=value), can be used multiple times" })
+        .option("biz-domain", { alias: "bd", type: "string" })
+        .check((argv) => {
+        const hasJson = typeof argv.json === "string";
+        const hasTemplate = typeof argv.template === "string";
+        if (hasJson && hasTemplate) {
+            throw new Error("Cannot use both json and --template");
+        }
+        if (!hasJson && !hasTemplate) {
+            throw new Error("Either json or --template is required");
+        }
+        return true;
+    }), async (argv) => {
+        exitCode = await with401RefreshRetry(async () => {
+            const base = await requireTokenAndBusinessDomain(argv.bizDomain);
+            let body;
+            if (argv.template) {
+                // Use template
+                const templatesDir = getTemplatesDir();
+                // Parse --set arguments
+                const args = {};
+                if (argv.set) {
+                    for (const item of argv.set) {
+                        const eqIdx = item.indexOf("=");
+                        if (eqIdx > 0) {
+                            const key = item.slice(0, eqIdx);
+                            const value = item.slice(eqIdx + 1);
+                            args[key] = value;
+                        }
+                    }
+                }
+                const loaded = await loadTemplate(argv.template, "dataflow", templatesDir);
+                if (!loaded) {
+                    console.error(`Template not found: ${argv.template}`);
+                    return 1;
+                }
+                body = renderTemplate(loaded.template, loaded.manifest, args);
+            }
+            else {
+                // Use JSON
+                let raw = argv.json;
+                if (raw.startsWith("@")) {
+                    const filePath = raw.slice(1);
+                    await access(filePath, constants.R_OK);
+                    raw = (await readFile(filePath, "utf8")).toString();
+                }
+                body = JSON.parse(raw);
+            }
+            const dagId = await createDataflow({ ...base, body });
+            console.log(JSON.stringify({ id: dagId }, null, 2));
+            return 0;
+        });
     })
         .demandCommand(1);
     try {

package/dist/commands/ds.d.ts

@@ -34,7 +34,6 @@ export declare function parseImportCsvArgs(args: string[]): {
     tablePrefix: string;
     batchSize: number;
     businessDomain: string;
-    recreate: boolean;
 };
 export declare function resolveFiles(pattern: string): Promise<string[]>;
 export interface ImportCsvResult {

package/dist/commands/ds.js

@@ -3,7 +3,7 @@ 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, } from "../api/datasources.js";
+import { testDatasource, createDatasource, listDatasources, getDatasource, deleteDatasource, listTablesWithColumns, scanMetadata, } from "../api/datasources.js";
 import { formatCallOutput } from "./call.js";
 import { resolveBusinessDomain } from "../config/store.js";
 import { parseCsvFile, buildTableName, splitBatches, buildFieldMappings, buildDagBody, } from "./import-csv.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));
@@ -404,7 +410,6 @@ Options:
   --files <s>          CSV file paths (comma-separated or glob pattern, required)
   --table-prefix <s>   Table name prefix (default: none)
   --batch-size <n>     Rows per batch (default: 500, range: 1-10000)
-  --recreate           First batch uses overwrite (drop/recreate table) then append; use when schema changed
   -bd, --biz-domain    Business domain (default: bd_public)`;
 export function parseImportCsvArgs(args) {
     let datasourceId = "";
@@ -412,7 +417,6 @@ export function parseImportCsvArgs(args) {
     let tablePrefix = "";
     let batchSize = 500;
     let businessDomain = "";
-    let recreate = false;
     for (let i = 0; i < args.length; i += 1) {
         const arg = args[i];
         if (arg === "--help" || arg === "-h")
@@ -421,10 +425,6 @@ export function parseImportCsvArgs(args) {
             files = args[++i];
             continue;
         }
-        if (arg === "--recreate") {
-            recreate = true;
-            continue;
-        }
         if (arg === "--table-prefix" && args[i + 1]) {
             tablePrefix = args[++i];
             continue;
@@ -447,7 +447,7 @@ export function parseImportCsvArgs(args) {
     }
     if (!businessDomain)
         businessDomain = resolveBusinessDomain();
-    return { datasourceId, files, tablePrefix, batchSize, businessDomain, recreate };
+    return { datasourceId, files, tablePrefix, batchSize, businessDomain };
 }
 export async function resolveFiles(pattern) {
     const parts = pattern.split(",").map((p) => p.trim()).filter(Boolean);
@@ -550,7 +550,6 @@ export async function runDsImportCsv(args) {
                 tableExist,
                 data: batch,
                 fieldMappings,
-                recreate: options.recreate,
             });
             const t0 = Date.now();
             process.stderr.write(`[${tableName}] batch ${batchLabel} (${rowCount} rows)... `);
@@ -585,6 +584,23 @@ export async function runDsImportCsv(args) {
     if (failed.length > 0) {
         console.error(`Failed tables: ${failed.join(", ")}`);
     }
+    // Refresh the platform metadata catalog so the freshly imported tables
+    // are visible to ds tables / bkn create-from-ds without manual scan.
+    // Best-effort: scan failures shouldn't mask a successful import.
+    if (succeeded.length > 0) {
+        process.stderr.write("Scanning datasource metadata ...\n");
+        try {
+            await scanMetadata({
+                ...base,
+                id: options.datasourceId,
+                dsType: datasourceType,
+                businessDomain: options.businessDomain,
+            });
+        }
+        catch (err) {
+            console.error(`Scan warning (continuing): ${formatHttpError(err)}`);
+        }
+    }
     return { code: failed.length > 0 ? 1 : 0, tables: succeeded, failed, tableColumns, sampleRows };
 }
 export async function runDsImportCsvCommand(args) {

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/import-csv.d.ts

@@ -19,8 +19,6 @@ export interface DagBodyOptions {
     tableExist: boolean;
     data: Array<Record<string, string | null>>;
     fieldMappings: FieldMapping[];
-    /** When true on the first batch (`tableExist` false), use "insert" to force table recreation. */
-    recreate?: boolean;
 }
 /**
  * Read a CSV file and return its headers and rows.

package/dist/commands/import-csv.js

@@ -80,11 +80,9 @@ export function buildFieldMappings(headers) {
  * The DAG has two steps: a manual trigger and the database write.
  */
 export function buildDagBody(options) {
-    const { datasourceId, datasourceType, tableName, tableExist, data, fieldMappings, recreate } = options;
+    const { datasourceId, datasourceType, tableName, tableExist, data, fieldMappings } = options;
     const ts = Date.now();
-    // "insert" creates/replaces the table; "append" adds rows to an existing table.
-    // With --recreate, use "insert" on first batch to force table recreation when schema changed.
-    const operateType = tableExist ? "append" : recreate ? "insert" : "append";
+    const operateType = "append";
     const triggerStep = {
         id: "step-trigger",
         title: "Trigger",

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>;