@qualcomm-ui/mdx-vite 2.5.1 → 2.5.2

package/dist/cli.js

@@ -5545,13 +5545,9 @@ import { dedent } from "@qualcomm-ui/utils/dedent";
 import { existsSync } from "node:fs";
 import { join as join2, resolve as resolve4 } from "node:path";
 function loadKnowledgeConfigFromEnv(options) {
-  const knowledgeId = process.env.KNOWLEDGE_ID;
   const exclude = options.exclude || (process.env.FILE_EXCLUDE_PATTERN ?? "").split(",");
   const outputPath = options.outputPath || process.env.KNOWLEDGE_OUTPUT_PATH;
   const prefix = process.env.PAGE_TITLE_PREFIX;
-  if (!knowledgeId) {
-    throw new Error("Missing required KNOWLEDGE_ID environment variable");
-  }
   if (!outputPath) {
     throw new Error("Missing required outputPath");
   }
@@ -5569,7 +5565,6 @@ function loadKnowledgeConfigFromEnv(options) {
     baseUrl: options.baseUrl || process.env.DOCS_SITE_BASE_URL,
     docPropsPath: resolvedConfig.typeDocProps,
     exclude,
-    knowledgeId,
     outputPath,
     pageTitlePrefix: prefix,
     routeDir
@@ -5580,95 +5575,6 @@ function loadKnowledgeConfigFromEnv(options) {
 async function exists(dirPath) {
   return access(dirPath).then(() => true).catch(() => false);
 }
-async function loadDocProps(routesFolder, docPropsPath, verbose) {
-  const resolvedDocPropsPath = docPropsPath ? await exists(docPropsPath) ? docPropsPath : resolve5(process.cwd(), docPropsPath) : join3(dirname(routesFolder), "doc-props.json");
-  if (!await exists(resolvedDocPropsPath)) {
-    if (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 (verbose) {
-      console.log(`Loaded doc props from: ${resolvedDocPropsPath}`);
-      console.log(`Found ${Object.keys(docProps.props).length} component types`);
-    }
-    return docProps;
-  } catch (error) {
-    if (verbose) {
-      console.log(`Error loading doc props: ${error}`);
-    }
-    return null;
-  }
-}
-function formatComment(comment) {
-  if (!comment) {
-    return "";
-  }
-  const parts = [];
-  if (comment.summary && comment.summary.length > 0) {
-    const summaryText = formatCommentParts(comment.summary);
-    if (summaryText.trim()) {
-      parts.push(summaryText.trim());
-    }
-  }
-  if (comment.blockTags && comment.blockTags.length > 0) {
-    for (const blockTag of comment.blockTags) {
-      const tagContent = 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 parts.join("\n\n");
-}
-function 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 ("tag" in part && part.tag === "@link" && typeof part.target === "string") {
-          return `[${part.text}](${part.target})`;
-        }
-        return part.text;
-    }
-  }).join("").replace(/\n/g, " ").replace(/\s+/g, " ").trim();
-}
-function convertPropInfo(propInfo, isPartial, propType = void 0) {
-  return {
-    name: propInfo.name,
-    type: extractBestType(propInfo),
-    ...propInfo.defaultValue && {
-      defaultValue: cleanDefaultValue(propInfo.defaultValue)
-    },
-    description: formatComment(propInfo.comment || null),
-    propType,
-    required: extractRequired(propInfo, isPartial) || void 0
-  };
-}
 function extractBestType(propInfo) {
   const type = propInfo.resolvedType?.prettyType || propInfo.type;
   return cleanType(type.startsWith("| ") ? type.substring(2) : type);
@@ -5682,121 +5588,20 @@ function cleanType(type) {
 function cleanDefaultValue(defaultValue) {
   return defaultValue.replace(/^\n+/, "").replace(/\n+$/, "").trim();
 }
-async function scanPages(routesFolder, verbose, excludePatterns = [], baseUrl) {
-  const components = [];
-  function shouldExclude(fileOrDir) {
-    const dirName = basename(fileOrDir);
-    return excludePatterns.some((pattern) => {
-      if (pattern.includes("*")) {
-        const regex = new RegExp(`^${pattern.replace(/\*/g, ".*")}$`);
-        return regex.test(dirName);
-      }
-      return dirName === pattern;
-    });
-  }
-  async function scanDirectory(dirPath) {
-    if (shouldExclude(dirPath)) {
-      if (verbose) {
-        console.log(`Excluding directory: ${basename(dirPath)}`);
-      }
-      return;
-    }
-    const entries = await readdir(dirPath, { withFileTypes: true });
-    const mdxFiles = entries.filter(
-      (f) => f.name.endsWith(".mdx") && !shouldExclude(f.name)
-    ) ?? [];
-    for (const mdxFile of mdxFiles) {
-      const demosFolder = entries.find((f) => f.name === "demos");
-      const demosFolderPath = demosFolder ? join3(dirPath, demosFolder.name) : void 0;
-      const segments = getPathSegmentsFromFileName(
-        join3(dirPath, mdxFile.name),
-        routesFolder
-      );
-      const url = getPathnameFromPathSegments(segments);
-      components.push({
-        demosFolder: demosFolderPath,
-        id: segments.join("-").trim(),
-        mdxFile: join3(dirPath, mdxFile.name),
-        name: segments.at(-1),
-        path: dirPath,
-        url: baseUrl ? new URL(url, baseUrl).toString() : void 0
-      });
-      if (verbose) {
-        console.log(`Found component: ${basename(dirPath)}`);
-        console.log(`  Demos folder: ${demosFolderPath || "NOT FOUND"}`);
-      }
-    }
-    for (const entry of entries) {
-      const fullPath = join3(dirPath, entry.name);
-      const stats = await stat(fullPath);
-      if (stats.isDirectory()) {
-        await scanDirectory(fullPath);
-      }
-    }
-  }
-  await scanDirectory(routesFolder);
-  return components;
-}
 function isPreviewLine(trimmedLine) {
   return trimmedLine === "// preview" || /^\{\s*\/\*\s*preview\s*\*\/\s*\}$/.test(trimmedLine) || /^<!--\s*preview\s*-->$/.test(trimmedLine);
 }
-function extractProps(props, isPartial) {
-  const propsInfo = [];
-  if (props.props?.length) {
-    propsInfo.push(
-      ...props.props.map((prop) => convertPropInfo(prop, isPartial))
-    );
-  }
-  if (props.input?.length) {
-    propsInfo.push(
-      ...props.input.map((prop) => convertPropInfo(prop, isPartial, "input"))
-    );
-  }
-  if (props.output?.length) {
-    propsInfo.push(
-      ...props.output.map((prop) => convertPropInfo(prop, isPartial, "output"))
-    );
-  }
-  return propsInfo;
-}
 function removePreviewLines(code) {
   return code.split("\n").filter((line) => !isPreviewLine(line.trim())).join("\n");
 }
-function getIntroLines(pages, projectName, description) {
+function getIntroLines(projectName, description) {
   const lines = [];
   if (projectName) {
     lines.push(`# ${projectName}`);
-    lines.push("");
   }
   if (description) {
-    lines.push(`> ${description}`);
-    lines.push("");
-  }
-  lines.push("## Components and Integrations");
-  lines.push("");
-  for (const page of pages) {
-    const url = page.url ?? `#${kebabCase(page.title)}`;
-    lines.push(`- [${page.title}](${url})`);
-  }
-  return lines.join("\n");
-}
-async function generateLlmsTxt(pages, projectName, description) {
-  const lines = [getIntroLines(pages, projectName, 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("");
+    lines.push(`> ${description}`);
   }
   return lines.join("\n");
 }
@@ -5827,44 +5632,11 @@ async function resolveModulePath(importPath, fromFile) {
   }
   return null;
 }
-async function collectRelativeImports(filePath, visited = /* @__PURE__ */ new Set(), verbose) {
-  const normalizedPath = resolve5(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 (verbose) {
-          console.log(
-            `  Could not resolve import: ${importPath} from ${normalizedPath}`
-          );
-        }
-        continue;
-      }
-      const importContent = await readFile(resolvedPath, "utf-8");
-      modules.push({
-        content: importContent,
-        path: resolvedPath
-      });
-      const nestedModules = await collectRelativeImports(
-        resolvedPath,
-        visited,
-        verbose
-      );
-      modules.push(...nestedModules);
-    }
-  } catch (error) {
-    if (verbose) {
-      console.log(`  Error processing ${normalizedPath}: ${error}`);
-    }
-  }
-  return modules;
+function extractMetadata(metadata) {
+  return (metadata ?? []).map((current) => {
+    const [key, value] = current.split("=");
+    return [key, value];
+  });
 }
 var replaceNpmInstallTabs = () => {
   return (tree, _file, done) => {
@@ -5885,376 +5657,606 @@ var replaceNpmInstallTabs = () => {
     done();
   };
 };
-function replaceTypeDocProps(docProps, verbose) {
-  return () => (tree, _file, done) => {
-    visit7(
-      tree,
-      "mdxJsxFlowElement",
-      (node, index, parent) => {
-        if (node?.name !== "TypeDocProps") {
-          return;
+var KnowledgeGenerator = class {
+  config;
+  docProps = null;
+  constructor(config2) {
+    this.config = config2;
+  }
+  async run() {
+    const extractedMetadata = extractMetadata(this.config.metadata);
+    if (this.config.verbose) {
+      console.log(`Scanning pages in: ${this.config.routeDir}`);
+      if (this.config.exclude?.length) {
+        console.log(`Excluding patterns: ${this.config.exclude.join(", ")}`);
+      }
+    }
+    const [docProps, pages] = await Promise.all([
+      this.loadDocProps(),
+      this.scanPages()
+    ]);
+    this.docProps = docProps;
+    if (pages.length === 0) {
+      console.log("No pages found.");
+      return;
+    }
+    if (this.config.verbose) {
+      console.log(`Found ${pages.length} page(s)`);
+    }
+    const processedPages = [];
+    for (const page of pages) {
+      try {
+        const processed = await this.processComponent(page);
+        processedPages.push(processed);
+      } catch (error) {
+        console.error(`Failed to process page: ${page.name}`);
+        process.exit(1);
+      }
+    }
+    if (this.config.clean) {
+      await rm(this.config.outputPath, { force: true, recursive: true }).catch(
+        () => {
         }
-        const nameAttr = node.attributes?.find(
-          (attr) => attr.type === "mdxJsxAttribute" && attr.name === "name"
+      );
+    }
+    if (this.config.outputMode === "aggregated") {
+      await this.generateAggregatedOutput(processedPages, pages);
+    } else {
+      await mkdir2(this.config.outputPath, { recursive: true }).catch(() => {
+      });
+      await this.generatePerPageExports(
+        pages,
+        processedPages,
+        extractedMetadata
+      );
+    }
+  }
+  async loadDocProps() {
+    const resolvedDocPropsPath = this.config.docPropsPath ? await exists(this.config.docPropsPath) ? this.config.docPropsPath : resolve5(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`
         );
-        const isPartial = node.attributes?.some(
-          (attr) => attr.type === "mdxJsxAttribute" && attr.name === "partial"
+      }
+      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 ?? [];
+    const shouldExclude = (fileOrDir) => {
+      const dirName = basename(fileOrDir);
+      return excludePatterns.some((pattern) => {
+        if (pattern.includes("*")) {
+          const regex = new RegExp(`^${pattern.replace(/\*/g, ".*")}$`);
+          return regex.test(dirName);
+        }
+        return dirName === pattern;
+      });
+    };
+    const scanDirectory = async (dirPath) => {
+      if (shouldExclude(dirPath)) {
+        if (this.config.verbose) {
+          console.log(`Excluding directory: ${basename(dirPath)}`);
+        }
+        return;
+      }
+      const entries = await readdir(dirPath, { withFileTypes: true });
+      const mdxFiles = entries.filter(
+        (f) => f.name.endsWith(".mdx") && !shouldExclude(f.name)
+      ) ?? [];
+      for (const mdxFile of mdxFiles) {
+        const demosFolder = entries.find((f) => f.name === "demos");
+        const demosFolderPath = demosFolder ? join3(dirPath, demosFolder.name) : void 0;
+        const segments = getPathSegmentsFromFileName(
+          join3(dirPath, mdxFile.name),
+          this.config.routeDir
         );
-        if (!docProps || !nameAttr) {
-          if (parent && index !== void 0) {
-            parent.children.splice(index, 1);
-          }
-          return;
+        const url = getPathnameFromPathSegments(segments);
+        components.push({
+          demosFolder: demosFolderPath,
+          id: segments.join("-").trim(),
+          mdxFile: join3(dirPath, mdxFile.name),
+          name: segments.at(-1),
+          path: dirPath,
+          url: this.config.baseUrl ? new URL(url, this.config.baseUrl).toString() : void 0
+        });
+        if (this.config.verbose) {
+          console.log(`Found component: ${basename(dirPath)}`);
+          console.log(`  Demos folder: ${demosFolderPath || "NOT FOUND"}`);
         }
-        const propsNames = extractNamesFromAttribute(nameAttr);
-        if (propsNames.length === 0) {
-          if (parent && index !== void 0) {
-            parent.children.splice(index, 1);
-          }
-          return;
+      }
+      for (const entry of entries) {
+        const fullPath = join3(dirPath, entry.name);
+        const stats = await stat(fullPath);
+        if (stats.isDirectory()) {
+          await scanDirectory(fullPath);
         }
-        const propsName = propsNames[0];
-        const componentProps = docProps.props[propsName];
-        if (!componentProps) {
-          if (verbose) {
-            console.log(`  TypeDocProps not found: ${propsName}`);
-          }
-          if (parent && index !== void 0) {
-            parent.children.splice(index, 1);
+      }
+    };
+    await scanDirectory(this.config.routeDir);
+    return components;
+  }
+  async collectRelativeImports(filePath, visited = /* @__PURE__ */ new Set()) {
+    const normalizedPath = resolve5(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}`
+            );
           }
-          return;
-        }
-        const propsDoc = extractProps(componentProps, Boolean(isPartial));
-        if (verbose) {
-          console.log(
-            `  Replaced TypeDocProps ${propsName} with API documentation`
-          );
+          continue;
         }
-        Object.assign(node, {
-          lang: "json",
-          meta: null,
-          type: "code",
-          value: JSON.stringify(propsDoc, null, 2)
+        const importContent = await readFile(resolvedPath, "utf-8");
+        modules.push({
+          content: importContent,
+          path: resolvedPath
         });
+        const nestedModules = await this.collectRelativeImports(
+          resolvedPath,
+          visited
+        );
+        modules.push(...nestedModules);
       }
-    );
-    done();
-  };
-}
-function replaceDemos(demosFolder, verbose, demoFiles) {
-  return () => async (tree) => {
-    const promises = [];
-    visit7(
-      tree,
-      "mdxJsxFlowElement",
-      (node, index, parent) => {
-        if (!node?.name || !["QdsDemo", "CodeDemo", "Demo"].includes(node.name)) {
-          return;
+    } catch (error) {
+      if (this.config.verbose) {
+        console.log(`  Error processing ${normalizedPath}: ${error}`);
+      }
+    }
+    return modules;
+  }
+  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;
+  }
+  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());
+      }
+    }
+    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()}`);
+          }
         }
-        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;
+      }
+    }
+    return parts.join("\n\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") {
+            return `[${part.text}](${part.target})`;
+          }
+          return part.text;
+      }
+    }).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
+    };
+  }
+  /**
+   * Creates a remark plugin that replaces TypeDocProps JSX elements with JSON
+   * code blocks containing component prop documentation.
+   */
+  replaceTypeDocProps() {
+    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;
           }
-        }
-        if (!demoName) {
-          if (parent && index !== void 0) {
-            parent.children.splice(index, 1);
+          const propsNames = extractNamesFromAttribute(nameAttr);
+          if (propsNames.length === 0) {
+            if (parent && index !== void 0) {
+              parent.children.splice(index, 1);
+            }
+            return;
           }
-          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);
+            }
+            return;
+          }
+          const propsDoc = this.extractProps(componentProps, Boolean(isPartial));
+          if (this.config.verbose) {
+            console.log(
+              `  Replaced TypeDocProps ${propsName} with API documentation`
+            );
+          }
+          Object.assign(node, {
+            lang: "json",
+            meta: null,
+            type: "code",
+            value: JSON.stringify(propsDoc, null, 2)
+          });
         }
-        promises.push(
-          (async () => {
-            const kebabName = kebabCase(demoName);
-            let filePath = `${kebabName}.tsx`;
-            if (!demosFolder) {
-              if (verbose) {
-                console.log(`  No demos folder for ${demoName}`);
-              }
-              if (parent && index !== void 0) {
-                parent.children.splice(index, 1);
+      );
+      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 = [];
+      visit7(
+        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;
               }
-              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 (!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;
               }
-            }
-            try {
-              const demoCode = await readFile(demoFilePath, "utf-8");
-              const cleanedCode = removePreviewLines(demoCode);
-              if (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 (verbose) {
-                console.log(`  Error reading demo ${demoName}: ${error}`);
+              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;
+                }
               }
-              if (parent && index !== void 0) {
-                parent.children.splice(index, 1);
+              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);
+                }
               }
-            }
-          })()
-        );
-      }
-    );
-    await Promise.all(promises);
-  };
-}
-async function processMdxContent(mdxContent, pageUrl, demosFolder, docProps, verbose) {
-  const demoFiles = [];
-  let processedContent = mdxContent;
-  const lines = processedContent.split("\n");
-  const titleLine = lines.findIndex((line) => line.startsWith("# "));
-  processedContent = titleLine >= 0 ? lines.slice(titleLine + 1).join("\n") : processedContent;
-  if (pageUrl) {
+            })()
+          );
+        }
+      );
+      await Promise.all(promises);
+    };
+  }
+  /**
+   * Processes MDX content by transforming JSX elements (TypeDocProps, demos)
+   * into markdown, resolving relative links, and cleaning up formatting.
+   */
+  async processMdxContent(mdxContent, pageUrl, demosFolder) {
+    const demoFiles = [];
+    let processedContent = mdxContent;
+    const lines = processedContent.split("\n");
+    const titleLine = lines.findIndex((line) => line.startsWith("# "));
+    processedContent = titleLine >= 0 ? lines.slice(titleLine + 1).join("\n") : processedContent;
     processedContent = processedContent.replace(
       /\[([^\]]+)\]\(\.\/#([^)]+)\)/g,
-      (_, text, anchor) => `[${text}](${pageUrl}#${anchor})`
+      (_, text, anchor) => pageUrl && this.config.outputMode === "per-page" ? `[${text}](${pageUrl}#${anchor})` : text
     );
+    const processor = unified4().use(remarkParse4).use(remarkMdx3).use(this.replaceTypeDocProps()).use(this.replaceDemos(demosFolder, demoFiles)).use(remarkStringify3);
+    const processed = await processor.process(processedContent);
+    processedContent = String(processed);
+    processedContent = processedContent.replace(/\n\s*\n\s*\n/g, "\n\n");
+    return { content: processedContent, demoFiles };
   }
-  const processor = unified4().use(remarkParse4).use(remarkMdx3).use(replaceTypeDocProps(docProps, verbose)).use(replaceDemos(demosFolder, verbose, demoFiles)).use(remarkStringify3);
-  const processed = await processor.process(processedContent);
-  processedContent = String(processed);
-  processedContent = processedContent.replace(/\n\s*\n\s*\n/g, "\n\n");
-  return { content: processedContent, demoFiles };
-}
-async function processComponent(component, docProps, verbose) {
-  try {
-    const mdxContent = await readFile(component.mdxFile, "utf-8");
-    if (verbose) {
-      console.log(`Processing page: ${component.name}`);
+  async processComponent(component) {
+    try {
+      const mdxContent = await readFile(component.mdxFile, "utf-8");
+      if (this.config.verbose) {
+        console.log(`Processing page: ${component.name}`);
+      }
+      const processor = unified4().use(remarkParse4).use(remarkMdx3).use(replaceNpmInstallTabs).use(remarkFrontmatter3, ["yaml"]).use(remarkParseFrontmatter2);
+      if (this.config.outputMode === "per-page") {
+        processor.use(remarkSelfLinkHeadings(component.url));
+      }
+      processor.use(remarkStringify3);
+      const parsed = await processor.process(mdxContent);
+      const frontmatter = parsed.data?.frontmatter || {};
+      const { content: processedContent, demoFiles } = await this.processMdxContent(
+        String(parsed),
+        component.url,
+        component.demosFolder
+      );
+      const removeJsxProcessor = unified4().use(remarkParse4).use(remarkMdx3).use(remarkRemoveJsx).use(remarkStringify3);
+      const removedJsx = String(
+        await removeJsxProcessor.process(processedContent)
+      );
+      const contentWithoutFrontmatter = removedJsx.replace(
+        /^---[\s\S]*?---\n/,
+        ""
+      );
+      const title = frontmatter.title || component.name;
+      return {
+        content: contentWithoutFrontmatter.trim(),
+        demoFiles,
+        frontmatter,
+        title,
+        url: component.url
+      };
+    } catch (error) {
+      console.error(`Error processing component ${component.name}:`, error);
+      throw error;
     }
-    const processor = unified4().use(remarkParse4).use(remarkMdx3).use(replaceNpmInstallTabs).use(remarkFrontmatter3, ["yaml"]).use(remarkParseFrontmatter2).use(remarkSelfLinkHeadings(component.url)).use(remarkStringify3);
-    const parsed = await processor.process(mdxContent);
-    const frontmatter = parsed.data?.frontmatter || {};
-    const { content: processedContent, demoFiles } = await processMdxContent(
-      String(parsed),
-      component.url,
-      component.demosFolder,
-      docProps,
-      verbose
-    );
-    const removeJsxProcessor = unified4().use(remarkParse4).use(remarkMdx3).use(remarkRemoveJsx).use(remarkStringify3);
-    const removedJsx = String(
-      await removeJsxProcessor.process(processedContent)
-    );
-    const contentWithoutFrontmatter = removedJsx.replace(
-      /^---[\s\S]*?---\n/,
-      ""
-    );
-    const title = frontmatter.title || component.name;
-    return {
-      content: contentWithoutFrontmatter.trim(),
-      demoFiles,
-      frontmatter,
-      title,
-      url: component.url
-    };
-  } catch (error) {
-    console.error(`Error processing component ${component.name}:`, error);
-    throw error;
   }
-}
-async function generatePerPageExports({
-  includeImports,
-  metadata,
-  outputPath,
-  pages,
-  pageTitlePrefix,
-  processedPages,
-  verbose
-}) {
-  await mkdir2(dirname(outputPath), { recursive: true }).catch();
-  const count = processedPages.length;
-  let totalSize = 0;
-  await Promise.all(
-    processedPages.map(async (processedPage, index) => {
-      const page = pages[index];
-      const lines = [];
-      if (metadata.length || page.url) {
-        lines.push("---");
-        if (page.url) {
-          lines.push(`url: ${page.url}`);
-        }
-        if (metadata.length) {
-          for (const [key, value] of metadata) {
-            lines.push(`${key}: ${value}`);
-          }
+  async 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}`;
         }
-        lines.push("---");
-        lines.push("");
+        return line;
+      });
+      if (content.every((line) => !line.trim())) {
+        continue;
       }
-      lines.push(`# ${processedPage.title}`);
+      lines.push(`## ${page.title}`);
       lines.push("");
-      if (processedPage.frontmatter?.title) {
-        page.name = processedPage.frontmatter.title;
-      }
-      let content = processedPage.content;
-      if (pageTitlePrefix) {
-        content = content.replace(
-          `# ${page.name}`,
-          `# ${pageTitlePrefix} ${page.name}`
-        );
-        page.name = `${pageTitlePrefix} ${page.name}`;
-      }
-      lines.push(content);
+      lines.push(content.join("\n"));
       lines.push("");
-      if (includeImports && processedPage.demoFiles.length > 0) {
-        if (verbose) {
-          console.log(
-            `Collecting imports for ${page.name} from ${processedPage.demoFiles.length} demo files`
-          );
+    }
+    return lines.join("\n");
+  }
+  async generateAggregatedOutput(processedPages, pages) {
+    const llmsTxtContent = await this.generateLlmsTxt(processedPages);
+    await mkdir2(dirname(this.config.outputPath), { recursive: true }).catch(
+      () => {
+      }
+    );
+    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} component(s) at: ${this.config.outputPath}`
+    );
+    console.log(`File size: ${outputSizeKb} KB`);
+  }
+  async generatePerPageExports(pages, processedPages, metadata) {
+    await mkdir2(dirname(this.config.outputPath), { recursive: true }).catch(
+      () => {
+      }
+    );
+    const count = processedPages.length;
+    let totalSize = 0;
+    await Promise.all(
+      processedPages.map(async (processedPage, index) => {
+        const page = pages[index];
+        const lines = [];
+        if (metadata.length || page.url) {
+          lines.push("---");
+          if (page.url) {
+            lines.push(`url: ${page.url}`);
+          }
+          if (metadata.length) {
+            for (const [key, value] of metadata) {
+              lines.push(`${key}: ${value}`);
+            }
+          }
+          lines.push("---");
+          lines.push("");
         }
-        const allImports = [];
-        for (const demoFile of processedPage.demoFiles) {
-          const imports = await collectRelativeImports(
-            demoFile,
-            /* @__PURE__ */ new Set(),
-            verbose
+        lines.push(`# ${processedPage.title}`);
+        lines.push("");
+        if (processedPage.frontmatter?.title) {
+          page.name = processedPage.frontmatter.title;
+        }
+        let content = processedPage.content;
+        if (this.config.pageTitlePrefix) {
+          content = content.replace(
+            `# ${page.name}`,
+            `# ${this.config.pageTitlePrefix} ${page.name}`
           );
-          allImports.push(...imports);
+          page.name = `${this.config.pageTitlePrefix} ${page.name}`;
         }
-        const uniqueImports = Array.from(
-          new Map(allImports.map((m) => [m.path, m])).values()
-        );
-        if (verbose) {
-          console.log(
-            `  Collected ${uniqueImports.length} unique import modules`
+        lines.push(content);
+        lines.push("");
+        if (this.config.includeImports && 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 (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("```");
+          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 outfile = `${resolve5(outputPath)}/${kebabCase(page.id || page.name)}.md`;
-      await writeFile3(outfile, lines.join("\n"), "utf-8");
-      const stats = await stat(outfile);
-      totalSize += stats.size / 1024;
-    })
-  );
-  console.log(`Generated ${count} component(s) in ${outputPath}`);
-  console.log(`Folder size: ${totalSize.toFixed(1)} KB`);
-}
-function extractMetadata(metadata) {
-  return (metadata ?? []).map((current) => {
-    const [key, value] = current.split("=");
-    return [key, value];
-  });
-}
-async function generate({
-  baseUrl,
-  clean,
-  description,
-  docPropsPath,
-  exclude,
-  includeImports,
-  metadata,
-  name,
-  outputMode,
-  outputPath,
-  pageTitlePrefix,
-  routeDir,
-  verbose
-}) {
-  const extractedMetadata = extractMetadata(metadata);
-  if (verbose) {
-    console.log(`Scanning pages in: ${routeDir}`);
-    if (exclude?.length) {
-      console.log(`Excluding patterns: ${exclude.join(", ")}`);
-    }
-  }
-  const [docProps, pages] = await Promise.all([
-    loadDocProps(routeDir, docPropsPath, verbose),
-    scanPages(routeDir, verbose, exclude, baseUrl)
-  ]);
-  if (pages.length === 0) {
-    console.log("No pages found.");
-    return;
-  }
-  if (verbose) {
-    console.log(`Found ${pages.length} page(s)`);
-  }
-  const processedPages = [];
-  for (const page of pages) {
-    try {
-      const processed = await processComponent(page, docProps, verbose);
-      processedPages.push(processed);
-    } catch (error) {
-      console.error(`Failed to process page: ${page.name}`);
-      process.exit(1);
-    }
-  }
-  if (clean) {
-    await rm(outputPath, { force: true, recursive: true }).catch();
-  }
-  if (outputMode === "aggregated") {
-    const llmsTxtContent = await generateLlmsTxt(
-      processedPages,
-      name,
-      description
+        const outfile = `${resolve5(this.config.outputPath)}/${kebabCase(page.id || page.name)}.md`;
+        await writeFile3(outfile, lines.join("\n"), "utf-8");
+        const stats = await stat(outfile);
+        totalSize += stats.size / 1024;
+      })
     );
-    await mkdir2(dirname(outputPath), { recursive: true }).catch();
-    await writeFile3(outputPath, llmsTxtContent, "utf-8");
-    const outputStats = await stat(outputPath);
-    const outputSizeKb = (outputStats.size / 1024).toFixed(1);
-    console.log(
-      `Generated ${outputPath} with ${pages.length} component(s) at: ${outputPath}`
-    );
-    console.log(`File size: ${outputSizeKb} KB`);
-  } else {
-    await mkdir2(outputPath, { recursive: true }).catch();
-    await generatePerPageExports({
-      includeImports,
-      metadata: extractedMetadata,
-      outputPath,
-      pages,
-      pageTitlePrefix,
-      processedPages,
-      verbose
-    });
+    console.log(`Generated ${count} component(s) in ${this.config.outputPath}`);
+    console.log(`Folder size: ${totalSize.toFixed(1)} KB`);
   }
+};
+async function generate(config2) {
+  const generator = new KnowledgeGenerator(config2);
+  await 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(
@@ -6276,14 +6278,7 @@ function addGenerateKnowledgeCommand() {
 
 // src/open-web-ui-knowledge/upload-knowledge.ts
 import { createHash as createHash2 } from "node:crypto";
-import {
-  access as access2,
-  mkdir as mkdir3,
-  readdir as readdir2,
-  readFile as readFile2,
-  stat as stat2,
-  writeFile as writeFile4
-} from "node:fs/promises";
+import { access as access2, readdir as readdir2, readFile as readFile2, 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";
@@ -6294,10 +6289,66 @@ function calculateFileHash(fileData) {
 var Uploader = class {
   config;
   api;
+  fileHashCache = /* @__PURE__ */ new Map();
+  knowledgeFilesCache = null;
   constructor(config2) {
     this.config = config2;
     this.api = new KnowledgeApi(config2);
   }
+  async buildHashCache(files) {
+    const results = await Promise.allSettled(
+      files.map(async (f) => {
+        const data = await this.api.downloadFile(f.id);
+        if (data) {
+          this.fileHashCache.set(f.id, calculateFileHash(data));
+        }
+      })
+    );
+    const failures = results.filter((r) => r.status === "rejected");
+    if (failures.length > 0) {
+      console.warn(`Failed to cache ${failures.length} file hashes`);
+    }
+  }
+  async waitForFileDeletion(fileId, fileName, maxAttempts = 15) {
+    const spinner = ora(`File changed, deleting ${fileName}`).start();
+    for (let i = 0; i < maxAttempts; i++) {
+      this.knowledgeFilesCache = null;
+      const knowledge = await this.api.listKnowledgeFiles();
+      const stillExists = (knowledge.files ?? []).some((f) => f.id === fileId);
+      if (!stillExists) {
+        this.fileHashCache.delete(fileId);
+        spinner.succeed(`File ${fileId} deleted`);
+        return true;
+      }
+      await setTimeout2(100 * (i + 1));
+    }
+    spinner.stop();
+    console.debug(`File ${fileId} may not have been fully deleted`);
+    return false;
+  }
+  async uploadWithRetry(name, contents, maxRetries = 10) {
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+      const result = await this.uploadFile(name, contents);
+      if (result.success) {
+        return result;
+      }
+      if (result.response?.detail?.includes("Duplicate content detected")) {
+        console.warn(
+          `Duplicate content: ${name} is already in knowledge base, skipping`
+        );
+        return { skipped: true, success: true };
+      }
+      if (attempt < maxRetries - 1) {
+        const delay = 100 * Math.pow(2, attempt);
+        console.debug(
+          `Retrying ${name} in ${delay}ms (attempt ${attempt + 2}/${maxRetries})`
+        );
+        await setTimeout2(delay);
+      }
+    }
+    console.debug(`Failed to upload ${name}`);
+    return { success: false };
+  }
   get headers() {
     return {
       Authorization: `Bearer ${this.config.webUiKey}`
@@ -6314,32 +6365,28 @@ var Uploader = class {
         name
       }))
     );
-    const skippedFiles = [];
+    const knowledge = await this.api.listKnowledgeFiles();
+    this.knowledgeFilesCache = knowledge.files ?? [];
+    await this.buildHashCache(this.knowledgeFilesCache);
+    let skippedCount = 0;
     let successCount = 0;
     let failureCount = 0;
-    await this.api.listKnowledgeFiles();
     for (const file of files) {
-      let result = await this.uploadFile(file.name, file.contents);
-      while (!result.success && result.count && result.count < 5) {
-        console.debug("Failed to upload, retrying with count: ", result.count);
-        await setTimeout2(100);
-        result = await this.uploadFile(file.name, file.contents, result.count);
-      }
+      const result = await this.uploadWithRetry(file.name, file.contents);
       if (result.skipped) {
-        skippedFiles.push(file.name);
-      }
-      if (result.success) {
+        skippedCount++;
+      } else if (result.success) {
         successCount++;
       } else {
         failureCount++;
       }
     }
-    if (skippedFiles.length > 0) {
+    if (skippedCount > 0) {
       console.debug(
-        `Skipped uploading ${skippedFiles.length} files because their contents did not change`
+        `Skipped uploading ${skippedCount} files because their contents did not change`
       );
     }
-    const uploadCount = successCount - skippedFiles.length;
+    const uploadCount = Math.abs(successCount);
     if (uploadCount) {
       console.debug(`Successfully uploaded ${uploadCount} files`);
     }
@@ -6347,67 +6394,38 @@ var Uploader = class {
       console.debug(`Failed to upload ${failureCount} files`);
     }
   }
-  async uploadFile(name, contents, count = 0) {
-    const knowledge = await this.api.listKnowledgeFiles();
-    const knowledgeFile = (knowledge.files ?? []).find(
-      (f) => f.meta.name === name
-    );
-    if (knowledgeFile) {
-      console.debug("Found existing file:", knowledgeFile?.meta.name);
-      const data = await this.api.downloadFile(knowledgeFile.id);
-      if (!this.config.force && data) {
-        if (calculateFileHash(data) === calculateFileHash(contents)) {
-          return { skipped: true, success: true };
-        }
-        await mkdir3(resolve6(process.cwd(), `./temp/diff`), {
-          recursive: true
-        }).catch();
-        await writeFile4(
-          resolve6(process.cwd(), `./temp/diff/${name}-current.md`),
-          contents,
-          "utf-8"
-        );
-        await writeFile4(
-          resolve6(process.cwd(), `./temp/diff/${name}-owui.md`),
-          data,
-          "utf-8"
-        );
-        const dataLines = data.split("\n");
-        const contentLines = contents.split("\n");
-        if (dataLines.length === contentLines.length) {
-          const allLinesMatch = dataLines.every(
-            (line, i) => line === contentLines[i]
-          );
-          if (allLinesMatch) {
-            return { skipped: true, success: true };
-          }
-        }
+  async uploadFile(name, contents) {
+    const knowledgeFiles = this.knowledgeFilesCache ?? [];
+    const knowledgeFile = knowledgeFiles.find((f) => f.meta.name === name);
+    const contentHash = calculateFileHash(contents);
+    if (knowledgeFile && !this.config.force) {
+      const existingHash = this.fileHashCache.get(knowledgeFile.id);
+      if (existingHash === contentHash) {
+        return { skipped: true, success: true };
       }
     }
-    const fileBuffer = await readFile2(
-      resolve6(this.config.knowledgeFilePath, name)
-    );
     if (knowledgeFile) {
       await this.api.removeKnowledgeFile(knowledgeFile.id);
-      console.log(`Removed existing file: ${name}`);
+      await this.waitForFileDeletion(knowledgeFile.id, name);
     }
     const spinner = ora(`Uploading ${name}`).start();
+    const fileBuffer = await readFile2(
+      resolve6(this.config.knowledgeFilePath, name)
+    );
     const uploadResponse = await this.api.uploadFile(fileBuffer, name);
     if (!uploadResponse.id || !uploadResponse.filename) {
-      spinner.fail(`Error uploading ${name}, exiting`);
-      console.debug(uploadResponse);
-      return { success: false };
+      spinner.fail(`Error uploading ${name}`);
+      return { response: uploadResponse, success: false };
     }
-    await setTimeout2(500);
     spinner.text = `Associating ${name} with knowledge base`;
     const addResponse = await this.api.associateFile(uploadResponse.id);
     if (addResponse.name) {
       spinner.succeed(`${name} associated with knowledge base`);
+      this.fileHashCache.set(uploadResponse.id, contentHash);
       return { success: true };
     } else {
-      spinner.fail(`Failed to associate ${name} with knowledge base`);
-      console.debug(addResponse);
-      return { count: count + 1, success: false };
+      spinner.stop();
+      return { response: addResponse, success: false };
     }
   }
   async uploadKnowledge() {
@@ -6447,7 +6465,7 @@ function addUploadKnowledgeCommand() {
 // src/react-demo-plugin/generate-lazy-demo-map.ts
 import { glob as glob3 } from "glob";
 import { uniqBy } from "lodash-es";
-import { writeFile as writeFile5 } from "node:fs/promises";
+import { writeFile as writeFile4 } from "node:fs/promises";
 import { resolve as resolve8 } from "node:path";
 import { dedent as dedent2 } from "@qualcomm-ui/utils/dedent";
 
@@ -6516,7 +6534,7 @@ async function generateLazyDemoMap(options) {
   const demoPages = await scanForDemoPages({ routesDir });
   console.log(`Found ${demoPages.length} pages with demos`);
   const content = generateLazyDemoLoader(demoPages);
-  await writeFile5(outputPath, content, "utf-8");
+  await writeFile4(outputPath, content, "utf-8");
   console.log(`
 Generated lazy demo loader at: ${outputPath}`);
 }