@qualcomm-ui/mdx-vite 2.5.1 → 2.5.3

package/dist/cli.js

@@ -5168,138 +5168,359 @@ function addGeneratePageMapCommand() {
 import { mkdir, writeFile as writeFile2 } from "node:fs/promises";
 import { resolve as resolve2 } from "node:path";
 
-// src/open-web-ui-knowledge/common.ts
-import { config } from "dotenv";
-function loadEnv() {
-  const options = program.optsWithGlobals();
-  console.debug(options);
-  if (options.env) {
-    config({ path: options.env });
-  } else {
-    config();
-  }
-}
-function getConfigFromEnv() {
-  const openWebUiUrl = process.env.WEB_UI_URL;
-  const openWebUiKey = process.env.WEB_UI_KEY;
-  const knowledgeId = process.env.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
-  };
+// src/open-web-ui-knowledge/api.ts
+function isErrorResponse(response) {
+  return typeof response === "object" && response !== null && "detail" in response;
 }
-var KnowledgeApi = class {
+var FilesApi = class {
   config;
-  knowledgeCache = null;
   constructor(config2) {
     this.config = config2;
   }
   get headers() {
     return {
-      Authorization: `Bearer ${this.config.webUiKey}`
+      Authorization: `Bearer ${this.config.apiKey}`
     };
   }
-  async listKnowledgeFiles() {
-    if (this.knowledgeCache) {
-      return this.knowledgeCache;
+  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 knowledge = await fetch(
-      `${this.config.webUiUrl}/api/v1/knowledge/${this.config.knowledgeId}`,
+    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,
-          Accept: "application/json"
-        }
+        headers: this.headers
       }
-    ).then((res) => res.json());
-    if ("detail" in knowledge) {
-      throw new Error(knowledge.detail);
-    } else {
-      this.knowledgeCache = knowledge;
+    );
+    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((resolve9) => setTimeout(resolve9, intervalMs));
     }
-    return this.knowledgeCache;
+    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 downloadFile(fileId) {
-    const fileResponse = await fetch(
-      `${this.config.webUiUrl}/api/v1/files/${fileId}`,
+  async updateDataContent(id, content) {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/files/${id}/data/content/update`,
       {
-        headers: {
-          ...this.headers,
-          Accept: "application/json"
-        }
+        body: JSON.stringify({ content }),
+        headers: this.jsonHeaders,
+        method: "POST"
       }
-    ).then((res) => res.json());
-    return fileResponse?.data?.content ?? "";
+    );
+    return this.handleResponse(response);
   }
-  async removeKnowledgeFile(id) {
+  async getContent(id, asAttachment = false) {
+    const params = new URLSearchParams({ attachment: String(asAttachment) });
     return fetch(
-      `${this.config.webUiUrl}/api/v1/knowledge/${this.config.knowledgeId}/file/remove`,
+      `${this.config.baseUrl}/api/v1/files/${id}/content?${params}`,
       {
-        body: JSON.stringify({ file_id: id }),
-        headers: {
-          ...this.headers,
-          "Content-Type": "application/json"
-        },
-        method: "POST"
+        headers: this.headers
       }
-    ).then((res) => res.json());
+    );
   }
-  async deleteFile(id) {
-    return fetch(`${this.config.webUiUrl}/api/v1/files/${id}`, {
-      headers: {
-        ...this.headers,
-        "Content-Type": "application/json"
-      },
+  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"
-    }).then((res) => res.json());
+    });
+    return this.handleResponse(response);
   }
-  async uploadFile(fileBuffer, name) {
-    const formData = new FormData();
-    formData.append("file", new Blob([fileBuffer]), name);
-    formData.append("knowledge_id", this.config.knowledgeId);
-    return fetch(`${this.config.webUiUrl}/api/v1/files/`, {
-      body: formData,
-      headers: {
-        ...this.headers,
-        Accept: "application/json"
-      },
-      method: "POST"
-    }).then((res) => res.json());
+};
+var KnowledgeApi = class {
+  config;
+  constructor(config2) {
+    this.config = config2;
   }
-  async associateFile(fileId) {
-    return fetch(
-      `${this.config.webUiUrl}/api/v1/knowledge/${this.config.knowledgeId}/file/add`,
+  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 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
+      }
+    );
+    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 this.handleResponse(response);
+  }
+  async reindex() {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/knowledge/reindex`,
+      {
+        headers: this.jsonHeaders,
+        method: "POST"
+      }
+    );
+    return this.handleResponse(response);
+  }
+  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"
+      }
+    );
+    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"
+      }
+    );
+    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"
+      }
+    );
+    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.headers,
-          "Content-Type": "application/json"
-        },
+        headers: this.jsonHeaders,
+        method: "POST"
+      }
+    );
+    return this.handleResponse(response);
+  }
+  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 reset(id) {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/knowledge/${id}/reset`,
+      {
+        headers: this.jsonHeaders,
+        method: "POST"
+      }
+    );
+    return this.handleResponse(response);
+  }
+  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"
       }
-    ).then((res) => res.json());
+    );
+    return this.handleResponse(response);
   }
 };
 
+// src/open-web-ui-knowledge/common.ts
+import { config } from "dotenv";
+function loadEnv() {
+  const options = program.optsWithGlobals();
+  console.debug(options);
+  if (options.env) {
+    config({ path: options.env });
+  } else {
+    config();
+  }
+}
+function getConfigFromEnv() {
+  const openWebUiUrl = process.env.WEB_UI_URL;
+  const openWebUiKey = process.env.WEB_UI_KEY;
+  const knowledgeId = process.env.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
+  };
+}
+
 // src/open-web-ui-knowledge/download-knowledge.ts
 function addDownloadKnowledgeCommand() {
   program.command("download-knowledge").description("Download files from an Open Web UI knowledge base").requiredOption("-o, --output-dir <outputDir>", "Folder path").action(async (opts) => {
     loadEnv();
     await mkdir(opts.outputDir, { recursive: true }).catch();
-    const api = new KnowledgeApi(getConfigFromEnv());
-    const knowledge = await api.listKnowledgeFiles();
-    for (const file of knowledge.files) {
-      const data = await api.downloadFile(file.id);
-      if (data) {
-        await writeFile2(
-          resolve2(opts.outputDir, file.meta.name),
-          data,
-          "utf-8"
-        );
+    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;
+      }
+      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}`);
       }
     }
   });
@@ -5545,13 +5766,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 +5786,6 @@ function loadKnowledgeConfigFromEnv(options) {
     baseUrl: options.baseUrl || process.env.DOCS_SITE_BASE_URL,
     docPropsPath: resolvedConfig.typeDocProps,
     exclude,
-    knowledgeId,
     outputPath,
     pageTitlePrefix: prefix,
     routeDir
@@ -5580,95 +5796,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 +5809,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 +5853,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 +5878,675 @@ var replaceNpmInstallTabs = () => {
     done();
   };
 };
-function replaceTypeDocProps(docProps, verbose) {
-  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"
+function getPath(obj, path) {
+  return path.split(".").reduce(
+    (acc, key) => acc && typeof acc === "object" ? acc[key] : void 0,
+    obj
+  );
+}
+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(
+        () => {
+        }
+      );
+    }
+    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`
+        );
+      }
+      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);
+        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"}`);
+        }
+      }
+      for (const entry of entries) {
+        const fullPath = join3(dirPath, entry.name);
+        const stats = await stat(fullPath);
+        if (stats.isDirectory()) {
+          await scanDirectory(fullPath);
+        }
+      }
+    };
+    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;
+          continue;
         }
-        const propsNames = extractNamesFromAttribute(nameAttr);
-        if (propsNames.length === 0) {
-          if (parent && index !== void 0) {
-            parent.children.splice(index, 1);
+        const importContent = await readFile(resolvedPath, "utf-8");
+        modules.push({
+          content: importContent,
+          path: resolvedPath
+        });
+        const nestedModules = await this.collectRelativeImports(
+          resolvedPath,
+          visited
+        );
+        modules.push(...nestedModules);
+      }
+    } 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()}`);
           }
-          return;
         }
-        const propsName = propsNames[0];
-        const componentProps = docProps.props[propsName];
-        if (!componentProps) {
-          if (verbose) {
-            console.log(`  TypeDocProps not found: ${propsName}`);
+      }
+    }
+    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;
           }
-          if (parent && index !== void 0) {
-            parent.children.splice(index, 1);
+        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.
+   */
+  async replaceThemeNodes() {
+    let themes = null;
+    try {
+      themes = await import("@qualcomm-ui/tailwind-plugin/theme");
+    } catch {
+      return () => {
+      };
+    }
+    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);
+      },
+      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) => {
+      visit7(tree, "mdxJsxFlowElement", (node) => {
+        const handler = node.name && handlers[node.name];
+        if (!handler) {
           return;
         }
-        const propsDoc = extractProps(componentProps, Boolean(isPartial));
-        if (verbose) {
-          console.log(
-            `  Replaced TypeDocProps ${propsName} with API documentation`
-          );
+        const data = handler(node);
+        if (!data) {
+          console.warn(`No theme data for ${node.name}`);
+          return;
         }
         Object.assign(node, {
           lang: "json",
           meta: null,
           type: "code",
-          value: JSON.stringify(propsDoc, null, 2)
+          value: JSON.stringify(data, null, 2)
         });
-      }
+      });
+      done();
+    };
+  }
+  getAttrExpression(node, name) {
+    const attr = node.attributes?.find(
+      (a) => a.type === "mdxJsxAttribute" && a.name === name
     );
-    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;
-        }
-        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 (!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;
+  }
+  /**
+   * 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(await this.replaceThemeNodes()).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}`);
-    }
-    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 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;
+    }
   }
-}
-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
-    );
-    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}`
+        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;
+      })
     );
-    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,32 +6568,132 @@ 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 { writeFileSync } from "node:fs";
+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";
+
+// src/open-web-ui-knowledge/knowledge-cleaner.ts
+var KnowledgeCleaner = class {
+  filesApi;
+  knowledgeApi;
+  constructor(config2) {
+    const apiConfig = {
+      apiKey: config2.webUiKey,
+      baseUrl: config2.webUiUrl
+    };
+    this.filesApi = new FilesApi(apiConfig);
+    this.knowledgeApi = new KnowledgeApi(apiConfig);
+  }
+  async cleanUpOrphanedFiles() {
+    const files = await this.filesApi.list();
+    const knowledgeBases = await this.knowledgeApi.list();
+    const knowledgeIds = knowledgeBases.map((k) => k.id);
+    for (const file of files) {
+      const collectionName = file.meta?.collection_name;
+      if (collectionName && !knowledgeIds.includes(collectionName)) {
+        await this.filesApi.delete(file.id);
+      } else if (file.data?.status === "failed") {
+        await this.filesApi.delete(file.id);
+      }
+    }
+  }
+};
+
+// src/open-web-ui-knowledge/upload-knowledge.ts
+function toKnowledgeFile(file) {
+  return {
+    id: file.id,
+    meta: { name: file.meta?.name }
+  };
+}
 function calculateFileHash(fileData) {
   const normalized = fileData.normalize("NFC").replace(/\r\n/g, "\n").replace(/\r/g, "\n").replace(/\n+$/, "");
   return createHash2("sha256").update(normalized).digest("hex");
 }
 var Uploader = class {
   config;
-  api;
+  knowledgeApi;
+  filesApi;
+  fileHashCache = /* @__PURE__ */ new Map();
+  knowledgeFilesCache = null;
+  cleaner;
   constructor(config2) {
     this.config = config2;
-    this.api = new KnowledgeApi(config2);
-  }
-  get headers() {
-    return {
-      Authorization: `Bearer ${this.config.webUiKey}`
+    const apiConfig = {
+      apiKey: config2.webUiKey,
+      baseUrl: config2.webUiUrl
     };
+    this.knowledgeApi = new KnowledgeApi(apiConfig);
+    this.filesApi = new FilesApi(apiConfig);
+    this.cleaner = new KnowledgeCleaner(config2);
+  }
+  async buildHashCache(files) {
+    const results = await Promise.allSettled(
+      files.map(async (f) => {
+        try {
+          const content = await this.filesApi.getDataContent(f.id);
+          if (content?.content) {
+            this.fileHashCache.set(f.id, calculateFileHash(content.content));
+          }
+        } catch {
+        }
+      })
+    );
+    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.knowledgeApi.getById(this.config.knowledgeId);
+      const stillExists = (knowledge.files ?? []).some((f) => f.id === fileId);
+      if (!stillExists) {
+        this.fileHashCache.delete(fileId);
+        spinner.succeed(`File deleted: ${fileId}`);
+        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.error?.detail?.includes("Duplicate content detected")) {
+        console.warn(
+          `Duplicate content: ${name} is already in knowledge base, skipping`
+        );
+        if (result.error.fileId) {
+          try {
+            console.debug(`Removing duplicate file: ${result.error.fileId}`);
+            await this.filesApi.delete(result.error.fileId);
+            await this.waitForFileDeletion(result.error.fileId, name);
+          } catch (e) {
+            console.debug("Failed to remove duplicate file", e);
+          }
+        }
+        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 };
   }
   async uploadDirectory() {
     const fileNames = await readdir2(this.config.knowledgeFilePath);
@@ -6314,32 +6706,28 @@ var Uploader = class {
         name
       }))
     );
-    const skippedFiles = [];
+    const knowledge = await this.knowledgeApi.getById(this.config.knowledgeId);
+    this.knowledgeFilesCache = (knowledge.files ?? []).map(toKnowledgeFile);
+    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 +6735,69 @@ 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
-    );
+  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 };
+      }
+    }
     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,
+      try {
+        const fileId = knowledgeFile.id;
+        const fileString = await readFile2(
+          resolve6(this.config.knowledgeFilePath, name),
           "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 };
-          }
-        }
+        const spinner2 = ora(`Updating ${name}`).start();
+        await this.filesApi.updateDataContent(fileId, fileString);
+        spinner2.succeed(`Updated ${name}`);
+        return { success: true };
+      } catch (e) {
+        console.warn(`Failed to update existing file ${name}:`, e);
+        return { success: false };
       }
     }
+    const spinner = ora(`Uploading ${name}`).start();
     const fileBuffer = await readFile2(
       resolve6(this.config.knowledgeFilePath, name)
     );
-    if (knowledgeFile) {
-      await this.api.removeKnowledgeFile(knowledgeFile.id);
-      console.log(`Removed existing file: ${name}`);
-    }
-    const spinner = ora(`Uploading ${name}`).start();
-    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 };
-    }
-    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`);
-      return { success: true };
-    } else {
-      spinner.fail(`Failed to associate ${name} with knowledge base`);
-      console.debug(addResponse);
-      return { count: count + 1, success: false };
+    let uploadedFileId = void 0;
+    try {
+      const uploadResponse = await this.filesApi.upload(fileBuffer, name, {
+        processInBackground: false
+      });
+      uploadedFileId = uploadResponse.id;
+      if (!uploadResponse.id || !uploadResponse.filename) {
+        spinner.fail(`Error uploading ${name}`);
+        return {
+          error: { fileId: uploadResponse.id, uploadResponse },
+          success: false
+        };
+      }
+      spinner.text = `Associating ${name} with knowledge base`;
+      const addResponse = await this.knowledgeApi.addFile(
+        this.config.knowledgeId,
+        uploadResponse.id
+      );
+      if (addResponse.name) {
+        spinner.succeed(`${name} associated with knowledge base`);
+        this.fileHashCache.set(uploadResponse.id, contentHash);
+        return { success: true };
+      } else {
+        spinner.stop();
+        return {
+          error: { addResponse, fileId: uploadResponse.id },
+          success: false
+        };
+      }
+    } catch (e) {
+      spinner.fail(`Error uploading ${name}`);
+      const detail = e instanceof Error ? e.message : String(e);
+      return { error: { detail, fileId: uploadedFileId }, success: false };
     }
   }
   async uploadKnowledge() {
@@ -6419,35 +6809,84 @@ var Uploader = class {
     if (stats.isDirectory()) {
       return this.uploadDirectory();
     } else {
+      console.error("Not a directory, can't upload.");
     }
   }
 };
 function addUploadKnowledgeCommand() {
-  program.name("upload-knowledge").description("Upload files to OpenWebUI knowledge base").command("upload-knowledge").option("-p, --path <path>", "Path to file or folder relative to script").option(
-    "--force",
-    "force upload files, even if their contents have not changed"
-  ).action(async (options) => {
-    loadEnv();
+  function getUploader(knowledgePath, forceUpload) {
     const sharedConfig = getConfigFromEnv();
-    const knowledgeFilePath = options.path || process.env.KNOWLEDGE_OUTPUT_PATH;
+    const knowledgeFilePath = knowledgePath || process.env.KNOWLEDGE_OUTPUT_PATH;
     if (!knowledgeFilePath) {
       throw new Error(
         "KNOWLEDGE_FILE_PATH must be set or provided as the --path option"
       );
     }
-    const uploader = new Uploader({
+    return new Uploader({
       ...sharedConfig,
-      force: options.force || false,
+      force: forceUpload,
       knowledgeFilePath
     });
-    return uploader.uploadKnowledge();
+  }
+  program.name("upload-knowledge").description("Upload files to OpenWebUI knowledge base").command("upload-knowledge").option("-p, --path <path>", "Path to file or folder relative to script").option(
+    "--force",
+    "force upload files, even if their contents have not changed"
+  ).action(async (options) => {
+    loadEnv();
+    return getUploader(options.path, options.force).uploadKnowledge();
+  });
+  program.command("get-knowledge-files").description("Get files from OpenWebUI knowledge base").option("-p, --path <path>", "Path to file or folder relative to script").action(async (options) => {
+    loadEnv();
+    const uploader = getUploader(options.path);
+    const files = await uploader.filesApi.search("*");
+    console.debug(`found ${files.length} files`);
+    writeFileSync(
+      resolve6(uploader.config.knowledgeFilePath, "files.json"),
+      JSON.stringify(files, null, 2),
+      "utf-8"
+    );
+  });
+  program.command("clear-knowledge").description("Remove all files from the knowledge base collection").action(async () => {
+    loadEnv();
+    const sharedConfig = getConfigFromEnv();
+    const apiConfig = {
+      apiKey: sharedConfig.webUiKey,
+      baseUrl: sharedConfig.webUiUrl
+    };
+    const filesApi = new FilesApi(apiConfig);
+    const knowledgeApi = new KnowledgeApi(apiConfig);
+    const cleaner = new KnowledgeCleaner(sharedConfig);
+    await cleaner.cleanUpOrphanedFiles();
+    const knowledge = await knowledgeApi.getById(sharedConfig.knowledgeId);
+    const knowledgeFiles = knowledge.files ?? [];
+    if (!knowledge) {
+      console.log("Knowledge base not found");
+      return;
+    }
+    const files = await filesApi.list(false).then(
+      (files2) => files2.filter((file) => file.meta?.collection_name === knowledge.id)
+    );
+    if (files.length === 0) {
+      console.log("No files in knowledge base");
+      return;
+    }
+    console.log(`Removing ${files.length} files from knowledge base...`);
+    for (const file of files) {
+      if (knowledgeFiles.some((f) => f.id === file.id)) {
+        await knowledgeApi.removeFile(knowledge.id, file.id, true);
+      } else {
+        await filesApi.delete(file.id);
+      }
+      console.log(`Removed ${file.id}`);
+    }
+    console.log(`Removed ${files.length} files`);
   });
 }
 
 // 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 +6955,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}`);
 }