@qualcomm-ui/mdx-vite 2.5.2 → 2.5.4

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 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 knowledge = await fetch(
-      `${this.config.webUiUrl}/api/v1/knowledge/${this.config.knowledgeId}`,
+    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.knowledgeCache;
+    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 downloadFile(fileId) {
-    const fileResponse = await fetch(
-      `${this.config.webUiUrl}/api/v1/files/${fileId}`,
+  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));
+    }
+    throw new Error(`File processing timed out after ${maxAttempts} attempts`);
+  }
+  async getDataContent(id) {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/files/${id}/data/content`,
+      { headers: this.headers }
+    );
+    return this.handleResponse(response);
+  }
+  async updateDataContent(id, content) {
+    const response = await fetch(
+      `${this.config.baseUrl}/api/v1/files/${id}/data/content/update`,
       {
-        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.headers,
-          "Content-Type": "application/json"
-        },
+        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.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}`);
       }
     }
   });
@@ -5657,6 +5878,12 @@ var replaceNpmInstallTabs = () => {
     done();
   };
 };
+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;
@@ -5919,6 +6146,69 @@ ${codeText}
       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 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(data, null, 2)
+        });
+      });
+      done();
+    };
+  }
+  getAttrExpression(node, name) {
+    const attr = node.attributes?.find(
+      (a) => a.type === "mdxJsxAttribute" && a.name === name
+    );
+    if (!attr?.value) {
+      return null;
+    }
+    if (typeof attr.value === "string") {
+      return attr.value;
+    } else if (typeof attr.value === "object" && "value" in attr.value) {
+      return attr.value.value;
+    }
+    return null;
+  }
   /**
    * Creates a remark plugin that replaces TypeDocProps JSX elements with JSON
    * code blocks containing component prop documentation.
@@ -6088,7 +6378,7 @@ ${codeText}
       /\[([^\]]+)\]\(\.\/#([^)]+)\)/g,
       (_, 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 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");
@@ -6278,29 +6568,76 @@ function addGenerateKnowledgeCommand() {
 
 // src/open-web-ui-knowledge/upload-knowledge.ts
 import { createHash as createHash2 } from "node:crypto";
+import { writeFileSync } from "node:fs";
 import { access as access2, readdir as readdir2, readFile as readFile2, stat as stat2 } from "node:fs/promises";
 import { resolve as 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);
+    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) => {
-        const data = await this.api.downloadFile(f.id);
-        if (data) {
-          this.fileHashCache.set(f.id, calculateFileHash(data));
+        try {
+          const content = await this.filesApi.getDataContent(f.id);
+          if (content?.content) {
+            this.fileHashCache.set(f.id, calculateFileHash(content.content));
+          }
+        } catch {
         }
       })
     );
@@ -6313,11 +6650,11 @@ var Uploader = class {
     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 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 ${fileId} deleted`);
+        spinner.succeed(`File deleted: ${fileId}`);
         return true;
       }
       await setTimeout2(100 * (i + 1));
@@ -6332,10 +6669,19 @@ var Uploader = class {
       if (result.success) {
         return result;
       }
-      if (result.response?.detail?.includes("Duplicate content detected")) {
+      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) {
@@ -6349,11 +6695,6 @@ var Uploader = class {
     console.debug(`Failed to upload ${name}`);
     return { success: false };
   }
-  get headers() {
-    return {
-      Authorization: `Bearer ${this.config.webUiKey}`
-    };
-  }
   async uploadDirectory() {
     const fileNames = await readdir2(this.config.knowledgeFilePath);
     const files = await Promise.all(
@@ -6365,8 +6706,8 @@ var Uploader = class {
         name
       }))
     );
-    const knowledge = await this.api.listKnowledgeFiles();
-    this.knowledgeFilesCache = knowledge.files ?? [];
+    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;
@@ -6405,27 +6746,59 @@ var Uploader = class {
       }
     }
     if (knowledgeFile) {
-      await this.api.removeKnowledgeFile(knowledgeFile.id);
-      await this.waitForFileDeletion(knowledgeFile.id, name);
+      try {
+        const fileId = knowledgeFile.id;
+        const fileString = await readFile2(
+          resolve6(this.config.knowledgeFilePath, name),
+          "utf-8"
+        );
+        const spinner2 = ora(`Updating ${name}`).start();
+        await this.filesApi.updateDataContent(fileId, fileString);
+        await this.knowledgeApi.updateFile(this.config.knowledgeId, fileId);
+        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)
     );
-    const uploadResponse = await this.api.uploadFile(fileBuffer, name);
-    if (!uploadResponse.id || !uploadResponse.filename) {
+    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}`);
-      return { response: uploadResponse, success: false };
-    }
-    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.stop();
-      return { response: addResponse, success: false };
+      const detail = e instanceof Error ? e.message : String(e);
+      return { error: { detail, fileId: uploadedFileId }, success: false };
     }
   }
   async uploadKnowledge() {
@@ -6437,28 +6810,77 @@ 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`);
   });
 }