@qualcomm-ui/mdx-vite 2.10.1 → 2.11.1

package/dist/cli.js

@@ -3570,15 +3570,41 @@ var knowledgeIntegrationSchema = implement().with(
     exclude: z2.array(z2.string()).optional(),
     exports: knowledgeExportsSchema.optional(),
     extraFiles: z2.array(knowledgeExtraFileSchema).optional(),
+    frontmatterFields: z2.union([z2.array(z2.string()), z2.any()]).optional(),
     metadata: z2.record(z2.string(), z2.string()).optional(),
     name: z2.string().optional(),
     outputMode: z2.union([z2.literal("per-page"), z2.literal("aggregated")]).optional(),
     outputPath: z2.string().optional(),
+    pageIdPrefix: z2.string().optional(),
     pageTitlePrefix: z2.string().optional()
   }
 );
+var knowledgeEnvironmentSchema = implement().with({
+  baseUrl: z2.string().optional(),
+  description: z2.string().optional(),
+  exclude: z2.array(z2.string()).optional(),
+  exports: knowledgeExportsSchema.optional(),
+  extraFiles: z2.array(knowledgeExtraFileSchema).optional(),
+  frontmatterFields: z2.array(z2.string()).optional(),
+  id: z2.string(),
+  metadata: z2.record(z2.string(), z2.string()).optional(),
+  name: z2.string().optional(),
+  outputMode: z2.union([z2.literal("per-page"), z2.literal("aggregated")]).optional(),
+  outputPath: z2.string(),
+  pageIdPrefix: z2.string().optional(),
+  pageTitlePrefix: z2.string().optional()
+});
+var openWebUiIntegrationSchema = implement().with({
+  envFile: z2.string().optional(),
+  id: z2.string()
+});
+var knowledgeIntegrationsSchema = implement().with({
+  openWebUi: z2.array(openWebUiIntegrationSchema).optional()
+});
 var knowledgeConfigSchema = implement().with({
-  global: knowledgeIntegrationSchema.optional()
+  environments: z2.array(knowledgeEnvironmentSchema).optional(),
+  global: knowledgeIntegrationSchema.optional(),
+  integrations: knowledgeIntegrationsSchema.optional()
 });
 var configSchema = implement().with({
   appDirectory: z2.string().optional(),
@@ -5286,6 +5312,7 @@ function addGeneratePageMapCommand() {
 }
 
 // src/open-web-ui-knowledge/download-knowledge.ts
+import dotenv from "dotenv";
 import { mkdir, writeFile as writeFile2 } from "node:fs/promises";
 import { resolve as resolve2 } from "node:path";
 
@@ -5602,9 +5629,9 @@ function loadEnv() {
   }
 }
 function getConfigFromEnv() {
-  const openWebUiUrl = process.env.WEB_UI_URL;
-  const openWebUiKey = process.env.WEB_UI_KEY;
-  const knowledgeId = process.env.KNOWLEDGE_ID;
+  const openWebUiUrl = process.env.WEB_UI_URL || process.env.OPEN_WEB_UI_URL;
+  const openWebUiKey = process.env.WEB_UI_KEY || process.env.OPEN_WEB_UI_API_KEY;
+  const knowledgeId = process.env.KNOWLEDGE_ID || process.env.OPEN_WEB_UI_KNOWLEDGE_ID;
   if (!openWebUiUrl || !openWebUiKey || !knowledgeId) {
     throw new Error("WEB_UI_URL, WEB_UI_KEY, and KNOWLEDGE_ID must be set");
   }
@@ -5614,11 +5641,47 @@ function getConfigFromEnv() {
     webUiUrl: openWebUiUrl
   };
 }
+function loadOpenWebUiEnv(integration, integrationName) {
+  const envFilePath = integration.envFile ?? `.env.${integration.id}`;
+  config({ override: true, path: envFilePath });
+  const url = process.env.OPEN_WEB_UI_URL ?? process.env.WEB_UI_URL;
+  const apiKey = process.env.OPEN_WEB_UI_API_KEY ?? process.env.WEB_UI_KEY;
+  const knowledgeId = process.env.OPEN_WEB_UI_KNOWLEDGE_ID ?? process.env.KNOWLEDGE_ID;
+  if (!url) {
+    throw new Error(
+      `Missing OPEN_WEB_UI_URL for integration "${integrationName}" (env file: ${envFilePath})`
+    );
+  }
+  if (!apiKey) {
+    throw new Error(
+      `Missing OPEN_WEB_UI_API_KEY for integration "${integrationName}" (env file: ${envFilePath})`
+    );
+  }
+  if (!knowledgeId) {
+    throw new Error(
+      `Missing OPEN_WEB_UI_KNOWLEDGE_ID for integration "${integrationName}" (env file: ${envFilePath})`
+    );
+  }
+  return { apiKey, knowledgeId, url };
+}
+function resolveOpenWebUiIntegration(name, integration, outputPath) {
+  const credentials = loadOpenWebUiEnv(integration, name);
+  return {
+    apiKey: credentials.apiKey,
+    environment: integration.id,
+    knowledgeId: credentials.knowledgeId,
+    name,
+    outputPath,
+    url: credentials.url
+  };
+}
 
 // src/open-web-ui-knowledge/download-knowledge.ts
 function addDownloadKnowledgeCommand() {
-  program.command("download-knowledge").description("Download files from an Open Web UI knowledge base").requiredOption("-o, --output-dir <outputDir>", "Folder path").action(async (opts) => {
+  program.command("download-knowledge").description("Download files from an Open Web UI knowledge base").requiredOption("-o, --output-dir <outputDir>", "Folder path").requiredOption("-e, --environment <environments>", "environment to load").action(async (opts) => {
     loadEnv();
+    const env = opts.environment;
+    dotenv.config({ path: `.env.${env}` });
     await mkdir(opts.outputDir, { recursive: true }).catch();
     const config2 = getConfigFromEnv();
     const apiConfig = { apiKey: config2.webUiKey, baseUrl: config2.webUiUrl };
@@ -5647,6 +5710,7 @@ function addDownloadKnowledgeCommand() {
 }
 
 // src/open-web-ui-knowledge/generate-knowledge.ts
+import chalk3 from "chalk";
 import { minimatch } from "minimatch";
 import {
   access,
@@ -5707,6 +5771,100 @@ function loadKnowledgeConfigFromEnv(options) {
     routeDir
   };
 }
+function mergeEnvironmentConfig(global, environment) {
+  return {
+    ...global,
+    ...environment,
+    extraFiles: environment.extraFiles ?? global?.extraFiles,
+    metadata: global?.metadata || environment.metadata ? { ...global?.metadata, ...environment.metadata } : void 0
+  };
+}
+function loadEnvironmentConfigs(options = {}) {
+  const configLoader = new ConfigLoader({});
+  const resolvedConfig = configLoader.loadConfig();
+  const knowledgeConfig = resolvedConfig.knowledge;
+  const globalConfig = knowledgeConfig?.global;
+  const environments = knowledgeConfig?.environments;
+  const routeDir = join2(
+    resolvedConfig.appDirectory,
+    resolvedConfig.pageDirectory
+  );
+  if (!existsSync(resolve3(routeDir))) {
+    throw new Error(`Route directory ${routeDir} does not exist`);
+  }
+  if (!environments || environments.length === 0) {
+    const legacyConfig = loadKnowledgeConfigFromEnv(
+      options.cliOptions ?? { outputMode: "per-page" }
+    );
+    return [legacyConfig];
+  }
+  let filteredEnvironments = environments;
+  if (options.environments?.length) {
+    const filterSet = new Set(options.environments);
+    filteredEnvironments = environments.filter((env) => filterSet.has(env.id));
+  }
+  if (filteredEnvironments.length === 0) {
+    throw new Error(
+      `No matching environments found. Available: ${environments.map((e) => e.id).join(", ")}`
+    );
+  }
+  return filteredEnvironments.map((envConfig) => {
+    const merged = mergeEnvironmentConfig(globalConfig, envConfig);
+    const cliOpts = options.cliOptions;
+    const cliMetadata = parseCliMetadata(cliOpts?.metadata);
+    const mergedMetadata = merged.metadata || cliMetadata ? { ...merged.metadata, ...cliMetadata } : void 0;
+    return {
+      ...merged,
+      ...cliOpts,
+      baseUrl: cliOpts?.baseUrl ?? merged.baseUrl ?? process.env.DOCS_SITE_BASE_URL,
+      docPropsPath: resolvedConfig.typeDocProps,
+      environmentName: envConfig.id,
+      exclude: (cliOpts?.exclude?.length ? cliOpts.exclude : void 0) ?? merged.exclude ?? (process.env.FILE_EXCLUDE_PATTERN ?? "").split(",").filter(Boolean),
+      extraFiles: merged.extraFiles,
+      metadata: mergedMetadata,
+      outputMode: cliOpts?.outputMode ?? merged.outputMode ?? "per-page",
+      outputPath: merged.outputPath,
+      pageTitlePrefix: cliOpts?.pageTitlePrefix ?? merged.pageTitlePrefix ?? process.env.PAGE_TITLE_PREFIX,
+      routeDir
+    };
+  });
+}
+function loadOpenWebUiIntegrations(options = {}) {
+  const configLoader = new ConfigLoader({});
+  const resolvedConfig = configLoader.loadConfig();
+  const knowledgeConfig = resolvedConfig.knowledge;
+  const environments = knowledgeConfig?.environments;
+  const integrations = knowledgeConfig?.integrations?.openWebUi;
+  if (!integrations || integrations.length === 0) {
+    return [];
+  }
+  let filteredIntegrations = integrations;
+  if (options.integrations?.length) {
+    const filterSet = new Set(options.integrations);
+    filteredIntegrations = integrations.filter(
+      (integration) => filterSet.has(integration.id)
+    );
+  }
+  if (options.environments?.length) {
+    const filterSet = new Set(options.environments);
+    filteredIntegrations = filteredIntegrations.filter(
+      (integration) => filterSet.has(integration.id)
+    );
+  }
+  return filteredIntegrations.map((integration) => {
+    const envConfig = environments?.find((e) => e.id === integration.id);
+    if (!envConfig) {
+      throw new Error(
+        `Integration "${integration.id}" references unknown environment "${integration.id}". Available environments: ${environments?.map((e) => e.id).join(", ") || "none"}`
+      );
+    }
+    return {
+      integration,
+      name: integration.id,
+      outputPath: envConfig.outputPath
+    };
+  });
+}
 
 // src/open-web-ui-knowledge/generate-knowledge.ts
 async function exists(dirPath) {
@@ -5880,7 +6038,6 @@ var KnowledgeGenerator = class {
         processedPages,
         extractedMetadata
       );
-      await this.generateExtraFiles(extractedMetadata);
     }
     return pages;
   }
@@ -5934,6 +6091,7 @@ var KnowledgeGenerator = class {
       const mdxFiles = entries.filter(
         (f) => f.name.endsWith(".mdx") && !shouldExclude(join3(dirPath, f.name))
       ) ?? [];
+      const pageIdPrefix = this.config.pageIdPrefix ?? "";
       for (const mdxFile of mdxFiles) {
         const demosFolder = entries.find((f) => f.name === "demos");
         const demosFolderPath = demosFolder ? join3(dirPath, demosFolder.name) : void 0;
@@ -5945,7 +6103,7 @@ var KnowledgeGenerator = class {
         components.push({
           demosFolder: demosFolderPath,
           filePath: dirPath,
-          id: segments.join("-").trim(),
+          id: `${pageIdPrefix ? `${pageIdPrefix}-` : ""}${segments.join("-").trim()}`,
           mdxFile: join3(dirPath, mdxFile.name),
           name: segments.at(-1),
           pathname: url,
@@ -6480,9 +6638,10 @@ ${propsToDefinitionList(outputs)}`);
     console.log(`File size: ${outputSizeKb} KB`);
   }
   async generateExtraFiles(metadata) {
+    const start = performance.now();
     const extraFiles = this.config.extraFiles ?? [];
     if (extraFiles.length === 0) {
-      return;
+      return { count: 0, duration: 0, totalSize: 0 };
     }
     let totalSize = 0;
     await Promise.all(
@@ -6513,11 +6672,14 @@ ${propsToDefinitionList(outputs)}`);
         totalSize += stats.size / 1024;
       })
     );
-    console.log(
-      `Generated ${extraFiles.length} extra file(s) (${totalSize.toFixed(1)} KB)`
-    );
+    return {
+      count: extraFiles.length,
+      duration: performance.now() - start,
+      totalSize
+    };
   }
   async generatePerPageExports(pages, processedPages, metadata) {
+    const start = performance.now();
     await mkdir2(dirname(this.config.outputPath), { recursive: true }).catch(
       () => {
       }
@@ -6528,16 +6690,38 @@ ${propsToDefinitionList(outputs)}`);
       processedPages.map(async (processedPage, index) => {
         const page = pages[index];
         const lines = [];
-        if (metadata.length || page.url) {
-          lines.push("---");
-          if (page.url) {
-            lines.push(`url: ${page.url}`);
-          }
-          if (metadata.length) {
-            for (const [key, value] of metadata) {
-              lines.push(`${key}: ${value}`);
+        const frontmatterEntries = [];
+        if (page.url) {
+          frontmatterEntries.push(["url", page.url]);
+        }
+        for (const [key, value] of metadata) {
+          frontmatterEntries.push([key, value]);
+        }
+        if (this.config.frontmatterFields) {
+          if (typeof this.config.frontmatterFields === "function") {
+            const transformed = this.config.frontmatterFields(
+              processedPage.frontmatter,
+              page
+            );
+            for (const [key, value] of Object.entries(transformed)) {
+              if (value !== void 0) {
+                frontmatterEntries.push([key, String(value)]);
+              }
+            }
+          } else {
+            for (const field of this.config.frontmatterFields) {
+              const value = processedPage.frontmatter[field];
+              if (value !== void 0) {
+                frontmatterEntries.push([field, String(value)]);
+              }
             }
           }
+        }
+        if (frontmatterEntries.length > 0) {
+          lines.push("---");
+          for (const [key, value] of frontmatterEntries) {
+            lines.push(`${key}: ${value}`);
+          }
           lines.push("---");
           lines.push("");
         }
@@ -6602,8 +6786,10 @@ ${propsToDefinitionList(outputs)}`);
         totalSize += stats.size / 1024;
       })
     );
-    console.log(`Generated ${count} files(s) in ${this.config.outputPath}`);
-    console.log(`Folder size: ${totalSize.toFixed(1)} KB`);
+    const extraFilesResult = await this.generateExtraFiles(metadata);
+    console.log(
+      `Generated ${count + extraFilesResult.count} files(s) in ${chalk3.magenta.bold(`${Math.round(performance.now() - start + extraFilesResult.duration)}ms`)} at ${chalk3.blue.bold(this.config.outputPath)} - ${(totalSize + extraFilesResult.totalSize).toFixed(1)} KB`
+    );
   }
 };
 async function generate(config2) {
@@ -6618,13 +6804,31 @@ function addGenerateKnowledgeCommand() {
     "--exclude <patterns...>",
     "Glob patterns to exclude (e.g., **/internal/**, guide/drafts/*)",
     []
-  ).option("--base-url <url>", "Base URL for component documentation links").option("--metadata <pairs...>", "metadata key-value pairs").option("--clean", "Clean the output path before generating").option("--include-imports", "Include relative import source files", true).action(async (options) => {
+  ).option("--base-url <url>", "Base URL for component documentation links").option("--metadata <pairs...>", "metadata key-value pairs").option("--clean", "Clean the output path before generating").option("--include-imports", "Include relative import source files", true).option(
+    "-e, --environment <environments>",
+    "Comma-separated list of environments to generate (default: all)"
+  ).action(async (options) => {
     loadEnv();
-    const knowledgeConfig = loadKnowledgeConfigFromEnv({
+    const cliOptions = {
       ...options,
       outputMode: options.outputMode === "per-page" ? "per-page" : "aggregated"
+    };
+    const environmentFilter = options.environment?.split(",").map((e) => e.trim()).filter(Boolean);
+    const configs = loadEnvironmentConfigs({
+      cliOptions,
+      environments: environmentFilter
     });
-    await generate(knowledgeConfig);
+    for (const config2 of configs) {
+      const envLabel = config2.environmentName ? `[${config2.environmentName}] ` : "";
+      console.log(`${envLabel}Generating knowledge to ${config2.outputPath}`);
+      await generate(config2);
+    }
+    if (configs.length > 1) {
+      console.log(
+        `
+Generated knowledge for ${configs.length} environment(s)`
+      );
+    }
   });
 }
 
@@ -6769,7 +6973,10 @@ var Uploader = class {
       }))
     );
     const knowledge = await this.knowledgeApi.getById(this.config.knowledgeId);
-    this.knowledgeFilesCache = (knowledge.files ?? []).map(toKnowledgeFile);
+    const receivedFiles = knowledge.files?.length ? knowledge.files.map(toKnowledgeFile) : await this.filesApi.list().then(
+      (res) => res.filter((file) => file.meta.collection_name === knowledge.id)
+    );
+    this.knowledgeFilesCache = receivedFiles;
     await this.buildHashCache(this.knowledgeFilesCache);
     let skippedCount = 0;
     let successCount = 0;
@@ -6894,9 +7101,56 @@ function addUploadKnowledgeCommand() {
   program.name("upload-knowledge").description("Upload files to OpenWebUI knowledge base").command("upload-knowledge").option("-p, --path <path>", "Path to file or folder relative to script").option(
     "--force",
     "force upload files, even if their contents have not changed"
+  ).option(
+    "-i, --integration <integrations>",
+    "Comma-separated list of integrations to upload to (default: all)"
+  ).option(
+    "-e, --environment <environments>",
+    "Comma-separated list of environments to filter integrations by (default: all)"
   ).action(async (options) => {
     loadEnv();
-    return getUploader(options.path, options.force).uploadKnowledge();
+    const integrationFilter = options.integration?.split(",").map((e) => e.trim()).filter(Boolean);
+    const environmentFilter = options.environment?.split(",").map((e) => e.trim()).filter(Boolean);
+    const integrations = loadOpenWebUiIntegrations({
+      environments: environmentFilter,
+      integrations: integrationFilter
+    });
+    if (integrations.length === 0) {
+      console.log("No integrations configured, using legacy env vars");
+      return getUploader(options.path, options.force).uploadKnowledge();
+    }
+    let successCount = 0;
+    let failureCount = 0;
+    for (const { integration, name, outputPath } of integrations) {
+      console.log(`
+[${name}] Uploading to OpenWebUI...`);
+      try {
+        const resolved = resolveOpenWebUiIntegration(
+          name,
+          integration,
+          outputPath
+        );
+        const uploader = new Uploader({
+          force: options.force,
+          knowledgeFilePath: options.path ?? resolved.outputPath,
+          knowledgeId: resolved.knowledgeId,
+          webUiKey: resolved.apiKey,
+          webUiUrl: resolved.url
+        });
+        await uploader.uploadKnowledge();
+        successCount++;
+        console.log(`[${name}] Upload complete`);
+      } catch (error) {
+        failureCount++;
+        console.error(`[${name}] Upload failed:`, error);
+      }
+    }
+    if (integrations.length > 1) {
+      console.log(
+        `
+Uploaded to ${successCount} integration(s)${failureCount > 0 ? `, ${failureCount} failed` : ""}`
+      );
+    }
   });
   program.command("get-knowledge-files").description("Get files from OpenWebUI knowledge base").option("-p, --path <path>", "Path to file or folder relative to script").action(async (options) => {
     loadEnv();
@@ -6954,7 +7208,7 @@ import { resolve as resolve7 } from "node:path";
 import { dedent } from "@qualcomm-ui/utils/dedent";
 
 // src/react-demo-plugin/demo-plugin-utils.ts
-import chalk3 from "chalk";
+import chalk4 from "chalk";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
 import { dirname as dirname2, join as join4, relative as relative3, resolve as resolve6, sep } from "node:path";
 import * as ts from "typescript";