@qualcomm-ui/mdx-vite 2.14.2 → 2.15.0

package/dist/cli.js

@@ -1815,14 +1815,14 @@ Expecting one of '${allowedValues.join("', '")}'`);
        * @return {Command} `this` command for chaining
        * @private
        */
-      _optionEx(config2, flags, description, fn, defaultValue) {
+      _optionEx(config3, flags, description, fn, defaultValue) {
         if (typeof flags === "object" && flags instanceof Option2) {
           throw new Error(
             "To add an Option object use addOption() instead of option() or requiredOption()"
           );
         }
         const option = this.createOption(flags, description);
-        option.makeOptionMandatory(!!config2.mandatory);
+        option.makeOptionMandatory(!!config3.mandatory);
         if (typeof fn === "function") {
           option.default(defaultValue).argParser(fn);
         } else if (fn instanceof RegExp) {
@@ -2797,9 +2797,9 @@ Expecting one of '${allowedValues.join("', '")}'`);
           this._outputConfiguration.writeErr("\n");
           this.outputHelp({ error: true });
         }
-        const config2 = errorOptions || {};
-        const exitCode = config2.exitCode || 1;
-        const code = config2.code || "commander.error";
+        const config3 = errorOptions || {};
+        const exitCode = config3.exitCode || 1;
+        const code = config3.code || "commander.error";
         this._exit(exitCode, code, message);
       }
       /**
@@ -3501,11 +3501,10 @@ var {
   Help
 } = import_index.default;
 
-// src/docs-plugin/generate-page-map.ts
-import { glob } from "glob";
-import { writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
-import { cwd } from "node:process";
+// src/ai-knowledge/env.ts
+import { config } from "dotenv";
+import { existsSync } from "node:fs";
+import { join as join2, resolve } from "node:path";
 
 // src/docs-plugin/internal/config-loader.ts
 import { cosmiconfigSync } from "cosmiconfig";
@@ -3555,15 +3554,27 @@ var knowledgeExtraFileSchema = implement().with({
   processAsMdx: z2.boolean().optional(),
   title: z2.string().optional()
 });
+var frontmatterConfigSchema = z2.object({
+  exclude: z2.array(z2.string()).optional(),
+  extraFields: z2.record(z2.string(), z2.union([z2.string(), z2.array(z2.string())])).optional(),
+  include: z2.array(z2.string()).optional()
+}).optional();
+var sectionsExportsSchema = implement().with({
+  depths: z2.array(z2.number()).optional(),
+  minContentLength: z2.number().optional(),
+  outputPath: z2.string().optional()
+});
 var knowledgeExportsSchema = implement().with({
   enabled: z2.boolean().optional(),
   exclude: z2.array(z2.string()).optional(),
   extraFiles: z2.array(knowledgeExtraFileSchema).optional(),
+  frontmatter: frontmatterConfigSchema,
   generateBulkZip: z2.boolean().optional(),
   generateManifest: z2.boolean().optional(),
   manifestPath: z2.string().optional(),
   metadata: z2.record(z2.string(), z2.string()).optional(),
   pageTitlePrefix: z2.string().optional(),
+  sections: sectionsExportsSchema.optional(),
   staticPath: z2.string().optional()
 });
 var knowledgeIntegrationSchema = implement().with(
@@ -3573,7 +3584,7 @@ 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(),
+    frontmatter: frontmatterConfigSchema,
     metadata: z2.record(z2.string(), z2.string()).optional(),
     name: z2.string().optional(),
     outputMode: z2.union([z2.literal("per-page"), z2.literal("aggregated")]).optional(),
@@ -3588,7 +3599,7 @@ var knowledgeEnvironmentSchema = implement().with({
   exclude: z2.array(z2.string()).optional(),
   exports: knowledgeExportsSchema.optional(),
   extraFiles: z2.array(knowledgeExtraFileSchema).optional(),
-  frontmatterFields: z2.array(z2.string()).optional(),
+  frontmatter: frontmatterConfigSchema,
   id: z2.string(),
   metadata: z2.record(z2.string(), z2.string()).optional(),
   name: z2.string().optional(),
@@ -3682,8 +3693,8 @@ var ConfigLoader = class {
     }
     return result;
   }
-  resolveConfigFromCosmiconfig(config2) {
-    const parsed = configSchema.safeParse(config2.config);
+  resolveConfigFromCosmiconfig(config3) {
+    const parsed = configSchema.safeParse(config3.config);
     if (!parsed.success) {
       console.dir(parsed.error.issues, { depth: 10 });
       throw new Error("Failed to parse config file.");
@@ -3692,13 +3703,13 @@ var ConfigLoader = class {
     return {
       ...conf,
       appDirectory: conf.appDirectory || "app",
-      filePath: config2.filepath,
+      filePath: config3.filepath,
       pageDirectory: conf.pageDirectory ? removeTrailingSlash(conf.pageDirectory) : "routes"
     };
   }
   loadConfig() {
-    const config2 = this.getCosmiconfig();
-    return this.resolveConfigFromCosmiconfig(config2);
+    const config3 = this.getCosmiconfig();
+    return this.resolveConfigFromCosmiconfig(config3);
   }
 };
 
@@ -4438,6 +4449,7 @@ var remarkRemoveJsx = () => {
   return (tree, _file, done) => {
     remove2(tree, "mdxjsEsm");
     remove2(tree, "mdxJsxFlowElement");
+    remove2(tree, "mdxJsxTextElement");
     done();
   };
 };
@@ -5027,11 +5039,11 @@ function transformRouteMetaArray(meta, routeMetaNav) {
 
 // src/docs-plugin/internal/search-indexer.ts
 var SearchIndexer = class {
-  constructor(config2, logWarnings = true, addons = {}) {
-    this.config = config2;
+  constructor(config3, logWarnings = true, addons = {}) {
+    this.config = config3;
     this.logWarnings = logWarnings;
     this.allowedHeadings = new Set(
-      Array.from(config2?.headings || ["h2", "h3", "h4"])
+      Array.from(config3?.headings || ["h2", "h3", "h4"])
     );
     this.metaJson = transformRouteMetaArray(
       this.config.navConfig ?? [],
@@ -5264,741 +5276,1032 @@ var SearchIndexer = class {
   }
 };
 
-// src/docs-plugin/generate-page-map.ts
-function addGeneratePageMapCommand() {
-  program.command("generate-page-map").description(
-    "Invokes the docs-plugin once to build the site data and writes it to json"
-  ).option(
-    "-c, --config-file <configFile>",
-    "Path to the qui-docs.config.ts config file"
-  ).option(
-    "-r, --routes-dir <routesDir>",
-    "Path to the routes directory",
-    "src/routes"
-  ).option(
-    "-o, --output <output>",
-    "Output path for the site data json",
-    "site-data.json"
-  ).action(async (options) => {
-    try {
-      const configLoader = new ConfigLoader({ configFile: options.configFile });
-      const resolvedConfig = configLoader.loadConfig();
-      const routesDir = fixPath(
-        resolve(resolvedConfig.appDirectory, resolvedConfig.pageDirectory)
-      );
-      const indexer = new SearchIndexer({
-        ...resolvedConfig,
-        srcDir: fixPath(resolve(cwd(), resolvedConfig.appDirectory)),
-        typeDocProps: {}
-      });
-      const files = glob.sync(
-        [`${routesDir}/**/*.mdx`, `${routesDir}/**/*.tsx`],
-        {
-          absolute: true,
-          cwd: cwd()
-        }
-      );
-      indexer.buildIndex(files, true);
-      await writeFile(
-        resolve(cwd(), options.output),
-        JSON.stringify(indexer.pageMap, null, 2),
-        "utf-8"
-      );
-    } catch (error) {
-      console.error(
-        "Generate Site Data Error:",
-        error instanceof Error ? error.message : String(error)
-      );
-      process.exit(1);
-    }
-  });
+// src/ai-knowledge/env.ts
+function loadEnv() {
+  const options = program.optsWithGlobals();
+  if (options.env) {
+    config({ path: options.env, quiet: true });
+  } else {
+    config({ quiet: true });
+  }
 }
-
-// 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";
-
-// src/open-web-ui-knowledge/api.ts
-function isErrorResponse(response) {
-  return typeof response === "object" && response !== null && "detail" in response;
+function getConfigFromEnv() {
+  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");
+  }
+  return {
+    knowledgeId,
+    webUiKey: openWebUiKey,
+    webUiUrl: openWebUiUrl
+  };
 }
-var FilesApi = class {
-  config;
-  constructor(config2) {
-    this.config = config2;
+function parseCliMetadata(cliMetadata) {
+  if (!cliMetadata?.length) {
+    return void 0;
   }
-  get headers() {
-    return {
-      Authorization: `Bearer ${this.config.apiKey}`
-    };
+  return Object.fromEntries(cliMetadata.map((entry) => entry.split("=")));
+}
+function loadKnowledgeConfigFromEnv(options) {
+  const configLoader = new ConfigLoader({});
+  const resolvedConfig = configLoader.loadConfig();
+  const fileConfig = resolvedConfig.knowledge?.global;
+  const exclude = (options.exclude?.length ? options.exclude : void 0) ?? fileConfig?.exclude ?? (process.env.FILE_EXCLUDE_PATTERN ?? "").split(",").filter(Boolean);
+  const outputPath = options.outputPath ?? fileConfig?.outputPath ?? process.env.KNOWLEDGE_OUTPUT_PATH;
+  if (!outputPath) {
+    throw new Error("Missing required outputPath");
   }
-  get jsonHeaders() {
-    return {
-      ...this.headers,
-      "Content-Type": "application/json"
-    };
+  const routeDir = join2(
+    resolvedConfig.appDirectory,
+    resolvedConfig.pageDirectory
+  );
+  if (!existsSync(resolve(routeDir))) {
+    throw new Error(`Route directory ${routeDir} does not exist`);
   }
-  async handleResponse(response) {
-    const data = await response.json();
-    if (isErrorResponse(data)) {
-      throw new Error(data.detail);
-    }
-    return data;
+  const cliMetadata = parseCliMetadata(options.metadata);
+  const mergedMetadata = fileConfig?.metadata || cliMetadata ? { ...fileConfig?.metadata, ...cliMetadata } : void 0;
+  return {
+    ...fileConfig,
+    ...options,
+    baseUrl: options.baseUrl ?? fileConfig?.baseUrl ?? process.env.DOCS_SITE_BASE_URL,
+    docPropsPath: resolvedConfig.typeDocProps,
+    exclude,
+    extraFiles: fileConfig?.extraFiles,
+    manifestOutputPath: outputPath,
+    metadata: mergedMetadata,
+    outputPath,
+    pageTitlePrefix: options.pageTitlePrefix ?? fileConfig?.pageTitlePrefix ?? process.env.PAGE_TITLE_PREFIX,
+    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(resolve(routeDir))) {
+    throw new Error(`Route directory ${routeDir} does not exist`);
   }
-  async upload(file, filename, options) {
-    const formData = new FormData();
-    let blob;
-    if (file instanceof Blob) {
-      blob = file;
-    } else if (file instanceof ArrayBuffer) {
-      blob = new Blob([file]);
-    } else {
-      const copy = new Uint8Array(file).buffer;
-      blob = new Blob([copy]);
-    }
-    formData.append("file", blob, filename);
-    if (options?.metadata) {
-      formData.append("metadata", JSON.stringify(options.metadata));
+  if (!environments || environments.length === 0 || options.cliOptions?.outputPath) {
+    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,
+      manifestOutputPath: merged.outputPath,
+      metadata: mergedMetadata,
+      outputMode: cliOpts?.outputMode ?? merged.outputMode ?? "per-page",
+      outputPath: merged.outputPath,
+      pageTitlePrefix: cliOpts?.pageTitlePrefix ?? merged.pageTitlePrefix ?? process.env.PAGE_TITLE_PREFIX,
+      routeDir
+    };
+  });
+}
+
+// src/ai-knowledge/generator/knowledge-generator.ts
+import AdmZip from "adm-zip";
+import chalk3 from "chalk";
+import { minimatch } from "minimatch";
+import { mkdir, readdir, readFile as readFile4, rm, stat, writeFile } from "node:fs/promises";
+import { basename as basename2, dirname as dirname3, join as join6, relative as relative2, resolve as resolve4 } from "node:path";
+import remarkFrontmatter2 from "remark-frontmatter";
+import remarkMdx3 from "remark-mdx";
+import remarkParse4 from "remark-parse";
+import remarkParseFrontmatter2 from "remark-parse-frontmatter";
+import remarkStringify4 from "remark-stringify";
+import { unified as unified5 } from "unified";
+import { visit as visit11 } from "unist-util-visit";
+import { kebabCase as kebabCase3 } from "@qualcomm-ui/utils/change-case";
+
+// src/docs-plugin/remark/remark-extract-meta.ts
+import { SKIP, visit as visit5 } from "unist-util-visit";
+function parseValue(value) {
+  const trimmed = value.trim();
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    const inner = trimmed.slice(1, -1);
+    return inner.split(",").map((item) => item.trim()).filter(Boolean);
+  }
+  return trimmed;
+}
+function parseMetaContent(content) {
+  const result = {};
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed === ":::") {
+      continue;
     }
-    const params = new URLSearchParams();
-    if (options?.process !== void 0) {
-      params.set("process", String(options.process));
+    const colonIndex = trimmed.indexOf(":");
+    if (colonIndex === -1) {
+      continue;
     }
-    if (options?.processInBackground !== void 0) {
-      params.set("process_in_background", String(options.processInBackground));
+    const key = trimmed.slice(0, colonIndex).trim();
+    const value = trimmed.slice(colonIndex + 1).trim();
+    if (key && value) {
+      result[key] = parseValue(value);
     }
-    const url = `${this.config.baseUrl}/api/v1/files/${params.toString() ? `?${params}` : ""}`;
-    const response = await fetch(url, {
-      body: formData,
-      headers: this.headers,
-      method: "POST"
-    });
-    return this.handleResponse(response);
   }
-  async list(includeContent = true) {
-    const params = new URLSearchParams({ content: String(includeContent) });
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/files/?${params}`,
-      {
-        headers: this.headers
+  return result;
+}
+var remarkExtractMeta = (metadata = {}) => {
+  return (tree) => {
+    const nodesToRemove = [];
+    visit5(tree, "paragraph", (node, index, parent) => {
+      if (!parent || index === void 0) {
+        return;
+      }
+      const firstChild = node.children[0];
+      if (firstChild?.type !== "text") {
+        return;
+      }
+      const text = firstChild.value;
+      const openMatch = text.match(/^:::\s*meta\s*/);
+      if (!openMatch) {
+        return;
+      }
+      if (text.includes(":::") && text.lastIndexOf(":::") > openMatch[0].length) {
+        const afterOpen = text.slice(openMatch[0].length);
+        const closeIndex = afterOpen.lastIndexOf(":::");
+        const content = afterOpen.slice(0, closeIndex);
+        const parsed = parseMetaContent(content);
+        Object.assign(metadata, parsed);
+        nodesToRemove.push({ index, parent });
+        return SKIP;
+      }
+      let fullText = text;
+      for (let i = 1; i < node.children.length; i++) {
+        const child = node.children[i];
+        if (child.type === "text") {
+          fullText += child.value;
+        }
+      }
+      const afterOpenFull = fullText.slice(openMatch[0].length);
+      const closeIndexFull = afterOpenFull.lastIndexOf(":::");
+      if (closeIndexFull !== -1) {
+        const content = afterOpenFull.slice(0, closeIndexFull);
+        const parsed = parseMetaContent(content);
+        Object.assign(metadata, parsed);
+        nodesToRemove.push({ index, parent });
+        return SKIP;
       }
-    );
-    return this.handleResponse(response);
-  }
-  async search(pattern, includeContent = true) {
-    const params = new URLSearchParams({
-      content: String(includeContent),
-      filename: pattern
     });
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/files/search?${params}`,
-      { headers: this.headers }
-    );
-    if (response.status === 404) {
-      return [];
+    for (let i = nodesToRemove.length - 1; i >= 0; i--) {
+      const { index, parent } = nodesToRemove[i];
+      parent.children.splice(index, 1);
     }
-    return this.handleResponse(response);
+  };
+};
+
+// src/ai-knowledge/generator/config.ts
+var currentConfig = null;
+function setConfig(config3) {
+  currentConfig = config3;
+}
+function getConfig() {
+  if (!currentConfig) {
+    throw new Error("Config not initialized");
   }
-  async deleteAll() {
-    const response = await fetch(`${this.config.baseUrl}/api/v1/files/all`, {
-      headers: this.headers,
-      method: "DELETE"
-    });
-    return this.handleResponse(response);
-  }
-  async getById(id) {
-    const response = await fetch(`${this.config.baseUrl}/api/v1/files/${id}`, {
-      headers: this.headers
-    });
-    return this.handleResponse(response);
+  return currentConfig;
+}
+
+// src/ai-knowledge/generator/demo-plugin.ts
+import { readFile as readFile2 } from "node:fs/promises";
+import { basename, extname, join as join4 } from "node:path";
+import { visit as visit6 } from "unist-util-visit";
+import { kebabCase } from "@qualcomm-ui/utils/change-case";
+
+// src/ai-knowledge/generator/utils.ts
+import { createHash as createHash2 } from "node:crypto";
+import { access, readFile } from "node:fs/promises";
+import { dirname, join as join3, resolve as resolve2 } from "node:path";
+import ts from "typescript";
+async function exists(dirPath) {
+  return access(dirPath).then(() => true).catch(() => false);
+}
+function computeMd5(content) {
+  return createHash2("md5").update(content).digest("hex");
+}
+function isPreviewLine(trimmedLine) {
+  return trimmedLine === "// preview" || /^\{\s*\/\*\s*preview\s*\*\/\s*\}$/.test(trimmedLine) || /^<!--\s*preview\s*-->$/.test(trimmedLine);
+}
+function removePreviewLines(code) {
+  return code.split("\n").filter((line) => !isPreviewLine(line.trim())).join("\n");
+}
+function getIntroLines(projectName, description) {
+  const lines = [];
+  if (projectName) {
+    lines.push(`# ${projectName}`);
   }
-  async getProcessStatus(id) {
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/files/${id}/process/status`,
-      { headers: this.headers }
-    );
-    return this.handleResponse(response);
+  if (description) {
+    lines.push("");
+    lines.push(`> ${description}`);
   }
-  async waitForProcessing(id, options) {
-    const maxAttempts = options?.maxAttempts ?? 120;
-    const intervalMs = options?.intervalMs ?? 1e3;
-    for (let i = 0; i < maxAttempts; i++) {
-      const status = await this.getProcessStatus(id);
-      if (status.status === "completed" || status.status === "failed") {
-        return status;
+  return lines.join("\n");
+}
+function extractRelativeImports(content) {
+  const sourceFile = ts.createSourceFile(
+    "temp.ts",
+    content,
+    ts.ScriptTarget.Latest,
+    false,
+    ts.ScriptKind.TSX
+  );
+  const imports = [];
+  for (const statement of sourceFile.statements) {
+    if (ts.isImportDeclaration(statement) && ts.isStringLiteral(statement.moduleSpecifier)) {
+      const path = statement.moduleSpecifier.text;
+      if (path.startsWith(".")) {
+        imports.push(path);
       }
-      await new Promise((resolve8) => setTimeout(resolve8, intervalMs));
     }
-    throw new Error(`File processing timed out after ${maxAttempts} attempts`);
   }
-  async getDataContent(id) {
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/files/${id}/data/content`,
-      { headers: this.headers }
-    );
-    return this.handleResponse(response);
+  return imports;
+}
+async function resolveModulePath(importPath, fromFile) {
+  const fromDir = dirname(fromFile);
+  const baseResolved = resolve2(fromDir, importPath);
+  const extensions = [".ts", ".tsx", ".js", ".jsx", ""];
+  for (const ext of extensions) {
+    const fullPath = baseResolved + ext;
+    if (await exists(fullPath)) {
+      return fullPath;
+    }
   }
-  async updateDataContent(id, content) {
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/files/${id}/data/content/update`,
-      {
-        body: JSON.stringify({ content }),
-        headers: this.jsonHeaders,
-        method: "POST"
+  if (await exists(baseResolved)) {
+    const indexPath = join3(baseResolved, "index.ts");
+    if (await exists(indexPath)) {
+      return indexPath;
+    }
+  }
+  return null;
+}
+function extractMetadata(metadata) {
+  return Object.entries(metadata ?? {});
+}
+
+// src/ai-knowledge/generator/demo-plugin.ts
+async function collectDemoImports(demoCode, demoFilePath, visited = /* @__PURE__ */ new Set()) {
+  const modules = [];
+  const relativeImports = extractRelativeImports(demoCode);
+  for (const importPath of relativeImports) {
+    const resolvedPath = await resolveModulePath(importPath, demoFilePath);
+    if (!resolvedPath || visited.has(resolvedPath)) {
+      continue;
+    }
+    visited.add(resolvedPath);
+    try {
+      const importContent = await readFile2(resolvedPath, "utf-8");
+      modules.push({
+        content: importContent,
+        path: resolvedPath
+      });
+      const nestedModules = await collectDemoImports(
+        importContent,
+        resolvedPath,
+        visited
+      );
+      modules.push(...nestedModules);
+    } catch {
+      if (getConfig().verbose) {
+        console.log(`  Could not read import: ${resolvedPath}`);
       }
-    );
-    return this.handleResponse(response);
+    }
   }
-  async getContent(id, asAttachment = false) {
-    const params = new URLSearchParams({ attachment: String(asAttachment) });
-    return fetch(
-      `${this.config.baseUrl}/api/v1/files/${id}/content?${params}`,
-      {
-        headers: this.headers
+  return modules;
+}
+function formatDemos(demosFolder) {
+  return () => async (tree) => {
+    const promises = [];
+    visit6(
+      tree,
+      "mdxJsxFlowElement",
+      (node, index, parent) => {
+        if (!node?.name || !["QdsDemo", "CodeDemo", "Demo"].includes(node.name)) {
+          return;
+        }
+        const nameAttr = node.attributes?.find(
+          (attr) => attr.type === "mdxJsxAttribute" && attr.name === "name"
+        );
+        const nodeAttr = node.attributes?.find(
+          (attr) => attr.type === "mdxJsxAttribute" && attr.name === "node"
+        );
+        let demoName;
+        if (nameAttr && typeof nameAttr.value === "string") {
+          demoName = nameAttr.value;
+        } else if (nodeAttr?.value && typeof nodeAttr.value !== "string") {
+          const estree = nodeAttr.value.data?.estree;
+          if (estree?.body?.[0]?.type === "ExpressionStatement") {
+            const expression = estree.body[0].expression;
+            if (expression.type === "MemberExpression" && expression.object.type === "Identifier" && expression.object.name === "Demo" && expression.property.type === "Identifier") {
+              demoName = expression.property.name;
+            }
+          }
+        }
+        if (!demoName) {
+          if (parent && index !== void 0) {
+            parent.children.splice(index, 1);
+          }
+          return;
+        }
+        promises.push(
+          (async () => {
+            const kebabName = kebabCase(demoName);
+            let filePath = `${kebabName}.tsx`;
+            if (!demosFolder) {
+              if (getConfig().verbose) {
+                console.log(`  No demos folder for ${demoName}`);
+              }
+              if (parent && index !== void 0) {
+                parent.children.splice(index, 1);
+              }
+              return;
+            }
+            let demoFilePath = join4(demosFolder, filePath);
+            let isAngularDemo = false;
+            if (!await exists(demoFilePath)) {
+              demoFilePath = join4(demosFolder, `${kebabName}.ts`);
+              if (await exists(demoFilePath)) {
+                isAngularDemo = true;
+                filePath = `${kebabCase(demoName).replace("-component", ".component")}.ts`;
+                demoFilePath = join4(demosFolder, filePath);
+              } else {
+                console.log(`  Demo not found ${demoName}`);
+                if (parent && index !== void 0) {
+                  parent.children.splice(index, 1);
+                }
+                return;
+              }
+            }
+            try {
+              const demoCode = await readFile2(demoFilePath, "utf-8");
+              const cleanedCode = removePreviewLines(demoCode);
+              if (getConfig().verbose) {
+                console.log(`  Replaced demo ${demoName} with source code`);
+              }
+              const demoCodeBlock = {
+                lang: isAngularDemo ? "angular-ts" : "tsx",
+                meta: null,
+                type: "code",
+                value: cleanedCode
+              };
+              const importedModules = await collectDemoImports(
+                demoCode,
+                demoFilePath
+              );
+              if (importedModules.length === 0 || !parent || index === void 0) {
+                Object.assign(node, demoCodeBlock);
+              } else {
+                const nodesToInsert = [demoCodeBlock];
+                for (const importedModule of importedModules) {
+                  const ext = extname(importedModule.path).slice(1);
+                  const filename = basename(importedModule.path);
+                  nodesToInsert.push({
+                    lang: ext,
+                    meta: `title="${filename}"`,
+                    type: "code",
+                    value: importedModule.content
+                  });
+                }
+                parent.children.splice(index, 1, ...nodesToInsert);
+                if (getConfig().verbose) {
+                  console.log(
+                    `  Added ${importedModules.length} imported file(s) after demo`
+                  );
+                }
+              }
+            } catch (error) {
+              if (getConfig().verbose) {
+                console.log(`Error reading demo ${demoName}`, error);
+              }
+              if (parent && index !== void 0) {
+                parent.children.splice(index, 1);
+              }
+            }
+          })()
+        );
       }
     );
+    await Promise.all(promises);
+  };
+}
+
+// src/ai-knowledge/generator/doc-props-plugin.ts
+import { readFile as readFile3 } from "node:fs/promises";
+import { dirname as dirname2, join as join5, resolve as resolve3 } from "node:path";
+import { visit as visit7 } from "unist-util-visit";
+function extractBestType(propInfo) {
+  const type = propInfo.resolvedType?.prettyType || propInfo.type;
+  return cleanType(type.startsWith("| ") ? type.substring(2) : type);
+}
+function extractRequired(propInfo, isPartial) {
+  return Boolean(propInfo.resolvedType?.required && !isPartial);
+}
+function cleanType(type) {
+  return type.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
+}
+function cleanDefaultValue(defaultValue) {
+  return defaultValue.replace(/^\n+/, "").replace(/\n+$/, "").trim();
+}
+function escapeText(value) {
+  return value.replace(/\n/g, " ");
+}
+function propsToDefinitionList(props) {
+  if (props.length === 0) {
+    return "";
   }
-  async getContentAsText(id) {
-    const response = await this.getContent(id);
-    if (!response.ok) {
-      const error = await response.json();
-      throw new Error(error.detail || "Failed to get file content");
+  return props.map((prop) => {
+    const parts = [`- **${prop.name}** (\`${escapeText(prop.type)}\``];
+    if (prop.defaultValue) {
+      parts.push(`, default: \`${escapeText(prop.defaultValue)}\``);
     }
-    return response.text();
-  }
-  async delete(id) {
-    const response = await fetch(`${this.config.baseUrl}/api/v1/files/${id}`, {
-      headers: this.headers,
-      method: "DELETE"
-    });
-    return this.handleResponse(response);
-  }
-};
-var KnowledgeApi = class {
-  config;
-  constructor(config2) {
-    this.config = config2;
-  }
-  get headers() {
-    return {
-      Authorization: `Bearer ${this.config.apiKey}`
-    };
-  }
-  get jsonHeaders() {
-    return {
-      ...this.headers,
-      "Content-Type": "application/json"
-    };
-  }
-  async handleResponse(response) {
-    const data = await response.json();
-    if (isErrorResponse(data)) {
-      throw new Error(data.detail);
+    if (prop.required) {
+      parts.push(", required");
     }
-    return data;
-  }
-  async list() {
-    const response = await fetch(`${this.config.baseUrl}/api/v1/knowledge/`, {
-      headers: this.headers
-    });
-    return this.handleResponse(response);
-  }
-  async listWritable() {
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/knowledge/list`,
-      {
-        headers: this.headers
+    parts.push(")");
+    if (prop.description) {
+      parts.push(` - ${escapeText(prop.description)}`);
+    }
+    return parts.join("");
+  }).join("\n");
+}
+var PropFormatter = class {
+  docProps = null;
+  async loadDocProps() {
+    if (this.docProps) {
+      return this.docProps;
+    }
+    const config3 = getConfig();
+    const resolvedDocPropsPath = config3.docPropsPath ? await exists(config3.docPropsPath) ? config3.docPropsPath : resolve3(process.cwd(), config3.docPropsPath) : join5(dirname2(config3.routeDir), "doc-props.json");
+    if (!await exists(resolvedDocPropsPath)) {
+      if (config3.verbose) {
+        console.log(`Doc props file not found at: ${resolvedDocPropsPath}`);
       }
-    );
-    return this.handleResponse(response);
-  }
-  async create(form) {
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/knowledge/create`,
-      {
-        body: JSON.stringify(form),
-        headers: this.jsonHeaders,
-        method: "POST"
+      return null;
+    }
+    try {
+      const content = await readFile3(resolvedDocPropsPath, "utf-8");
+      const docProps = JSON.parse(content);
+      if (config3.verbose) {
+        console.log(`Loaded doc props from: ${resolvedDocPropsPath}`);
+        console.log(
+          `Found ${Object.keys(docProps.props).length} component types`
+        );
       }
-    );
-    return this.handleResponse(response);
-  }
-  async reindex() {
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/knowledge/reindex`,
-      {
-        headers: this.jsonHeaders,
-        method: "POST"
+      this.docProps = docProps;
+      return docProps;
+    } catch (error) {
+      if (config3.verbose) {
+        console.log("Error loading doc props", error);
       }
-    );
-    return this.handleResponse(response);
+      return null;
+    }
   }
-  async getById(id) {
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/knowledge/${id}`,
-      {
-        headers: this.headers
-      }
-    );
-    return this.handleResponse(response);
-  }
-  async update(id, form) {
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/knowledge/${id}/update`,
-      {
-        body: JSON.stringify(form),
-        headers: this.jsonHeaders,
-        method: "POST"
+  formatCommentParts(parts) {
+    return parts.map((part) => {
+      switch (part.kind) {
+        case "text":
+          return part.text;
+        case "code":
+          const codeText = part.text.replace(/```\w*\n?/g, "").replace(/\n?```/g, "").trim();
+          if (codeText.includes("\n")) {
+            return `\`\`\`
+${codeText}
+\`\`\``;
+          } else {
+            return codeText;
+          }
+        default:
+          if (getConfig().outputMode === "per-page" && "tag" in part && part.tag === "@link" && typeof part.target === "string") {
+            if (part.text === "Learn more") {
+              return "";
+            }
+          }
+          return part.text;
       }
-    );
-    return this.handleResponse(response);
+    }).join("").replace(/\n/g, " ").replace(/\s+/g, " ").trim();
   }
-  async addFile(knowledgeId, fileId) {
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/knowledge/${knowledgeId}/file/add`,
-      {
-        body: JSON.stringify({ file_id: fileId }),
-        headers: this.jsonHeaders,
-        method: "POST"
+  formatComment(comment) {
+    if (!comment) {
+      return "";
+    }
+    const parts = [];
+    if (comment.summary && comment.summary.length > 0) {
+      const summaryText = this.formatCommentParts(comment.summary);
+      if (summaryText.trim()) {
+        parts.push(summaryText.trim());
       }
-    );
-    return this.handleResponse(response);
-  }
-  async updateFile(knowledgeId, fileId) {
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/knowledge/${knowledgeId}/file/update`,
-      {
-        body: JSON.stringify({ file_id: fileId }),
-        headers: this.jsonHeaders,
-        method: "POST"
+    }
+    if (comment.blockTags && comment.blockTags.length > 0) {
+      for (const blockTag of comment.blockTags) {
+        const tagContent = this.formatCommentParts(blockTag.content);
+        if (tagContent.trim()) {
+          const tagName = blockTag.tag.replace("@", "");
+          if (tagName === "default" || tagName === "defaultValue") {
+            continue;
+          }
+          if (tagName === "example") {
+            parts.push(`**Example:**
+\`\`\`
+${tagContent.trim()}
+\`\`\``);
+          } else {
+            parts.push(`**${tagName}:** ${tagContent.trim()}`);
+          }
+        }
       }
-    );
-    return this.handleResponse(response);
+    }
+    return parts.join("\n\n");
   }
-  async removeFile(knowledgeId, fileId, deleteFile = true) {
-    const params = new URLSearchParams({ delete_file: String(deleteFile) });
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/knowledge/${knowledgeId}/file/remove?${params}`,
-      {
-        body: JSON.stringify({ file_id: fileId }),
-        headers: this.jsonHeaders,
-        method: "POST"
-      }
-    );
-    return this.handleResponse(response);
+  extractProps(props, isPartial) {
+    const propsInfo = [];
+    if (props.props?.length) {
+      propsInfo.push(
+        ...props.props.map((prop) => this.convertPropInfo(prop, isPartial))
+      );
+    }
+    if (props.input?.length) {
+      propsInfo.push(
+        ...props.input.map(
+          (prop) => this.convertPropInfo(prop, isPartial, "input")
+        )
+      );
+    }
+    if (props.output?.length) {
+      propsInfo.push(
+        ...props.output.map(
+          (prop) => this.convertPropInfo(prop, isPartial, "output")
+        )
+      );
+    }
+    return propsInfo;
   }
-  async delete(id) {
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/knowledge/${id}/delete`,
-      {
-        headers: this.headers,
-        method: "DELETE"
-      }
-    );
-    return this.handleResponse(response);
+  convertPropInfo(propInfo, isPartial, propType = void 0) {
+    return {
+      name: propInfo.name,
+      type: extractBestType(propInfo),
+      ...propInfo.defaultValue && {
+        defaultValue: cleanDefaultValue(propInfo.defaultValue)
+      },
+      description: this.formatComment(propInfo.comment || null),
+      propType,
+      required: extractRequired(propInfo, isPartial) || void 0
+    };
   }
-  async reset(id) {
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/knowledge/${id}/reset`,
-      {
-        headers: this.jsonHeaders,
-        method: "POST"
-      }
-    );
-    return this.handleResponse(response);
+  /**
+   * Creates a remark plugin that replaces TypeDocProps JSX elements with
+   * Markdown tables containing component prop documentation.
+   */
+  formatTypeDocProps() {
+    return () => (tree, _file, done) => {
+      visit7(
+        tree,
+        "mdxJsxFlowElement",
+        (node, index, parent) => {
+          if (node?.name !== "TypeDocProps") {
+            return;
+          }
+          const nameAttr = node.attributes?.find(
+            (attr) => attr.type === "mdxJsxAttribute" && attr.name === "name"
+          );
+          const isPartial = node.attributes?.some(
+            (attr) => attr.type === "mdxJsxAttribute" && attr.name === "partial"
+          );
+          if (!this.docProps || !nameAttr) {
+            if (parent && index !== void 0) {
+              parent.children.splice(index, 1);
+            }
+            return;
+          }
+          const propsNames = extractNamesFromAttribute(nameAttr);
+          if (propsNames.length === 0) {
+            if (parent && index !== void 0) {
+              parent.children.splice(index, 1);
+            }
+            return;
+          }
+          const propsName = propsNames[0];
+          const componentProps = this.docProps.props[propsName];
+          if (!componentProps) {
+            if (getConfig().verbose) {
+              console.log(`  TypeDocProps not found: ${propsName}`);
+            }
+            if (parent && index !== void 0) {
+              parent.children.splice(index, 1);
+            }
+            return;
+          }
+          const propsDoc = this.extractProps(componentProps, Boolean(isPartial));
+          if (getConfig().verbose) {
+            console.log(
+              `  Replaced TypeDocProps ${propsName} with API documentation`
+            );
+          }
+          const regularProps = propsDoc.filter((p) => p.propType === void 0);
+          const inputs = propsDoc.filter((p) => p.propType === "input");
+          const outputs = propsDoc.filter((p) => p.propType === "output");
+          const sections = [];
+          if (regularProps.length > 0) {
+            sections.push(propsToDefinitionList(regularProps));
+          }
+          if (inputs.length > 0) {
+            sections.push(`**Inputs**
+
+${propsToDefinitionList(inputs)}`);
+          }
+          if (outputs.length > 0) {
+            sections.push(`**Outputs**
+
+${propsToDefinitionList(outputs)}`);
+          }
+          const markdownContent = sections.join("\n\n");
+          if (!markdownContent) {
+            if (parent && index !== void 0) {
+              parent.children.splice(index, 1);
+            }
+            return;
+          }
+          const propNames = propsDoc.map((p) => p.name);
+          Object.assign(node, {
+            data: { typeDocProps: { name: propsName, props: propNames } },
+            lang: null,
+            meta: null,
+            type: "code",
+            value: markdownContent
+          });
+        }
+      );
+      done();
+    };
   }
-  async addFilesBatch(knowledgeId, fileIds) {
-    const response = await fetch(
-      `${this.config.baseUrl}/api/v1/knowledge/${knowledgeId}/files/batch/add`,
-      {
-        body: JSON.stringify(fileIds.map((file_id) => ({ file_id }))),
-        headers: this.jsonHeaders,
-        method: "POST"
+};
+
+// src/ai-knowledge/generator/npm-install-tabs-plugin.ts
+import { visit as visit8 } from "unist-util-visit";
+var formatNpmInstallTabs = () => {
+  return (tree, _file, done) => {
+    visit8(
+      tree,
+      "mdxJsxFlowElement",
+      (node, index, parent) => {
+        if (node?.name === "NpmInstallTabs") {
+          const packages = node.attributes?.find(
+            (attr) => attr.type === "mdxJsxAttribute" && attr.name === "packages"
+          );
+          const packageNames = packages ? extractNamesFromAttribute(packages) : [];
+          if (packageNames.length === 0) {
+            if (parent && index !== void 0) {
+              parent.children.splice(index, 1);
+            }
+            return;
+          }
+          Object.assign(node, {
+            lang: "shell",
+            meta: null,
+            type: "code",
+            value: `npm install ${packageNames.join(" ")}`
+          });
+        }
       }
     );
-    return this.handleResponse(response);
-  }
+    done();
+  };
 };
 
-// src/open-web-ui-knowledge/common.ts
-import { config } from "dotenv";
-function loadEnv() {
-  const options = program.optsWithGlobals();
-  if (options.env) {
-    config({ path: options.env });
-  } else {
-    config();
-  }
-}
-function getConfigFromEnv() {
-  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");
+// src/ai-knowledge/generator/qds-theme-plugin.ts
+import { visit as visit9 } from "unist-util-visit";
+function themeDataToJson(data, cssPropertyName) {
+  if (!data || typeof data !== "object") {
+    return "";
   }
-  return {
-    knowledgeId,
-    webUiKey: openWebUiKey,
-    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 (cssPropertyName) {
+    return JSON.stringify({ cssProperty: cssPropertyName, data }, null, 2);
   }
-  if (!apiKey) {
-    throw new Error(
-      `Missing OPEN_WEB_UI_API_KEY for integration "${integrationName}" (env file: ${envFilePath})`
-    );
+  return JSON.stringify(data, null, 2);
+}
+function getPath(obj, path) {
+  return path.split(".").reduce(
+    (acc, key) => acc && typeof acc === "object" ? acc[key] : void 0,
+    obj
+  );
+}
+function getAttrExpression(node, name) {
+  const attr = node.attributes?.find(
+    (a) => a.type === "mdxJsxAttribute" && a.name === name
+  );
+  if (!attr?.value) {
+    return null;
   }
-  if (!knowledgeId) {
-    throw new Error(
-      `Missing OPEN_WEB_UI_KNOWLEDGE_ID for integration "${integrationName}" (env file: ${envFilePath})`
-    );
+  if (typeof attr.value === "string") {
+    return attr.value;
+  } else if (typeof attr.value === "object" && "value" in attr.value) {
+    return attr.value.value;
   }
-  return { apiKey, knowledgeId, url };
+  return null;
 }
-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
+async function formatThemeNodes() {
+  let themes = null;
+  try {
+    themes = await import("@qualcomm-ui/tailwind-plugin/theme");
+  } catch {
+    return () => {
+    };
+  }
+  const handlers = {
+    ColorTable: (node) => {
+      const path = getAttrExpression(node, "data");
+      return path && getPath(themes, path);
+    },
+    FontTable: (node) => {
+      const path = getAttrExpression(node, "data");
+      return path && getPath(themes, path);
+    },
+    SpacingTable: (node) => {
+      const path = getAttrExpression(node, "data");
+      return path && getPath(themes, path);
+    },
+    ThemePropertyTable: (node) => {
+      const path = getAttrExpression(node, "data");
+      const property = getAttrExpression(node, "cssProperty");
+      const data = path && getPath(themes, path);
+      return path && property ? { cssPropertyName: property, data } : void 0;
+    }
   };
-}
-
-// 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").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 };
-    const knowledgeApi = new KnowledgeApi(apiConfig);
-    const filesApi = new FilesApi(apiConfig);
-    const knowledge = await knowledgeApi.getById(config2.knowledgeId);
-    for (const file of knowledge.files ?? []) {
-      const fileName = file.meta?.name;
-      if (!fileName) {
-        continue;
+  return () => (tree, _file, done) => {
+    visit9(tree, "mdxJsxFlowElement", (node) => {
+      const handler = node.name && handlers[node.name];
+      if (!handler) {
+        return;
       }
-      try {
-        const content = await filesApi.getDataContent(file.id);
-        if (content?.content) {
-          await writeFile2(
-            resolve2(opts.outputDir, fileName),
-            content.content,
-            "utf-8"
-          );
-        }
-      } catch {
-        console.warn(`Failed to download ${fileName}`);
+      const data = handler(node);
+      if (!data) {
+        console.warn(`No theme data for ${node.name}`);
+        return;
       }
-    }
-  });
+      let markdownTable;
+      if (typeof data === "object" && data !== null && "cssPropertyName" in data && "data" in data) {
+        const { cssPropertyName, data: themeData } = data;
+        markdownTable = themeDataToJson(themeData, cssPropertyName);
+      } else {
+        markdownTable = themeDataToJson(data);
+      }
+      if (!markdownTable) {
+        return;
+      }
+      Object.assign(node, {
+        lang: "json",
+        meta: null,
+        type: "code",
+        value: markdownTable
+      });
+    });
+    done();
+  };
 }
 
-// src/open-web-ui-knowledge/generate-knowledge.ts
-import AdmZip from "adm-zip";
-import chalk3 from "chalk";
-import { minimatch } from "minimatch";
-import { createHash as createHash2 } from "node:crypto";
-import {
-  access,
-  mkdir as mkdir2,
-  readdir,
-  readFile,
-  rm,
-  stat,
-  writeFile as writeFile3
-} from "node:fs/promises";
-import { basename, dirname, extname, join as join3, relative as relative2, resolve as resolve4 } from "node:path";
-import remarkFrontmatter2 from "remark-frontmatter";
-import remarkMdx3 from "remark-mdx";
-import remarkParse4 from "remark-parse";
-import remarkParseFrontmatter2 from "remark-parse-frontmatter";
+// src/ai-knowledge/generator/section-extractor.ts
 import remarkStringify3 from "remark-stringify";
 import { unified as unified4 } from "unified";
-import { visit as visit5 } from "unist-util-visit";
-import { kebabCase } from "@qualcomm-ui/utils/change-case";
-
-// src/open-web-ui-knowledge/load-config-from-env.ts
-import { existsSync } from "node:fs";
-import { join as join2, resolve as resolve3 } from "node:path";
-function parseCliMetadata(cliMetadata) {
-  if (!cliMetadata?.length) {
-    return void 0;
+import { visit as visit10 } from "unist-util-visit";
+import { kebabCase as kebabCase2 } from "@qualcomm-ui/utils/change-case";
+var SectionExtractor = class {
+  depths;
+  minContentLength;
+  constructor(options) {
+    const defaultDepths = [1, 2, 3, 4];
+    this.depths = new Set(options?.depths ?? defaultDepths);
+    this.minContentLength = options?.minContentLength ?? 0;
   }
-  return Object.fromEntries(cliMetadata.map((entry) => entry.split("=")));
-}
-function loadKnowledgeConfigFromEnv(options) {
-  const configLoader = new ConfigLoader({});
-  const resolvedConfig = configLoader.loadConfig();
-  const fileConfig = resolvedConfig.knowledge?.global;
-  const exclude = (options.exclude?.length ? options.exclude : void 0) ?? fileConfig?.exclude ?? (process.env.FILE_EXCLUDE_PATTERN ?? "").split(",").filter(Boolean);
-  const outputPath = options.outputPath ?? fileConfig?.outputPath ?? process.env.KNOWLEDGE_OUTPUT_PATH;
-  if (!outputPath) {
-    throw new Error("Missing required outputPath");
+  /**
+   * Extracts sections from a parsed AST.
+   */
+  extract(tree, pageInfo) {
+    const sections = [];
+    const headerStack = [{ depth: 1, text: pageInfo.title }];
+    let pendingSection = null;
+    const finalizeSection = () => {
+      if (!pendingSection || pendingSection.nodes.length === 0) {
+        return;
+      }
+      const entry = this.buildSectionEntry(pendingSection, pageInfo);
+      if (entry && entry.content.length >= this.minContentLength) {
+        sections.push(entry);
+      }
+    };
+    for (let i = 0; i < tree.children.length; i++) {
+      const node = tree.children[i];
+      if (node.type === "heading") {
+        const heading = node;
+        if (!this.depths.has(heading.depth)) {
+          if (pendingSection) {
+            pendingSection.nodes.push(node);
+          }
+          continue;
+        }
+        finalizeSection();
+        while (headerStack.length > 0 && headerStack[headerStack.length - 1].depth >= heading.depth) {
+          headerStack.pop();
+        }
+        const headingText = this.getHeadingText(heading);
+        headerStack.push({ depth: heading.depth, text: headingText });
+        pendingSection = {
+          headerPath: headerStack.map((h) => h.text),
+          nodes: [],
+          startIndex: i
+        };
+      } else if (pendingSection) {
+        pendingSection.nodes.push(node);
+      }
+    }
+    finalizeSection();
+    return sections;
   }
-  const routeDir = join2(
-    resolvedConfig.appDirectory,
-    resolvedConfig.pageDirectory
-  );
-  if (!existsSync(resolve3(routeDir))) {
-    throw new Error(`Route directory ${routeDir} does not exist`);
+  getHeadingText(heading) {
+    let text = "";
+    visit10(heading, "text", (node) => {
+      text += node.value;
+    });
+    return text.trim();
   }
-  const cliMetadata = parseCliMetadata(options.metadata);
-  const mergedMetadata = fileConfig?.metadata || cliMetadata ? { ...fileConfig?.metadata, ...cliMetadata } : void 0;
-  return {
-    ...fileConfig,
-    ...options,
-    baseUrl: options.baseUrl ?? fileConfig?.baseUrl ?? process.env.DOCS_SITE_BASE_URL,
-    docPropsPath: resolvedConfig.typeDocProps,
-    exclude,
-    extraFiles: fileConfig?.extraFiles,
-    metadata: mergedMetadata,
-    outputPath,
-    pageTitlePrefix: options.pageTitlePrefix ?? fileConfig?.pageTitlePrefix ?? process.env.PAGE_TITLE_PREFIX,
-    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`);
+  buildSectionEntry(section, pageInfo) {
+    const { metadata, nodes } = this.extractMetadata(section.nodes);
+    if (nodes.length === 0) {
+      return null;
+    }
+    const contentNodes = [];
+    const codeExamples = [];
+    for (const node of nodes) {
+      if (node.type === "code") {
+        const codeNode = node;
+        if (codeNode.data?.typeDocProps) {
+          const { name, props } = codeNode.data.typeDocProps;
+          metadata.props = [...metadata.props ?? [], ...props];
+          metadata.type = name;
+        }
+        codeExamples.push({
+          code: codeNode.value,
+          language: codeNode.lang ?? ""
+        });
+      } else {
+        contentNodes.push(node);
+      }
+    }
+    const rawContent = this.nodesToRawContent(nodes);
+    const content = this.nodesToContent(contentNodes);
+    const sectionId = this.generateSectionId(section.headerPath);
+    const url = pageInfo.url ? `${pageInfo.url}#${this.generateAnchorId(section.headerPath.at(-1) ?? "")}` : void 0;
+    const hashData = {
+      headerPath: section.headerPath,
+      metadata: Object.keys(metadata).length ? metadata : void 0,
+      pageFrontmatter: Object.keys(pageInfo.frontmatter).length ? pageInfo.frontmatter : void 0,
+      pageId: pageInfo.id,
+      rawContent: rawContent.trim()
+    };
+    const sectionHash = JSON.stringify(hashData);
+    return {
+      ...hashData,
+      codeExamples: codeExamples.length ? codeExamples : void 0,
+      content: content.trim(),
+      hash: sectionHash,
+      sectionId,
+      url
+    };
   }
-  if (!environments || environments.length === 0) {
-    const legacyConfig = loadKnowledgeConfigFromEnv(
-      options.cliOptions ?? { outputMode: "per-page" }
-    );
-    return [legacyConfig];
+  extractMetadata(nodes) {
+    const metadata = {};
+    const filteredNodes = [];
+    for (const node of nodes) {
+      if (node.type === "paragraph") {
+        const firstChild = node.children?.[0];
+        if (firstChild?.type === "text") {
+          const text = firstChild.value;
+          const metaMatch = text.match(/^:::\s*meta\s*/);
+          if (metaMatch) {
+            const parsed = this.parseMetaBlock(text);
+            Object.assign(metadata, parsed);
+            continue;
+          }
+        }
+      }
+      filteredNodes.push(node);
+    }
+    return { metadata, nodes: filteredNodes };
   }
-  let filteredEnvironments = environments;
-  if (options.environments?.length) {
-    const filterSet = new Set(options.environments);
-    filteredEnvironments = environments.filter((env) => filterSet.has(env.id));
+  parseMetaBlock(text) {
+    const metadata = {};
+    const afterOpen = text.replace(/^:::\s*meta\s*/, "");
+    const closeIndex = afterOpen.lastIndexOf(":::");
+    const content = closeIndex !== -1 ? afterOpen.slice(0, closeIndex) : afterOpen;
+    const lines = content.split("\n");
+    for (const line of lines) {
+      const trimmed = line.trim();
+      if (!trimmed) {
+        continue;
+      }
+      const colonIndex = trimmed.indexOf(":");
+      if (colonIndex === -1) {
+        continue;
+      }
+      const key = trimmed.slice(0, colonIndex).trim();
+      const value = trimmed.slice(colonIndex + 1).trim();
+      if (key && value) {
+        metadata[key] = this.parseValue(value);
+      }
+    }
+    return metadata;
   }
-  if (filteredEnvironments.length === 0) {
-    throw new Error(
-      `No matching environments found. Available: ${environments.map((e) => e.id).join(", ")}`
-    );
+  parseValue(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+      const inner = trimmed.slice(1, -1);
+      return inner.split(",").map((item) => item.trim()).filter(Boolean);
+    }
+    return trimmed;
   }
-  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
+  /**
+   * Convert links to inline code. URLs are not relevant for text embeddings
+   * and will muddy the vector storage.
+   */
+  transformLinks() {
+    return () => (tree) => {
+      visit10(tree, "link", (node) => {
+        let text = "";
+        visit10(node, "text", (textNode) => {
+          text += textNode.value;
+        });
+        Object.assign(node, {
+          children: void 0,
+          type: "inlineCode",
+          url: void 0,
+          value: text
+        });
+      });
     };
-  });
-}
-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)
-    );
+  nodesToRawContent(nodes) {
+    const tree = { children: nodes, type: "root" };
+    const processor = unified4().use(remarkStringify3);
+    return processor.stringify(tree);
   }
-  if (options.environments?.length) {
-    const filterSet = new Set(options.environments);
-    filteredIntegrations = filteredIntegrations.filter(
-      (integration) => filterSet.has(integration.id)
-    );
+  nodesToContent(nodes) {
+    const tree = { children: structuredClone(nodes), type: "root" };
+    const processor = unified4().use(this.transformLinks()).use(remarkStringify3);
+    const transformed = processor.runSync(tree);
+    return processor.stringify(transformed);
   }
-  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) {
-  return access(dirPath).then(() => true).catch(() => false);
-}
-function computeMd5(content) {
-  return createHash2("md5").update(content).digest("hex");
-}
-function extractBestType(propInfo) {
-  const type = propInfo.resolvedType?.prettyType || propInfo.type;
-  return cleanType(type.startsWith("| ") ? type.substring(2) : type);
-}
-function extractRequired(propInfo, isPartial) {
-  return Boolean(propInfo.resolvedType?.required && !isPartial);
-}
-function cleanType(type) {
-  return type.replace(/\n/g, " ").replace(/\s+/g, " ").trim();
-}
-function cleanDefaultValue(defaultValue) {
-  return defaultValue.replace(/^\n+/, "").replace(/\n+$/, "").trim();
-}
-function isPreviewLine(trimmedLine) {
-  return trimmedLine === "// preview" || /^\{\s*\/\*\s*preview\s*\*\/\s*\}$/.test(trimmedLine) || /^<!--\s*preview\s*-->$/.test(trimmedLine);
-}
-function removePreviewLines(code) {
-  return code.split("\n").filter((line) => !isPreviewLine(line.trim())).join("\n");
-}
-function getIntroLines(projectName, description) {
-  const lines = [];
-  if (projectName) {
-    lines.push(`# ${projectName}`);
-  }
-  if (description) {
-    lines.push("");
-    lines.push(`> ${description}`);
-  }
-  return lines.join("\n");
-}
-function extractRelativeImports(content) {
-  const imports = [];
-  const importRegex = /^import\s+(?:{[^}]*}|[\w*]+|\*\s+as\s+\w+)?\s*(?:,\s*{[^}]*})?\s*from\s+["'](\.[^"']+)["']/gm;
-  let match;
-  while ((match = importRegex.exec(content)) !== null) {
-    imports.push(match[1]);
-  }
-  return imports;
-}
-async function resolveModulePath(importPath, fromFile) {
-  const fromDir = dirname(fromFile);
-  const baseResolved = resolve4(fromDir, importPath);
-  const extensions = [".ts", ".tsx", ".js", ".jsx", ""];
-  for (const ext of extensions) {
-    const fullPath = baseResolved + ext;
-    if (await exists(fullPath)) {
-      return fullPath;
-    }
+  generateSectionId(headerPath) {
+    return headerPath.map((h) => kebabCase2(h)).join("-");
   }
-  if (await exists(baseResolved)) {
-    const indexPath = join3(baseResolved, "index.ts");
-    if (await exists(indexPath)) {
-      return indexPath;
-    }
+  generateAnchorId(headerText) {
+    return kebabCase2(headerText);
   }
-  return null;
-}
-function extractMetadata(metadata) {
-  return Object.entries(metadata ?? {});
-}
-var replaceNpmInstallTabs = () => {
-  return (tree, _file, done) => {
-    visit5(tree, "mdxJsxFlowElement", (node) => {
-      if (node?.name === "NpmInstallTabs") {
-        const packages = node.attributes?.find(
-          (attr) => attr.type === "mdxJsxAttribute" && attr.name === "packages"
-        );
-        const packageNames = packages ? extractNamesFromAttribute(packages) : [];
-        Object.assign(node, {
-          lang: "shell",
-          meta: null,
-          type: "code",
-          value: `npm install ${packageNames.join(" ")}`
-        });
-      }
-    });
-    done();
-  };
 };
-function getPath(obj, path) {
-  return path.split(".").reduce(
-    (acc, key) => acc && typeof acc === "object" ? acc[key] : void 0,
-    obj
-  );
-}
-function escapeText(value) {
-  return value.replace(/\n/g, " ");
-}
-function propsToDefinitionList(props) {
-  if (props.length === 0) {
-    return "";
-  }
-  return props.map((prop) => {
-    const parts = [`- **${prop.name}** (\`${escapeText(prop.type)}\``];
-    if (prop.defaultValue) {
-      parts.push(`, default: \`${escapeText(prop.defaultValue)}\``);
-    }
-    if (prop.required) {
-      parts.push(", required");
-    }
-    parts.push(")");
-    if (prop.description) {
-      parts.push(` - ${escapeText(prop.description)}`);
-    }
-    return parts.join("");
-  }).join("\n");
-}
-function themeDataToJson(data, cssPropertyName) {
-  if (!data || typeof data !== "object") {
-    return "";
-  }
-  if (cssPropertyName) {
-    return JSON.stringify({ cssProperty: cssPropertyName, data }, null, 2);
-  }
-  return JSON.stringify(data, null, 2);
-}
+
+// src/ai-knowledge/generator/knowledge-generator.ts
 var KnowledgeGenerator = class {
   config;
-  docProps = null;
-  constructor(config2) {
-    this.config = config2;
+  propFormatter;
+  constructor(config3) {
+    setConfig(config3);
+    this.config = getConfig();
+    this.propFormatter = new PropFormatter();
   }
   async run() {
     const extractedMetadata = extractMetadata(this.config.metadata);
@@ -6008,11 +6311,10 @@ var KnowledgeGenerator = class {
         console.log(`Excluding patterns: ${this.config.exclude.join(", ")}`);
       }
     }
-    const [docProps, pages] = await Promise.all([
-      this.loadDocProps(),
-      this.scanPages()
+    const [pages] = await Promise.all([
+      this.scanPages(),
+      this.propFormatter.loadDocProps()
     ]);
-    this.docProps = docProps;
     if (pages.length === 0) {
       console.log("No pages found.");
       return [];
@@ -6039,7 +6341,7 @@ var KnowledgeGenerator = class {
     if (this.config.outputMode === "aggregated") {
       await this.generateAggregatedOutput(processedPages, pages);
     } else {
-      await mkdir2(this.config.outputPath, { recursive: true }).catch(() => {
+      await mkdir(this.config.outputPath, { recursive: true }).catch(() => {
       });
       await this.generatePerPageExports(
         pages,
@@ -6049,31 +6351,6 @@ var KnowledgeGenerator = class {
     }
     return pages;
   }
-  async loadDocProps() {
-    const resolvedDocPropsPath = this.config.docPropsPath ? await exists(this.config.docPropsPath) ? this.config.docPropsPath : resolve4(process.cwd(), this.config.docPropsPath) : join3(dirname(this.config.routeDir), "doc-props.json");
-    if (!await exists(resolvedDocPropsPath)) {
-      if (this.config.verbose) {
-        console.log(`Doc props file not found at: ${resolvedDocPropsPath}`);
-      }
-      return null;
-    }
-    try {
-      const content = await readFile(resolvedDocPropsPath, "utf-8");
-      const docProps = JSON.parse(content);
-      if (this.config.verbose) {
-        console.log(`Loaded doc props from: ${resolvedDocPropsPath}`);
-        console.log(
-          `Found ${Object.keys(docProps.props).length} component types`
-        );
-      }
-      return docProps;
-    } catch (error) {
-      if (this.config.verbose) {
-        console.log("Error loading doc props", error);
-      }
-      return null;
-    }
-  }
   async scanPages() {
     const components = [];
     const excludePatterns = this.config.exclude ?? [];
@@ -6097,14 +6374,14 @@ var KnowledgeGenerator = class {
       }
       const entries = await readdir(dirPath, { withFileTypes: true });
       const mdxFiles = entries.filter(
-        (f) => f.name.endsWith(".mdx") && !shouldExclude(join3(dirPath, f.name))
+        (f) => f.name.endsWith(".mdx") && !shouldExclude(join6(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;
+        const demosFolderPath = demosFolder ? join6(dirPath, demosFolder.name) : void 0;
         const segments = getPathSegmentsFromFileName(
-          join3(dirPath, mdxFile.name),
+          join6(dirPath, mdxFile.name),
           this.config.routeDir
         );
         const url = getPathnameFromPathSegments(segments);
@@ -6112,18 +6389,18 @@ var KnowledgeGenerator = class {
           demosFolder: demosFolderPath,
           filePath: dirPath,
           id: `${pageIdPrefix ? `${pageIdPrefix}-` : ""}${segments.join("-").trim()}`,
-          mdxFile: join3(dirPath, mdxFile.name),
+          mdxFile: join6(dirPath, mdxFile.name),
           name: segments.at(-1),
           pathname: url,
           url: this.config.baseUrl ? new URL(url, this.config.baseUrl).toString() : void 0
         });
         if (this.config.verbose) {
-          console.log(`Found file: ${basename(dirPath)}`);
+          console.log(`Found file: ${basename2(dirPath)}`);
           console.log(`  Demos folder: ${demosFolderPath || "NOT FOUND"}`);
         }
       }
       for (const entry of entries) {
-        const fullPath = join3(dirPath, entry.name);
+        const fullPath = join6(dirPath, entry.name);
         const stats = await stat(fullPath);
         if (stats.isDirectory()) {
           await scanDirectory(fullPath);
@@ -6133,807 +6410,892 @@ var KnowledgeGenerator = class {
     await scanDirectory(this.config.routeDir);
     return components;
   }
-  async collectRelativeImports(filePath, visited = /* @__PURE__ */ new Set()) {
-    const normalizedPath = resolve4(filePath);
-    if (visited.has(normalizedPath)) {
-      return [];
-    }
-    visited.add(normalizedPath);
-    const modules = [];
-    try {
-      const content = await readFile(normalizedPath, "utf-8");
-      const relativeImports = extractRelativeImports(content);
-      for (const importPath of relativeImports) {
-        const resolvedPath = await resolveModulePath(importPath, normalizedPath);
-        if (!resolvedPath) {
-          if (this.config.verbose) {
-            console.log(
-              `  Could not resolve import: ${importPath} from ${normalizedPath}`
-            );
+  formatFrontmatterExpressions(frontmatter) {
+    return () => (tree) => {
+      visit11(
+        tree,
+        "mdxFlowExpression",
+        (node, index, parent) => {
+          if (node.value.trim() !== "frontmatter.description" || index === void 0 || !parent) {
+            return;
+          }
+          if (frontmatter.description) {
+            parent.children.splice(index, 1, {
+              children: [{ type: "text", value: frontmatter.description }],
+              type: "paragraph"
+            });
+          } else {
+            parent.children.splice(index, 1);
           }
-          continue;
         }
-        const importContent = await readFile(resolvedPath, "utf-8");
-        modules.push({
-          content: importContent,
-          path: resolvedPath
-        });
-        const nestedModules = await this.collectRelativeImports(
-          resolvedPath,
-          visited
+      );
+      const root = tree;
+      const h1Index = root.children.findIndex((node) => {
+        if (node.type !== "heading" || node.depth !== 1) {
+          return false;
+        }
+        return node.children?.some(
+          (child) => child.type === "mdxTextExpression" && child.value?.includes("frontmatter")
         );
-        modules.push(...nestedModules);
+      });
+      if (h1Index >= 0) {
+        root.children.splice(h1Index, 1);
       }
-    } catch (error) {
-      if (this.config.verbose) {
-        console.log(`Error processing ${normalizedPath}`, error);
+    };
+  }
+  /**
+   * Creates a remark plugin that transforms relative URLs to absolute URLs.
+   */
+  transformRelativeUrls(pageUrl) {
+    const baseUrl = this.config.baseUrl;
+    return () => (tree) => {
+      if (!baseUrl || this.config.outputMode !== "per-page") {
+        return;
       }
+      visit11(tree, "link", (node) => {
+        if (node.url.startsWith("/")) {
+          node.url = `${baseUrl}${node.url}`;
+        } else if (node.url.startsWith("./#") && pageUrl) {
+          node.url = `${pageUrl}${node.url.slice(2)}`;
+        }
+      });
+    };
+  }
+  applyPlugins(opts, processor) {
+    if (this.config.mdxPlugins) {
+      this.config.mdxPlugins.forEach((plugin) => {
+        processor.use(plugin(opts));
+      });
     }
-    return modules;
   }
-  extractProps(props, isPartial) {
-    const propsInfo = [];
-    if (props.props?.length) {
-      propsInfo.push(
-        ...props.props.map((prop) => this.convertPropInfo(prop, isPartial))
-      );
+  filterFrontmatter(frontmatter) {
+    if (!this.config.frontmatter?.include?.length) {
+      return frontmatter;
     }
-    if (props.input?.length) {
-      propsInfo.push(
-        ...props.input.map(
-          (prop) => this.convertPropInfo(prop, isPartial, "input")
-        )
+    const includePatterns = this.config.frontmatter.include;
+    const excludePatterns = this.config.frontmatter.exclude ?? [];
+    const filtered = {};
+    for (const [field, value] of Object.entries(frontmatter)) {
+      if (value === void 0) {
+        continue;
+      }
+      const isIncluded = includePatterns.some(
+        (pattern) => minimatch(field, pattern)
       );
-    }
-    if (props.output?.length) {
-      propsInfo.push(
-        ...props.output.map(
-          (prop) => this.convertPropInfo(prop, isPartial, "output")
-        )
+      const isExcluded = excludePatterns.some(
+        (pattern) => minimatch(field, pattern)
       );
+      if (isIncluded && !isExcluded) {
+        filtered[field] = value;
+      }
     }
-    return propsInfo;
+    return filtered;
   }
-  formatComment(comment) {
-    if (!comment) {
-      return "";
-    }
-    const parts = [];
-    if (comment.summary && comment.summary.length > 0) {
-      const summaryText = this.formatCommentParts(comment.summary);
-      if (summaryText.trim()) {
-        parts.push(summaryText.trim());
+  /**
+   * Processes MDX content by transforming JSX elements (TypeDocProps, demos)
+   * into Markdown, resolving relative links, and cleaning up formatting.
+   */
+  async processMdxContent(mdxContent, pageInfo, frontmatter) {
+    const processor = unified5().use(remarkParse4).use(remarkMdx3).use(remarkFrontmatter2, ["yaml"]).use(this.propFormatter.formatTypeDocProps()).use(this.formatFrontmatterExpressions(frontmatter)).use(await formatThemeNodes()).use(formatDemos(pageInfo.demosFolder)).use(this.transformRelativeUrls(pageInfo.url));
+    this.applyPlugins(pageInfo, processor);
+    processor.use(remarkStringify4);
+    return await processor.run(processor.parse(mdxContent));
+  }
+  async processMdxPage(pageInfo) {
+    try {
+      const mdxContent = await readFile4(pageInfo.mdxFile, "utf-8");
+      if (this.config.verbose) {
+        console.log(`Processing page: ${pageInfo.name}`);
       }
+      const processor = unified5().use(remarkParse4).use(remarkMdx3).use(formatNpmInstallTabs).use(remarkFrontmatter2, ["yaml"]).use(remarkParseFrontmatter2).use(remarkStringify4);
+      const parsed = await processor.process(mdxContent);
+      const frontmatter = parsed.data?.frontmatter || {};
+      const ast = await this.processMdxContent(
+        String(parsed),
+        pageInfo,
+        frontmatter
+      );
+      const removeJsxProcessor = unified5().use(remarkMdx3).use(remarkFrontmatter2, ["yaml"]).use(remarkRemoveJsx).use(remarkStringify4);
+      const sectionAst = removeJsxProcessor.runSync(ast);
+      const removedJsx = String(removeJsxProcessor.stringify(sectionAst));
+      const rawContent = removedJsx.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, "").replace(/(^#{1,6} .*\\<[^>]+)>/gm, "$1\\>");
+      const stripMetaProcessor = unified5().use(remarkParse4).use(remarkExtractMeta, {}).use(remarkStringify4);
+      const strippedContent = String(
+        await stripMetaProcessor.process(rawContent)
+      );
+      const title = frontmatter.title || pageInfo.name;
+      return {
+        content: strippedContent.trim(),
+        frontmatter,
+        rawContent: rawContent.trim(),
+        sectionAst,
+        title,
+        url: pageInfo.url
+      };
+    } catch (error) {
+      console.error(`Error processing component ${pageInfo.name}:`, error);
+      throw error;
     }
-    if (comment.blockTags && comment.blockTags.length > 0) {
-      for (const blockTag of comment.blockTags) {
-        const tagContent = this.formatCommentParts(blockTag.content);
-        if (tagContent.trim()) {
-          const tagName = blockTag.tag.replace("@", "");
-          if (tagName === "default" || tagName === "defaultValue") {
-            continue;
-          }
-          if (tagName === "example") {
-            parts.push(`**Example:**
-\`\`\`
-${tagContent.trim()}
-\`\`\``);
-          } else {
-            parts.push(`**${tagName}:** ${tagContent.trim()}`);
-          }
+  }
+  generateLlmsTxt(pages) {
+    const lines = [
+      getIntroLines(this.config.name, this.config.description)
+    ];
+    lines.push("");
+    for (const page of pages) {
+      const content = page.content.split("\n").map((line) => {
+        if (line.startsWith("#")) {
+          return `#${line}`;
         }
+        return line;
+      });
+      if (content.every((line) => !line.trim())) {
+        continue;
       }
+      lines.push(`## ${page.title}`);
+      lines.push("");
+      lines.push(content.join("\n"));
+      lines.push("");
     }
-    return parts.join("\n\n");
+    return lines.join("\n");
   }
-  formatCommentParts(parts) {
-    return parts.map((part) => {
-      switch (part.kind) {
-        case "text":
-          return part.text;
-        case "code":
-          const codeText = part.text.replace(/```\w*\n?/g, "").replace(/\n?```/g, "").trim();
-          if (codeText.includes("\n")) {
-            return `\`\`\`
-${codeText}
-\`\`\``;
-          } else {
-            return codeText;
-          }
-        default:
-          if (this.config.outputMode === "per-page" && "tag" in part && part.tag === "@link" && typeof part.target === "string") {
-            if (part.text === "Learn more") {
-              return "";
-            }
-          }
-          return part.text;
+  async generateAggregatedOutput(processedPages, pages) {
+    const llmsTxtContent = this.generateLlmsTxt(processedPages);
+    await mkdir(dirname3(this.config.outputPath), { recursive: true }).catch(
+      () => {
       }
-    }).join("").replace(/\n/g, " ").replace(/\s+/g, " ").trim();
-  }
-  convertPropInfo(propInfo, isPartial, propType = void 0) {
-    return {
-      name: propInfo.name,
-      type: extractBestType(propInfo),
-      ...propInfo.defaultValue && {
-        defaultValue: cleanDefaultValue(propInfo.defaultValue)
-      },
-      description: this.formatComment(propInfo.comment || null),
-      propType,
-      required: extractRequired(propInfo, isPartial) || void 0
-    };
+    );
+    await writeFile(this.config.outputPath, llmsTxtContent, "utf-8");
+    const outputStats = await stat(this.config.outputPath);
+    const outputSizeKb = (outputStats.size / 1024).toFixed(1);
+    console.log(
+      `Generated ${this.config.outputPath} with ${pages.length} files(s) at: ${this.config.outputPath}`
+    );
+    console.log(`File size: ${outputSizeKb} KB`);
   }
-  /**
-   * Creates a remark plugin that replaces theme JSX elements with
-   * markdown tables containing theme data.
-   */
-  async replaceThemeNodes() {
-    let themes = null;
-    try {
-      themes = await import("@qualcomm-ui/tailwind-plugin/theme");
-    } catch {
-      return () => {
-      };
+  async generateExtraFiles(metadata) {
+    const start = performance.now();
+    const extraFiles = this.config.extraFiles ?? [];
+    if (extraFiles.length === 0) {
+      return { count: 0, duration: 0, entries: [], totalSize: 0 };
     }
-    const handlers = {
-      ColorTable: (node) => {
-        const path = this.getAttrExpression(node, "data");
-        return path && getPath(themes, path);
-      },
-      FontTable: (node) => {
-        const path = this.getAttrExpression(node, "data");
-        return path && getPath(themes, path);
-      },
-      SpacingTable: (node) => {
-        const path = this.getAttrExpression(node, "data");
-        return path && getPath(themes, path);
-      },
-      ThemePropertyTable: (node) => {
-        const path = this.getAttrExpression(node, "data");
-        const property = this.getAttrExpression(node, "cssProperty");
-        const data = path && getPath(themes, path);
-        return path && property ? { cssPropertyName: property, data } : void 0;
-      }
-    };
-    return () => (tree, _file, done) => {
-      visit5(tree, "mdxJsxFlowElement", (node) => {
-        const handler = node.name && handlers[node.name];
-        if (!handler) {
-          return;
-        }
-        const data = handler(node);
-        if (!data) {
-          console.warn(`No theme data for ${node.name}`);
-          return;
+    let totalSize = 0;
+    const entries = [];
+    await Promise.all(
+      extraFiles.map(async (extraFile) => {
+        let contents = extraFile.contents;
+        if (extraFile.processAsMdx) {
+          const removeJsxProcessor = unified5().use(remarkParse4).use(remarkMdx3).use(remarkFrontmatter2, ["yaml"]).use(remarkRemoveJsx).use(this.transformRelativeUrls()).use(remarkStringify4);
+          contents = String(await removeJsxProcessor.process(contents));
         }
-        let markdownTable;
-        if (typeof data === "object" && data !== null && "cssPropertyName" in data && "data" in data) {
-          const { cssPropertyName, data: themeData } = data;
-          markdownTable = themeDataToJson(themeData, cssPropertyName);
-        } else {
-          markdownTable = themeDataToJson(data);
+        const lines = [];
+        if (metadata.length) {
+          lines.push("---");
+          for (const [key, value] of metadata) {
+            lines.push(`${key}: ${value}`);
+          }
+          lines.push("---");
+          lines.push("");
         }
-        if (!markdownTable) {
-          return;
+        if (extraFile.title) {
+          lines.push(`# ${extraFile.title}`);
+          lines.push("");
         }
-        Object.assign(node, {
-          lang: "json",
-          meta: null,
-          type: "code",
-          value: markdownTable
+        lines.push(contents);
+        lines.push("");
+        const fileContent = lines.join("\n");
+        const fileName = `${kebabCase3(extraFile.id)}.md`;
+        const outfile = `${resolve4(this.config.outputPath)}/${fileName}`;
+        await writeFile(outfile, fileContent, "utf-8");
+        const stats = await stat(outfile);
+        totalSize += stats.size / 1024;
+        entries.push({
+          id: extraFile.id,
+          md5: computeMd5(fileContent),
+          path: fileName,
+          size: stats.size,
+          title: extraFile.title || extraFile.id
         });
-      });
-      done();
-    };
-  }
-  getAttrExpression(node, name) {
-    const attr = node.attributes?.find(
-      (a) => a.type === "mdxJsxAttribute" && a.name === name
+      })
     );
-    if (!attr?.value) {
-      return null;
-    }
-    if (typeof attr.value === "string") {
-      return attr.value;
-    } else if (typeof attr.value === "object" && "value" in attr.value) {
-      return attr.value.value;
-    }
-    return null;
+    return {
+      count: extraFiles.length,
+      duration: performance.now() - start,
+      entries,
+      totalSize
+    };
   }
-  /**
-   * Creates a remark plugin that transforms relative URLs to absolute URLs.
-   */
-  transformRelativeUrls(pageUrl) {
-    const baseUrl = this.config.baseUrl;
-    return () => (tree) => {
-      if (!baseUrl || this.config.outputMode !== "per-page") {
-        return;
+  async generatePerPageExports(pages, processedPages, metadata) {
+    const start = performance.now();
+    await mkdir(dirname3(this.config.outputPath), { recursive: true }).catch(
+      () => {
       }
-      visit5(tree, "link", (node) => {
-        if (node.url.startsWith("/")) {
-          node.url = `${baseUrl}${node.url}`;
-        } else if (node.url.startsWith("./#") && pageUrl) {
-          node.url = `${pageUrl}${node.url.slice(2)}`;
+    );
+    const count = processedPages.length;
+    let totalSize = 0;
+    const manifestEntries = [];
+    await Promise.all(
+      processedPages.map(async (processedPage, index) => {
+        const page = pages[index];
+        const lines = [];
+        const frontmatterEntries = [];
+        if (page.url) {
+          frontmatterEntries.push(["url", page.url]);
         }
-      });
-    };
-  }
-  /**
-   * Creates a remark plugin that replaces TypeDocProps JSX elements with
-   * markdown tables containing component prop documentation.
-   */
-  replaceTypeDocProps() {
-    return () => (tree, _file, done) => {
-      visit5(
-        tree,
-        "mdxJsxFlowElement",
-        (node, index, parent) => {
-          if (node?.name !== "TypeDocProps") {
-            return;
-          }
-          const nameAttr = node.attributes?.find(
-            (attr) => attr.type === "mdxJsxAttribute" && attr.name === "name"
-          );
-          const isPartial = node.attributes?.some(
-            (attr) => attr.type === "mdxJsxAttribute" && attr.name === "partial"
-          );
-          if (!this.docProps || !nameAttr) {
-            if (parent && index !== void 0) {
-              parent.children.splice(index, 1);
-            }
-            return;
-          }
-          const propsNames = extractNamesFromAttribute(nameAttr);
-          if (propsNames.length === 0) {
-            if (parent && index !== void 0) {
-              parent.children.splice(index, 1);
-            }
-            return;
-          }
-          const propsName = propsNames[0];
-          const componentProps = this.docProps.props[propsName];
-          if (!componentProps) {
-            if (this.config.verbose) {
-              console.log(`  TypeDocProps not found: ${propsName}`);
-            }
-            if (parent && index !== void 0) {
-              parent.children.splice(index, 1);
+        for (const [key, value] of metadata) {
+          frontmatterEntries.push([key, value]);
+        }
+        if (this.config.frontmatter?.include?.length) {
+          const includePatterns = this.config.frontmatter.include;
+          const excludePatterns = this.config.frontmatter.exclude ?? [];
+          for (const [field, value] of Object.entries(
+            processedPage.frontmatter
+          )) {
+            if (value === void 0) {
+              continue;
             }
-            return;
-          }
-          const propsDoc = this.extractProps(componentProps, Boolean(isPartial));
-          if (this.config.verbose) {
-            console.log(
-              `  Replaced TypeDocProps ${propsName} with API documentation`
+            const isIncluded = includePatterns.some(
+              (pattern) => minimatch(field, pattern)
             );
+            const isExcluded = excludePatterns.some(
+              (pattern) => minimatch(field, pattern)
+            );
+            if (isIncluded && !isExcluded) {
+              frontmatterEntries.push([
+                field,
+                Array.isArray(value) ? value : String(value)
+              ]);
+            }
           }
-          const regularProps = propsDoc.filter((p) => p.propType === void 0);
-          const inputs = propsDoc.filter((p) => p.propType === "input");
-          const outputs = propsDoc.filter((p) => p.propType === "output");
-          const sections = [];
-          if (regularProps.length > 0) {
-            sections.push(propsToDefinitionList(regularProps));
-          }
-          if (inputs.length > 0) {
-            sections.push(`**Inputs**
-
-${propsToDefinitionList(inputs)}`);
-          }
-          if (outputs.length > 0) {
-            sections.push(`**Outputs**
-
-${propsToDefinitionList(outputs)}`);
+        }
+        if (this.config.frontmatter?.extraFields) {
+          for (const [key, value] of Object.entries(
+            this.config.frontmatter.extraFields
+          )) {
+            frontmatterEntries.push([key, value]);
           }
-          const markdownContent = sections.join("\n\n");
-          if (!markdownContent) {
-            if (parent && index !== void 0) {
-              parent.children.splice(index, 1);
+        }
+        if (frontmatterEntries.length > 0) {
+          lines.push("---");
+          for (const [key, value] of frontmatterEntries) {
+            if (Array.isArray(value)) {
+              lines.push(`${key}: [${value.join(", ")}]`);
+            } else {
+              lines.push(`${key}: ${value}`);
             }
-            return;
           }
-          Object.assign(node, {
-            lang: null,
-            meta: null,
-            type: "code",
-            value: markdownContent
-          });
+          lines.push("---");
+          lines.push("");
         }
-      );
-      done();
-    };
-  }
-  /**
-   * Creates a remark plugin that replaces demo JSX elements (QdsDemo, CodeDemo,
-   * Demo) with code blocks containing the demo source code from the demos folder.
-   */
-  replaceDemos(demosFolder, demoFiles) {
-    return () => async (tree) => {
-      const promises = [];
-      visit5(
-        tree,
-        "mdxJsxFlowElement",
-        (node, index, parent) => {
-          if (!node?.name || !["QdsDemo", "CodeDemo", "Demo"].includes(node.name)) {
-            return;
-          }
-          const nameAttr = node.attributes?.find(
-            (attr) => attr.type === "mdxJsxAttribute" && attr.name === "name"
-          );
-          const nodeAttr = node.attributes?.find(
-            (attr) => attr.type === "mdxJsxAttribute" && attr.name === "node"
-          );
-          let demoName;
-          if (nameAttr && typeof nameAttr.value === "string") {
-            demoName = nameAttr.value;
-          } else if (nodeAttr?.value && typeof nodeAttr.value !== "string") {
-            const estree = nodeAttr.value.data?.estree;
-            if (estree?.body?.[0]?.type === "ExpressionStatement") {
-              const expression = estree.body[0].expression;
-              if (expression.type === "MemberExpression" && expression.object.type === "Identifier" && expression.object.name === "Demo" && expression.property.type === "Identifier") {
-                demoName = expression.property.name;
-              }
-            }
-          }
-          if (!demoName) {
-            if (parent && index !== void 0) {
-              parent.children.splice(index, 1);
-            }
-            return;
-          }
-          promises.push(
-            (async () => {
-              const kebabName = kebabCase(demoName);
-              let filePath = `${kebabName}.tsx`;
-              if (!demosFolder) {
-                if (this.config.verbose) {
-                  console.log(`  No demos folder for ${demoName}`);
-                }
-                if (parent && index !== void 0) {
-                  parent.children.splice(index, 1);
-                }
-                return;
-              }
-              let demoFilePath = join3(demosFolder, filePath);
-              let isAngularDemo = false;
-              if (!await exists(demoFilePath)) {
-                demoFilePath = join3(demosFolder, `${kebabName}.ts`);
-                if (await exists(demoFilePath)) {
-                  isAngularDemo = true;
-                  filePath = `${kebabCase(demoName).replace("-component", ".component")}.ts`;
-                  demoFilePath = join3(demosFolder, filePath);
-                } else {
-                  console.log(`  Demo not found ${demoName}`);
-                  if (parent && index !== void 0) {
-                    parent.children.splice(index, 1);
-                  }
-                  return;
-                }
-              }
-              try {
-                const demoCode = await readFile(demoFilePath, "utf-8");
-                const cleanedCode = removePreviewLines(demoCode);
-                if (this.config.verbose) {
-                  console.log(`  Replaced demo ${demoName} with source code`);
-                }
-                demoFiles.push(demoFilePath);
-                Object.assign(node, {
-                  lang: isAngularDemo ? "angular-ts" : "tsx",
-                  meta: null,
-                  type: "code",
-                  value: cleanedCode
-                });
-              } catch (error) {
-                if (this.config.verbose) {
-                  console.log(`Error reading demo ${demoName}`, error);
-                }
-                if (parent && index !== void 0) {
-                  parent.children.splice(index, 1);
-                }
-              }
-            })()
+        lines.push(`# ${processedPage.title}`);
+        lines.push("");
+        if (processedPage.frontmatter?.title) {
+          page.name = processedPage.frontmatter.title;
+        }
+        let content = processedPage.content;
+        content = content.replace(
+          new RegExp(`^# ${processedPage.title}\\n+`, ""),
+          ""
+        );
+        if (this.config.pageTitlePrefix) {
+          content = content.replace(
+            `# ${page.name}`,
+            `# ${this.config.pageTitlePrefix} ${page.name}`
           );
+          page.name = `${this.config.pageTitlePrefix} ${page.name}`;
         }
+        lines.push(content);
+        lines.push("");
+        const fileContent = lines.join("\n");
+        const fileName = `${kebabCase3(page.id || page.name)}.md`;
+        const outfile = `${resolve4(this.config.outputPath)}/${fileName}`;
+        await writeFile(outfile, fileContent, "utf-8");
+        const stats = await stat(outfile);
+        totalSize += stats.size / 1024;
+        manifestEntries.push({
+          id: page.id || kebabCase3(page.name),
+          md5: computeMd5(fileContent),
+          path: fileName,
+          size: stats.size,
+          title: processedPage.title,
+          url: page.url
+        });
+      })
+    );
+    const extraFilesResult = await this.generateExtraFiles(metadata);
+    manifestEntries.push(...extraFilesResult.entries);
+    if (this.config.manifestOutputPath) {
+      if (this.config.generateManifest !== false) {
+        await this.generateManifest(
+          this.config.manifestOutputPath,
+          manifestEntries
+        );
+      }
+      if (this.config.generateBulkZip !== false) {
+        await this.generateBulkZip(
+          this.config.manifestOutputPath,
+          manifestEntries
+        );
+      }
+      await this.generateSectionsOutput(
+        processedPages,
+        pages,
+        this.config.manifestOutputPath
       );
-      await Promise.all(promises);
+    }
+    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`
+    );
+  }
+  computeAggregateHash(entries) {
+    const sortedHashes = entries.map((e) => e.md5).sort().join("");
+    return computeMd5(sortedHashes);
+  }
+  async generateManifest(outputPath, entries) {
+    const aggregateHash = this.computeAggregateHash(entries);
+    const totalSize = entries.reduce((sum, e) => sum + e.size, 0);
+    const manifest = {
+      aggregateHash,
+      baseUrl: this.config.baseUrl,
+      files: entries,
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      totalFiles: entries.length,
+      totalSize,
+      version: 1
     };
+    await mkdir(outputPath, { recursive: true }).catch(() => {
+    });
+    await writeFile(
+      join6(outputPath, "manifest.json"),
+      JSON.stringify(manifest, null, 2),
+      "utf-8"
+    );
+    return manifest;
   }
-  replaceFrontmatterExpressions(frontmatter) {
-    return () => (tree) => {
-      visit5(
-        tree,
-        "mdxFlowExpression",
-        (node, index, parent) => {
-          if (node.value.trim() !== "frontmatter.description" || index === void 0 || !parent) {
-            return;
-          }
-          if (frontmatter.description) {
-            parent.children.splice(index, 1, {
-              children: [{ type: "text", value: frontmatter.description }],
-              type: "paragraph"
-            });
-          } else {
-            parent.children.splice(index, 1);
-          }
-        }
-      );
-      const root = tree;
-      const h1Index = root.children.findIndex((node) => {
-        if (node.type !== "heading" || node.depth !== 1) {
-          return false;
-        }
-        return node.children?.some(
-          (child) => child.type === "mdxTextExpression" && child.value?.includes("frontmatter")
-        );
+  async generateBulkZip(outputPath, entries) {
+    await mkdir(outputPath, { recursive: true }).catch(() => {
+    });
+    const zipPath = join6(outputPath, "bulk.zip");
+    const zip = new AdmZip();
+    for (const entry of entries) {
+      const filePath = join6(this.config.outputPath, entry.path);
+      const content = await readFile4(filePath);
+      zip.addFile(entry.path, content);
+    }
+    zip.writeZip(zipPath);
+  }
+  async generateSectionsOutput(processedPages, pages, outputPath) {
+    const sectionsConfig = this.config.sections ?? {};
+    const extractor = new SectionExtractor({
+      depths: sectionsConfig.depths,
+      minContentLength: sectionsConfig.minContentLength
+    });
+    const allSections = [];
+    for (let i = 0; i < processedPages.length; i++) {
+      const processed = processedPages[i];
+      const page = pages[i];
+      const filteredFrontmatter = this.filterFrontmatter(processed.frontmatter);
+      const pageSections = extractor.extract(processed.sectionAst, {
+        frontmatter: filteredFrontmatter,
+        id: page.id,
+        title: processed.title,
+        url: processed.url
       });
-      if (h1Index >= 0) {
-        root.children.splice(h1Index, 1);
+      allSections.push(...pageSections);
+    }
+    const hash = computeMd5(JSON.stringify(allSections));
+    const output = {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      hash,
+      sections: allSections,
+      totalSections: allSections.length,
+      version: 1
+    };
+    const sectionsPath = join6(
+      outputPath,
+      sectionsConfig.outputPath ?? "sections.json"
+    );
+    await mkdir(dirname3(sectionsPath), { recursive: true }).catch(() => {
+    });
+    await writeFile(sectionsPath, JSON.stringify(output, null, 2), "utf-8");
+    if (this.config.verbose) {
+      console.log(
+        `Generated ${allSections.length} sections at ${chalk3.blue.bold(sectionsPath)}`
+      );
+    }
+  }
+};
+
+// src/ai-knowledge/generator/command.ts
+async function generate(config3) {
+  const generator = new KnowledgeGenerator(config3);
+  return generator.run();
+}
+function addGenerateKnowledgeCommand() {
+  program.description("Generate llms.txt from QUI Docs documentation").command("generate-llms-txt").option("-n, --name <name>", "Project name for llms.txt header").requiredOption("-m, --output-mode <outputMode>").option("-o, --outputPath <outputPath>", "Output file or directory.").option(
+    "-d, --description <description>",
+    "Project description for llms.txt"
+  ).option("-v, --verbose", "Enable verbose logging", false).option(
+    "--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).option(
+    "-e, --environment <environments>",
+    "Comma-separated list of environments to generate (default: all)"
+  ).action(async (options) => {
+    loadEnv();
+    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
+    });
+    for (const config3 of configs) {
+      const envLabel = config3.environmentName ? `[${config3.environmentName}] ` : "";
+      console.log(`${envLabel}Generating knowledge to ${config3.outputPath}`);
+      await generate(config3);
+    }
+    if (configs.length > 1) {
+      console.log(
+        `
+Generated knowledge for ${configs.length} environment(s)`
+      );
+    }
+  });
+}
+
+// src/ai-knowledge/open-web-ui/download-knowledge.ts
+import dotenv from "dotenv";
+import { mkdir as mkdir2, writeFile as writeFile2 } from "node:fs/promises";
+import { resolve as resolve5 } from "node:path";
+
+// src/ai-knowledge/open-web-ui/api.ts
+function isErrorResponse(response) {
+  return typeof response === "object" && response !== null && "detail" in response;
+}
+var FilesApi = class {
+  config;
+  constructor(config3) {
+    this.config = config3;
+  }
+  get headers() {
+    return {
+      Authorization: `Bearer ${this.config.apiKey}`
+    };
+  }
+  get jsonHeaders() {
+    return {
+      ...this.headers,
+      "Content-Type": "application/json"
+    };
+  }
+  async handleResponse(response) {
+    const data = await response.json();
+    if (isErrorResponse(data)) {
+      throw new Error(data.detail);
+    }
+    return data;
+  }
+  async upload(file, filename, options) {
+    const formData = new FormData();
+    let blob;
+    if (file instanceof Blob) {
+      blob = file;
+    } else if (file instanceof ArrayBuffer) {
+      blob = new Blob([file]);
+    } else {
+      const copy = new Uint8Array(file).buffer;
+      blob = new Blob([copy]);
+    }
+    formData.append("file", blob, filename);
+    if (options?.metadata) {
+      formData.append("metadata", JSON.stringify(options.metadata));
+    }
+    const params = new URLSearchParams();
+    if (options?.process !== void 0) {
+      params.set("process", String(options.process));
+    }
+    if (options?.processInBackground !== void 0) {
+      params.set("process_in_background", String(options.processInBackground));
+    }
+    const url = `${this.config.baseUrl}/api/v1/files/${params.toString() ? `?${params}` : ""}`;
+    const response = await fetch(url, {
+      body: formData,
+      headers: this.headers,
+      method: "POST"
+    });
+    return this.handleResponse(response);
+  }
+  async list(includeContent = true) {
+    const params = new URLSearchParams({ content: String(includeContent) });
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/files/?${params}`,
+      {
+        headers: this.headers
       }
+    );
+    return this.handleResponse(response);
+  }
+  async search(pattern, includeContent = true) {
+    const params = new URLSearchParams({
+      content: String(includeContent),
+      filename: pattern
+    });
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/files/search?${params}`,
+      { headers: this.headers }
+    );
+    if (response.status === 404) {
+      return [];
+    }
+    return this.handleResponse(response);
+  }
+  async deleteAll() {
+    const response = await fetch(`${this.config.baseUrl}/api/v1/files/all`, {
+      headers: this.headers,
+      method: "DELETE"
+    });
+    return this.handleResponse(response);
+  }
+  async getById(id) {
+    const response = await fetch(`${this.config.baseUrl}/api/v1/files/${id}`, {
+      headers: this.headers
+    });
+    return this.handleResponse(response);
+  }
+  async getProcessStatus(id) {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/files/${id}/process/status`,
+      { headers: this.headers }
+    );
+    return this.handleResponse(response);
+  }
+  async waitForProcessing(id, options) {
+    const maxAttempts = options?.maxAttempts ?? 120;
+    const intervalMs = options?.intervalMs ?? 1e3;
+    for (let i = 0; i < maxAttempts; i++) {
+      const status = await this.getProcessStatus(id);
+      if (status.status === "completed" || status.status === "failed") {
+        return status;
+      }
+      await new Promise((resolve10) => setTimeout(resolve10, intervalMs));
+    }
+    throw new Error(`File processing timed out after ${maxAttempts} attempts`);
+  }
+  async getDataContent(id) {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/files/${id}/data/content`,
+      { headers: this.headers }
+    );
+    return this.handleResponse(response);
+  }
+  async updateDataContent(id, content) {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/files/${id}/data/content/update`,
+      {
+        body: JSON.stringify({ content }),
+        headers: this.jsonHeaders,
+        method: "POST"
+      }
+    );
+    return this.handleResponse(response);
+  }
+  async getContent(id, asAttachment = false) {
+    const params = new URLSearchParams({ attachment: String(asAttachment) });
+    return fetch(
+      `${this.config.baseUrl}/api/v1/files/${id}/content?${params}`,
+      {
+        headers: this.headers
+      }
+    );
+  }
+  async getContentAsText(id) {
+    const response = await this.getContent(id);
+    if (!response.ok) {
+      const error = await response.json();
+      throw new Error(error.detail || "Failed to get file content");
+    }
+    return response.text();
+  }
+  async delete(id) {
+    const response = await fetch(`${this.config.baseUrl}/api/v1/files/${id}`, {
+      headers: this.headers,
+      method: "DELETE"
+    });
+    return this.handleResponse(response);
+  }
+};
+var KnowledgeApi = class {
+  config;
+  constructor(config3) {
+    this.config = config3;
+  }
+  get headers() {
+    return {
+      Authorization: `Bearer ${this.config.apiKey}`
     };
   }
-  /**
-   * Processes MDX content by transforming JSX elements (TypeDocProps, demos)
-   * into markdown, resolving relative links, and cleaning up formatting.
-   */
-  async processMdxContent(mdxContent, pageUrl, demosFolder, frontmatter) {
-    const demoFiles = [];
-    const processor = unified4().use(remarkParse4).use(remarkMdx3).use(remarkFrontmatter2, ["yaml"]).use(this.replaceTypeDocProps()).use(this.replaceFrontmatterExpressions(frontmatter)).use(await this.replaceThemeNodes()).use(this.replaceDemos(demosFolder, demoFiles)).use(this.transformRelativeUrls(pageUrl)).use(remarkStringify3);
-    const processed = await processor.process(mdxContent);
-    const processedContent = String(processed).replace(/\n\s*\n\s*\n/g, "\n\n");
-    return { content: processedContent, demoFiles };
+  get jsonHeaders() {
+    return {
+      ...this.headers,
+      "Content-Type": "application/json"
+    };
   }
-  async processMdxPage(pageInfo) {
-    try {
-      const mdxContent = await readFile(pageInfo.mdxFile, "utf-8");
-      if (this.config.verbose) {
-        console.log(`Processing page: ${pageInfo.name}`);
-      }
-      const processor = unified4().use(remarkParse4).use(remarkMdx3).use(replaceNpmInstallTabs).use(remarkFrontmatter2, ["yaml"]).use(remarkParseFrontmatter2).use(remarkStringify3);
-      const parsed = await processor.process(mdxContent);
-      const frontmatter = parsed.data?.frontmatter || {};
-      const { content: processedContent, demoFiles } = await this.processMdxContent(
-        String(parsed),
-        pageInfo.url,
-        pageInfo.demosFolder,
-        frontmatter
-      );
-      const removeJsxProcessor = unified4().use(remarkParse4).use(remarkMdx3).use(remarkFrontmatter2, ["yaml"]).use(remarkRemoveJsx).use(remarkStringify3);
-      const removedJsx = String(
-        await removeJsxProcessor.process(processedContent)
-      );
-      const contentWithoutFrontmatter = removedJsx.replace(/^---[\s\S]*?---\n/, "").replace(/(^#{1,6} .*\\<[^>]+)>/gm, "$1\\>");
-      const title = frontmatter.title || pageInfo.name;
-      return {
-        content: contentWithoutFrontmatter.trim(),
-        demoFiles,
-        frontmatter,
-        title,
-        url: pageInfo.url
-      };
-    } catch (error) {
-      console.error(`Error processing component ${pageInfo.name}:`, error);
-      throw error;
+  async handleResponse(response) {
+    const data = await response.json();
+    if (isErrorResponse(data)) {
+      throw new Error(data.detail);
     }
+    return data;
   }
-  generateLlmsTxt(pages) {
-    const lines = [
-      getIntroLines(this.config.name, this.config.description)
-    ];
-    lines.push("");
-    for (const page of pages) {
-      const content = page.content.split("\n").map((line) => {
-        if (line.startsWith("#")) {
-          return `#${line}`;
-        }
-        return line;
-      });
-      if (content.every((line) => !line.trim())) {
-        continue;
+  async list() {
+    const response = await fetch(`${this.config.baseUrl}/api/v1/knowledge/`, {
+      headers: this.headers
+    });
+    return this.handleResponse(response);
+  }
+  async listWritable() {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/knowledge/list`,
+      {
+        headers: this.headers
       }
-      lines.push(`## ${page.title}`);
-      lines.push("");
-      lines.push(content.join("\n"));
-      lines.push("");
-    }
-    return lines.join("\n");
+    );
+    return this.handleResponse(response);
   }
-  async generateAggregatedOutput(processedPages, pages) {
-    const llmsTxtContent = this.generateLlmsTxt(processedPages);
-    await mkdir2(dirname(this.config.outputPath), { recursive: true }).catch(
-      () => {
+  async create(form) {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/knowledge/create`,
+      {
+        body: JSON.stringify(form),
+        headers: this.jsonHeaders,
+        method: "POST"
       }
     );
-    await writeFile3(this.config.outputPath, llmsTxtContent, "utf-8");
-    const outputStats = await stat(this.config.outputPath);
-    const outputSizeKb = (outputStats.size / 1024).toFixed(1);
-    console.log(
-      `Generated ${this.config.outputPath} with ${pages.length} files(s) at: ${this.config.outputPath}`
+    return this.handleResponse(response);
+  }
+  async reindex() {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/knowledge/reindex`,
+      {
+        headers: this.jsonHeaders,
+        method: "POST"
+      }
     );
-    console.log(`File size: ${outputSizeKb} KB`);
+    return this.handleResponse(response);
   }
-  async generateExtraFiles(metadata) {
-    const start = performance.now();
-    const extraFiles = this.config.extraFiles ?? [];
-    if (extraFiles.length === 0) {
-      return { count: 0, duration: 0, entries: [], totalSize: 0 };
-    }
-    let totalSize = 0;
-    const entries = [];
-    await Promise.all(
-      extraFiles.map(async (extraFile) => {
-        let contents = extraFile.contents;
-        if (extraFile.processAsMdx) {
-          const removeJsxProcessor = unified4().use(remarkParse4).use(remarkMdx3).use(remarkFrontmatter2, ["yaml"]).use(remarkRemoveJsx).use(this.transformRelativeUrls()).use(remarkStringify3);
-          contents = String(await removeJsxProcessor.process(contents));
-        }
-        const lines = [];
-        if (metadata.length) {
-          lines.push("---");
-          for (const [key, value] of metadata) {
-            lines.push(`${key}: ${value}`);
-          }
-          lines.push("---");
-          lines.push("");
-        }
-        if (extraFile.title) {
-          lines.push(`# ${extraFile.title}`);
-          lines.push("");
-        }
-        lines.push(contents);
-        lines.push("");
-        const fileContent = lines.join("\n");
-        const fileName = `${kebabCase(extraFile.id)}.md`;
-        const outfile = `${resolve4(this.config.outputPath)}/${fileName}`;
-        await writeFile3(outfile, fileContent, "utf-8");
-        const stats = await stat(outfile);
-        totalSize += stats.size / 1024;
-        entries.push({
-          id: extraFile.id,
-          md5: computeMd5(fileContent),
-          path: fileName,
-          size: stats.size,
-          title: extraFile.title || extraFile.id
-        });
-      })
+  async getById(id) {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/knowledge/${id}`,
+      {
+        headers: this.headers
+      }
     );
-    return {
-      count: extraFiles.length,
-      duration: performance.now() - start,
-      entries,
-      totalSize
-    };
+    return this.handleResponse(response);
   }
-  async generatePerPageExports(pages, processedPages, metadata) {
-    const start = performance.now();
-    await mkdir2(dirname(this.config.outputPath), { recursive: true }).catch(
-      () => {
+  async update(id, form) {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/knowledge/${id}/update`,
+      {
+        body: JSON.stringify(form),
+        headers: this.jsonHeaders,
+        method: "POST"
       }
     );
-    const count = processedPages.length;
-    let totalSize = 0;
-    const manifestEntries = [];
-    await Promise.all(
-      processedPages.map(async (processedPage, index) => {
-        const page = pages[index];
-        const lines = [];
-        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("");
-        }
-        lines.push(`# ${processedPage.title}`);
-        lines.push("");
-        if (processedPage.frontmatter?.title) {
-          page.name = processedPage.frontmatter.title;
-        }
-        let content = processedPage.content;
-        content = content.replace(
-          new RegExp(`^# ${processedPage.title}\\n+`, ""),
-          ""
-        );
-        if (this.config.pageTitlePrefix) {
-          content = content.replace(
-            `# ${page.name}`,
-            `# ${this.config.pageTitlePrefix} ${page.name}`
-          );
-          page.name = `${this.config.pageTitlePrefix} ${page.name}`;
-        }
-        lines.push(content);
-        lines.push("");
-        if (processedPage.demoFiles.length > 0) {
-          if (this.config.verbose) {
-            console.log(
-              `Collecting imports for ${page.name} from ${processedPage.demoFiles.length} demo files`
-            );
-          }
-          const allImports = [];
-          for (const demoFile of processedPage.demoFiles) {
-            const imports = await this.collectRelativeImports(
-              demoFile,
-              /* @__PURE__ */ new Set()
-            );
-            allImports.push(...imports);
-          }
-          const uniqueImports = Array.from(
-            new Map(allImports.map((m) => [m.path, m])).values()
-          );
-          if (this.config.verbose) {
-            console.log(
-              `  Collected ${uniqueImports.length} unique import modules`
-            );
-          }
-          if (uniqueImports.length > 0) {
-            lines.push("## Related Source Files");
-            lines.push("");
-            for (const importedModule of uniqueImports) {
-              const ext = extname(importedModule.path).slice(1);
-              lines.push(`### ${basename(importedModule.path)}`);
-              lines.push("");
-              lines.push(`\`\`\`${ext}`);
-              lines.push(importedModule.content);
-              lines.push("```");
-              lines.push("");
-            }
-          }
-        }
-        const fileContent = lines.join("\n");
-        const fileName = `${kebabCase(page.id || page.name)}.md`;
-        const outfile = `${resolve4(this.config.outputPath)}/${fileName}`;
-        await writeFile3(outfile, fileContent, "utf-8");
-        const stats = await stat(outfile);
-        totalSize += stats.size / 1024;
-        manifestEntries.push({
-          id: page.id || kebabCase(page.name),
-          md5: computeMd5(fileContent),
-          path: fileName,
-          size: stats.size,
-          title: processedPage.title,
-          url: page.url
-        });
-      })
+    return this.handleResponse(response);
+  }
+  async addFile(knowledgeId, fileId) {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/knowledge/${knowledgeId}/file/add`,
+      {
+        body: JSON.stringify({ file_id: fileId }),
+        headers: this.jsonHeaders,
+        method: "POST"
+      }
     );
-    const extraFilesResult = await this.generateExtraFiles(metadata);
-    manifestEntries.push(...extraFilesResult.entries);
-    if (this.config.manifestOutputPath) {
-      if (this.config.generateManifest !== false) {
-        await this.generateManifest(
-          this.config.manifestOutputPath,
-          manifestEntries
-        );
+    return this.handleResponse(response);
+  }
+  async updateFile(knowledgeId, fileId) {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/knowledge/${knowledgeId}/file/update`,
+      {
+        body: JSON.stringify({ file_id: fileId }),
+        headers: this.jsonHeaders,
+        method: "POST"
       }
-      if (this.config.generateBulkZip !== false) {
-        await this.generateBulkZip(
-          this.config.manifestOutputPath,
-          manifestEntries
-        );
+    );
+    return this.handleResponse(response);
+  }
+  async removeFile(knowledgeId, fileId, deleteFile = true) {
+    const params = new URLSearchParams({ delete_file: String(deleteFile) });
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/knowledge/${knowledgeId}/file/remove?${params}`,
+      {
+        body: JSON.stringify({ file_id: fileId }),
+        headers: this.jsonHeaders,
+        method: "POST"
       }
-    }
-    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`
     );
+    return this.handleResponse(response);
   }
-  computeAggregateHash(entries) {
-    const sortedHashes = entries.map((e) => e.md5).sort().join("");
-    return computeMd5(sortedHashes);
+  async delete(id) {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/knowledge/${id}/delete`,
+      {
+        headers: this.headers,
+        method: "DELETE"
+      }
+    );
+    return this.handleResponse(response);
   }
-  async generateManifest(outputPath, entries) {
-    const aggregateHash = this.computeAggregateHash(entries);
-    const totalSize = entries.reduce((sum, e) => sum + e.size, 0);
-    const manifest = {
-      aggregateHash,
-      baseUrl: this.config.baseUrl,
-      files: entries,
-      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      totalFiles: entries.length,
-      totalSize,
-      version: 1
-    };
-    await mkdir2(outputPath, { recursive: true }).catch(() => {
-    });
-    await writeFile3(
-      join3(outputPath, "manifest.json"),
-      JSON.stringify(manifest, null, 2),
-      "utf-8"
+  async reset(id) {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/knowledge/${id}/reset`,
+      {
+        headers: this.jsonHeaders,
+        method: "POST"
+      }
     );
-    return manifest;
+    return this.handleResponse(response);
   }
-  async generateBulkZip(outputPath, entries) {
-    await mkdir2(outputPath, { recursive: true }).catch(() => {
-    });
-    const zipPath = join3(outputPath, "bulk.zip");
-    const zip = new AdmZip();
-    for (const entry of entries) {
-      const filePath = join3(this.config.outputPath, entry.path);
-      const content = await readFile(filePath);
-      zip.addFile(entry.path, content);
-    }
-    zip.writeZip(zipPath);
+  async addFilesBatch(knowledgeId, fileIds) {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/knowledge/${knowledgeId}/files/batch/add`,
+      {
+        body: JSON.stringify(fileIds.map((file_id) => ({ file_id }))),
+        headers: this.jsonHeaders,
+        method: "POST"
+      }
+    );
+    return this.handleResponse(response);
   }
 };
-async function generate(config2) {
-  const generator = new KnowledgeGenerator(config2);
-  return generator.run();
-}
-function addGenerateKnowledgeCommand() {
-  program.description("Generate llms.txt from QUI Docs documentation").command("generate-llms-txt").option("-n, --name <name>", "Project name for llms.txt header").requiredOption("-m, --output-mode <outputMode>").option("-o, --outputPath <outputPath>", "Output file or directory.").option(
-    "-d, --description <description>",
-    "Project description for llms.txt"
-  ).option("-v, --verbose", "Enable verbose logging", false).option(
-    "--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).option(
-    "-e, --environment <environments>",
-    "Comma-separated list of environments to generate (default: all)"
-  ).action(async (options) => {
+
+// src/ai-knowledge/open-web-ui/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").requiredOption("-e, --environment <environments>", "environment to load").action(async (opts) => {
     loadEnv();
-    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
-    });
-    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)`
-      );
+    const env = opts.environment;
+    dotenv.config({ path: `.env.${env}` });
+    await mkdir2(opts.outputDir, { recursive: true }).catch();
+    const config3 = getConfigFromEnv();
+    const apiConfig = { apiKey: config3.webUiKey, baseUrl: config3.webUiUrl };
+    const knowledgeApi = new KnowledgeApi(apiConfig);
+    const filesApi = new FilesApi(apiConfig);
+    const knowledge = await knowledgeApi.getById(config3.knowledgeId);
+    for (const file of knowledge.files ?? []) {
+      const fileName = file.meta?.name;
+      if (!fileName) {
+        continue;
+      }
+      try {
+        const content = await filesApi.getDataContent(file.id);
+        if (content?.content) {
+          await writeFile2(
+            resolve5(opts.outputDir, fileName),
+            content.content,
+            "utf-8"
+          );
+        }
+      } catch {
+        console.warn(`Failed to download ${fileName}`);
+      }
     }
   });
 }
 
-// src/open-web-ui-knowledge/upload-knowledge.ts
+// src/ai-knowledge/open-web-ui/upload-knowledge.ts
 import { createHash as createHash3 } from "node:crypto";
 import { writeFileSync } from "node:fs";
-import { access as access2, readdir as readdir2, readFile as readFile2, stat as stat2 } from "node:fs/promises";
-import { resolve as resolve5 } from "node:path";
+import { access as access2, readdir as readdir2, readFile as readFile5, stat as stat2 } from "node:fs/promises";
+import { resolve as resolve6 } from "node:path";
 import { setTimeout as setTimeout2 } from "node:timers/promises";
 import ora from "ora";
 
-// src/open-web-ui-knowledge/knowledge-cleaner.ts
+// src/ai-knowledge/open-web-ui/common.ts
+import { config as config2 } from "dotenv";
+function loadOpenWebUiEnv(integration, integrationName) {
+  const envFilePath = integration.envFile ?? `.env.${integration.id}`;
+  config2({ override: true, path: envFilePath, quiet: true });
+  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
+  };
+}
+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/ai-knowledge/open-web-ui/knowledge-cleaner.ts
 var KnowledgeCleaner = class {
   filesApi;
   knowledgeApi;
-  constructor(config2) {
+  constructor(config3) {
     const apiConfig = {
-      apiKey: config2.webUiKey,
-      baseUrl: config2.webUiUrl
+      apiKey: config3.webUiKey,
+      baseUrl: config3.webUiUrl
     };
     this.filesApi = new FilesApi(apiConfig);
     this.knowledgeApi = new KnowledgeApi(apiConfig);
@@ -6953,7 +7315,7 @@ var KnowledgeCleaner = class {
   }
 };
 
-// src/open-web-ui-knowledge/upload-knowledge.ts
+// src/ai-knowledge/open-web-ui/upload-knowledge.ts
 function toKnowledgeFile(file) {
   return {
     id: file.id,
@@ -6971,15 +7333,15 @@ var Uploader = class {
   fileHashCache = /* @__PURE__ */ new Map();
   knowledgeFilesCache = null;
   cleaner;
-  constructor(config2) {
-    this.config = config2;
+  constructor(config3) {
+    this.config = config3;
     const apiConfig = {
-      apiKey: config2.webUiKey,
-      baseUrl: config2.webUiUrl
+      apiKey: config3.webUiKey,
+      baseUrl: config3.webUiUrl
     };
     this.knowledgeApi = new KnowledgeApi(apiConfig);
     this.filesApi = new FilesApi(apiConfig);
-    this.cleaner = new KnowledgeCleaner(config2);
+    this.cleaner = new KnowledgeCleaner(config3);
   }
   async buildHashCache(files) {
     const results = await Promise.allSettled(
@@ -7048,11 +7410,15 @@ var Uploader = class {
     return { success: false };
   }
   async uploadDirectory() {
-    const fileNames = await readdir2(this.config.knowledgeFilePath);
+    const allFileNames = await readdir2(this.config.knowledgeFilePath);
+    const allowedExtensions = [".md", ".mdx", ".txt", ".pdf"];
+    const fileNames = allFileNames.filter(
+      (name) => allowedExtensions.some((ext) => name.endsWith(ext))
+    );
     const files = await Promise.all(
       fileNames.map(async (name) => ({
-        contents: await readFile2(
-          resolve5(this.config.knowledgeFilePath, name),
+        contents: await readFile5(
+          resolve6(this.config.knowledgeFilePath, name),
           "utf-8"
         ),
         name
@@ -7103,8 +7469,8 @@ var Uploader = class {
     if (knowledgeFile) {
       try {
         const fileId = knowledgeFile.id;
-        const fileString = await readFile2(
-          resolve5(this.config.knowledgeFilePath, name),
+        const fileString = await readFile5(
+          resolve6(this.config.knowledgeFilePath, name),
           "utf-8"
         );
         const spinner2 = ora(`Updating ${name}`).start();
@@ -7118,8 +7484,8 @@ var Uploader = class {
       }
     }
     const spinner = ora(`Uploading ${name}`).start();
-    const fileBuffer = await readFile2(
-      resolve5(this.config.knowledgeFilePath, name)
+    const fileBuffer = await readFile5(
+      resolve6(this.config.knowledgeFilePath, name)
     );
     let uploadedFileId = void 0;
     try {
@@ -7157,7 +7523,7 @@ var Uploader = class {
     }
   }
   async uploadKnowledge() {
-    const resolvedPath = resolve5(this.config.knowledgeFilePath);
+    const resolvedPath = resolve6(this.config.knowledgeFilePath);
     if (!await access2(resolvedPath).then(() => true).catch(() => false)) {
       throw new Error(`File or folder not found at ${resolvedPath}`);
     }
@@ -7244,7 +7610,7 @@ Uploaded to ${successCount} integration(s)${failureCount > 0 ? `, ${failureCount
     const files = await uploader.filesApi.search("*");
     console.debug(`found ${files.length} files`);
     writeFileSync(
-      resolve5(uploader.config.knowledgeFilePath, "files.json"),
+      resolve6(uploader.config.knowledgeFilePath, "files.json"),
       JSON.stringify(files, null, 2),
       "utf-8"
     );
@@ -7286,18 +7652,72 @@ Uploaded to ${successCount} integration(s)${failureCount > 0 ? `, ${failureCount
   });
 }
 
+// src/docs-plugin/generate-page-map.ts
+import { glob } from "glob";
+import { writeFile as writeFile3 } from "node:fs/promises";
+import { resolve as resolve7 } from "node:path";
+import { cwd } from "node:process";
+function addGeneratePageMapCommand() {
+  program.command("generate-page-map").description(
+    "Invokes the docs-plugin once to build the site data and writes it to json"
+  ).option(
+    "-c, --config-file <configFile>",
+    "Path to the qui-docs.config.ts config file"
+  ).option(
+    "-r, --routes-dir <routesDir>",
+    "Path to the routes directory",
+    "src/routes"
+  ).option(
+    "-o, --output <output>",
+    "Output path for the site data json",
+    "site-data.json"
+  ).action(async (options) => {
+    try {
+      const configLoader = new ConfigLoader({ configFile: options.configFile });
+      const resolvedConfig = configLoader.loadConfig();
+      const routesDir = fixPath(
+        resolve7(resolvedConfig.appDirectory, resolvedConfig.pageDirectory)
+      );
+      const indexer = new SearchIndexer({
+        ...resolvedConfig,
+        srcDir: fixPath(resolve7(cwd(), resolvedConfig.appDirectory)),
+        typeDocProps: {}
+      });
+      const files = glob.sync(
+        [`${routesDir}/**/*.mdx`, `${routesDir}/**/*.tsx`],
+        {
+          absolute: true,
+          cwd: cwd()
+        }
+      );
+      indexer.buildIndex(files, true);
+      await writeFile3(
+        resolve7(cwd(), options.output),
+        JSON.stringify(indexer.pageMap, null, 2),
+        "utf-8"
+      );
+    } catch (error) {
+      console.error(
+        "Generate Site Data Error:",
+        error instanceof Error ? error.message : String(error)
+      );
+      process.exit(1);
+    }
+  });
+}
+
 // src/react-demo-plugin/generate-lazy-demo-map.ts
 import { glob as glob2 } from "glob";
 import { uniqBy } from "lodash-es";
 import { writeFile as writeFile4 } from "node:fs/promises";
-import { resolve as resolve7 } from "node:path";
+import { resolve as resolve9 } from "node:path";
 import { dedent } from "@qualcomm-ui/utils/dedent";
 
 // src/react-demo-plugin/demo-plugin-utils.ts
 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";
+import { dirname as dirname4, join as join7, relative as relative3, resolve as resolve8, sep } from "node:path";
+import * as ts2 from "typescript";
 import { pascalCase } from "@qualcomm-ui/utils/change-case";
 function extractPageId(filePath, routesDir) {
   const relativePath = relative3(routesDir, filePath);
@@ -7306,7 +7726,7 @@ function extractPageId(filePath, routesDir) {
     const demosIndex = pathParts.indexOf("demos");
     return pathParts.slice(0, demosIndex).join(sep);
   }
-  return dirname2(relativePath);
+  return dirname4(relativePath);
 }
 function isDemoFile(filePath) {
   try {
@@ -7353,7 +7773,7 @@ function generateLazyDemoLoader(demoPages) {
 }
 async function generateLazyDemoMap(options) {
   const routesDir = options.routesDir;
-  const outputPath = resolve7(options.output);
+  const outputPath = resolve9(options.output);
   console.log(`Scanning for demo pages in: ${routesDir}`);
   const demoPages = await scanForDemoPages({ routesDir });
   console.log(`Found ${demoPages.length} pages with demos`);