@larkup/cli 0.2.5 → 0.2.7

package/dist/index.js

@@ -12,18 +12,6 @@ import {
   setActiveServer,
   trackUsageEvent
 } from "./chunk-ZJLA4SIG.js";
-import {
-  getInstalledTool,
-  getInstalledTools,
-  installTool,
-  isToolInstalled,
-  loadTool,
-  uninstallTool
-} from "./chunk-TH2MPRMA.js";
-import {
-  getAllTools,
-  getToolById
-} from "./chunk-P5JVXA7X.js";
 import {
   __require
 } from "./chunk-3RG5ZIWI.js";
@@ -34,7 +22,7 @@ import { Command } from "commander";
 // package.json
 var package_default = {
   name: "@larkup/cli",
-  version: "0.2.5",
+  version: "0.2.7",
   publishConfig: {
     access: "public"
   },
@@ -951,12 +939,12 @@ function addChatProviderDependency(dependencies, provider) {
 }
 
 // ../../packages/core/src/generator/generate-server.ts
-function lang(path14) {
-  if (path14.endsWith(".json")) return "json";
-  if (path14.endsWith(".mjs") || path14.endsWith(".js")) return "javascript";
-  if (path14.endsWith(".md")) return "markdown";
-  if (path14.endsWith("Dockerfile")) return "dockerfile";
-  if (path14.endsWith(".yml") || path14.endsWith(".yaml")) return "yaml";
+function lang(path13) {
+  if (path13.endsWith(".json")) return "json";
+  if (path13.endsWith(".mjs") || path13.endsWith(".js")) return "javascript";
+  if (path13.endsWith(".md")) return "markdown";
+  if (path13.endsWith("Dockerfile")) return "dockerfile";
+  if (path13.endsWith(".yml") || path13.endsWith(".yaml")) return "yaml";
   return "text";
 }
 function lancedbStore() {
@@ -1415,7 +1403,7 @@ const server = createServer(async (req, res) => {
         <svg class="icon" viewBox="0 0 24 24"><path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z"/><polyline points="14 2 14 8 20 8"/><line x1="16" y1="13" x2="8" y2="13"/><line x1="16" y1="17" x2="8" y2="17"/></svg>
         API Reference
       </a>
-      <a href="https://github.com/Larkup-AI/larkup-rag" target="_blank" rel="noopener" class="btn btn-outline">
+      <a href="https://github.com/Larkup-AI/larkup" target="_blank" rel="noopener" class="btn btn-outline">
         <svg class="icon" viewBox="0 0 24 24"><path d="M17 21v-2a4 4 0 0 0-4-4H5a4 4 0 0 0-4 4v2"/><circle cx="9" cy="7" r="4"/><path d="M23 21v-2a4 4 0 0 0-3-3.87"/><path d="M16 3.13a4 4 0 0 1 0 7.75"/></svg>
         Larkup Team
       </a>
@@ -1424,7 +1412,7 @@ const server = createServer(async (req, res) => {
         Contact
       </a>
     </div>
-    <div class="footer">Built with <a href="https://github.com/Larkup-AI/larkup-rag/buddy-rag" target="_blank" rel="noopener">larkup</a> \xB7 v1.0</div>
+    <div class="footer">Built with <a href="https://github.com/Larkup-AI/larkup/buddy-rag" target="_blank" rel="noopener">larkup</a> \xB7 v1.0</div>
   </div>
 </body>
 </html>\`)
@@ -2273,22 +2261,22 @@ function generateServer(config) {
     { path: "README.md", contents: readme(config, server) }
   ].map((f) => ({ ...f, language: lang(f.path) }));
   try {
-    const fs13 = __require("fs");
-    const path14 = __require("path");
-    const faviconPath = path14.resolve(process.cwd(), "public/favicon2.ico");
-    if (fs13.existsSync(faviconPath)) {
+    const fs12 = __require("fs");
+    const path13 = __require("path");
+    const faviconPath = path13.resolve(process.cwd(), "public/favicon2.ico");
+    if (fs12.existsSync(faviconPath)) {
       files.push({
         path: "public/favicon2.ico",
-        contents: fs13.readFileSync(faviconPath).toString("base64"),
+        contents: fs12.readFileSync(faviconPath).toString("base64"),
         language: "ico",
         encoding: "base64"
       });
     } else {
-      const webFaviconPath = path14.resolve(process.cwd(), "apps/web/public/favicon2.ico");
-      if (fs13.existsSync(webFaviconPath)) {
+      const webFaviconPath = path13.resolve(process.cwd(), "apps/web/public/favicon2.ico");
+      if (fs12.existsSync(webFaviconPath)) {
         files.push({
           path: "public/favicon2.ico",
-          contents: fs13.readFileSync(webFaviconPath).toString("base64"),
+          contents: fs12.readFileSync(webFaviconPath).toString("base64"),
           language: "ico",
           encoding: "base64"
         });
@@ -2302,12 +2290,12 @@ function generateServer(config) {
 }
 
 // ../../packages/core/src/generator/generate-agent-server.ts
-function lang2(path14) {
-  if (path14.endsWith(".json")) return "json";
-  if (path14.endsWith(".mjs") || path14.endsWith(".js")) return "javascript";
-  if (path14.endsWith(".md")) return "markdown";
-  if (path14.endsWith("Dockerfile")) return "dockerfile";
-  if (path14.endsWith(".yml") || path14.endsWith(".yaml")) return "yaml";
+function lang2(path13) {
+  if (path13.endsWith(".json")) return "json";
+  if (path13.endsWith(".mjs") || path13.endsWith(".js")) return "javascript";
+  if (path13.endsWith(".md")) return "markdown";
+  if (path13.endsWith("Dockerfile")) return "dockerfile";
+  if (path13.endsWith(".yml") || path13.endsWith(".yaml")) return "yaml";
   return "text";
 }
 function lancedbStore2() {
@@ -3321,22 +3309,22 @@ function generateAgentServer(config) {
     { path: "README.md", contents: readme2(config, server) }
   ].map((f) => ({ ...f, language: lang2(f.path) }));
   try {
-    const fs13 = __require("fs");
-    const path14 = __require("path");
-    const faviconPath = path14.resolve(process.cwd(), "public/favicon2.ico");
-    if (fs13.existsSync(faviconPath)) {
+    const fs12 = __require("fs");
+    const path13 = __require("path");
+    const faviconPath = path13.resolve(process.cwd(), "public/favicon2.ico");
+    if (fs12.existsSync(faviconPath)) {
       files.push({
         path: "public/favicon2.ico",
-        contents: fs13.readFileSync(faviconPath).toString("base64"),
+        contents: fs12.readFileSync(faviconPath).toString("base64"),
         language: "ico",
         encoding: "base64"
       });
     } else {
-      const webFaviconPath = path14.resolve(process.cwd(), "apps/web/public/favicon2.ico");
-      if (fs13.existsSync(webFaviconPath)) {
+      const webFaviconPath = path13.resolve(process.cwd(), "apps/web/public/favicon2.ico");
+      if (fs12.existsSync(webFaviconPath)) {
         files.push({
           path: "public/favicon2.ico",
-          contents: fs13.readFileSync(webFaviconPath).toString("base64"),
+          contents: fs12.readFileSync(webFaviconPath).toString("base64"),
           language: "ico",
           encoding: "base64"
         });
@@ -3413,6 +3401,18 @@ async function writeState(state) {
   if (file) await fs2.writeFile(file, JSON.stringify(state, null, 2), "utf8");
   return state;
 }
+async function withActiveVectorTable(config) {
+  const server = await getActiveServer();
+  if (!server || config.vectorStore && config.vectorStore !== "lancedb") return config;
+  const safeId = server.id.replace(/[^a-zA-Z0-9_-]/g, "_");
+  return {
+    ...config,
+    storeConfig: {
+      ...config.storeConfig,
+      tableName: `documents_${safeId}`
+    }
+  };
+}
 function pidAlive(pid) {
   if (!pid) return false;
   try {
@@ -3423,7 +3423,7 @@ function pidAlive(pid) {
   }
 }
 async function emitToDisk(config) {
-  const server = generateServer(config);
+  const server = generateServer(await withActiveVectorTable(config));
   const dir = await outDir(true);
   if (!dir) throw new Error("No active server to emit to.");
   await fs2.mkdir(dir, { recursive: true });
@@ -3459,7 +3459,8 @@ async function startServer(config, serverApiKey) {
     }
   }
   await killPort(port);
-  const dir = await emitToDisk(config);
+  const runtimeConfig = await withActiveVectorTable(config);
+  const dir = await emitToDisk(runtimeConfig);
   try {
     await execAsync("npm install --omit=dev", {
       cwd: dir,
@@ -3474,7 +3475,7 @@ async function startServer(config, serverApiKey) {
     const message = err instanceof Error ? err.message : "npm install failed";
     return writeState({ ...emptyState(port), lastError: message });
   }
-  const dbPath = config.storeConfig.dbPath || "./.larkup/lancedb";
+  const dbPath = runtimeConfig.storeConfig.dbPath || "./.larkup/lancedb";
   const absDb = path2.isAbsolute(dbPath) ? dbPath : path2.join(process.cwd(), dbPath);
   const logPath = path2.join(dir, "server.log");
   await fs2.writeFile(logPath, "", "utf8");
@@ -3487,35 +3488,35 @@ async function startServer(config, serverApiKey) {
     env: {
       ...process.env,
       PORT: String(port),
-      TOP_K: String(config.topK),
+      TOP_K: String(runtimeConfig.topK),
       SERVER_API_KEY: serverApiKey || "",
-      EMBEDDING_API_KEY: config.embeddingApiKey || process.env.EMBEDDING_API_KEY || process.env.OPENAI_API_KEY || "",
-      CHAT_API_KEY: config.chatApiKey || config.customChatModels?.find(
-        (model) => model.modelName === config.chatModelId?.replace(/^custom:/, "")
+      EMBEDDING_API_KEY: runtimeConfig.embeddingApiKey || process.env.EMBEDDING_API_KEY || process.env.OPENAI_API_KEY || "",
+      CHAT_API_KEY: runtimeConfig.chatApiKey || runtimeConfig.customChatModels?.find(
+        (model) => model.modelName === runtimeConfig.chatModelId?.replace(/^custom:/, "")
       )?.apiKey || process.env.CHAT_API_KEY || process.env.OPENAI_API_KEY || "",
-      CHAT_MODEL: process.env.CHAT_MODEL || resolveChatModel(config),
-      CHAT_BASE_URL: config.customChatModels?.find(
-        (model) => model.modelName === config.chatModelId?.replace(/^custom:/, "")
+      CHAT_MODEL: process.env.CHAT_MODEL || resolveChatModel(runtimeConfig),
+      CHAT_BASE_URL: runtimeConfig.customChatModels?.find(
+        (model) => model.modelName === runtimeConfig.chatModelId?.replace(/^custom:/, "")
       )?.baseUrl || process.env.CHAT_BASE_URL || "",
-      OPENAI_API_KEY: config.embeddingApiKey || config.chatApiKey || process.env.OPENAI_API_KEY || "",
-      ANTHROPIC_API_KEY: config.chatApiKey || config.embeddingApiKey || process.env.ANTHROPIC_API_KEY || "",
-      COHERE_API_KEY: config.embeddingApiKey || config.chatApiKey || process.env.COHERE_API_KEY || "",
-      GOOGLE_GENERATIVE_AI_API_KEY: config.embeddingApiKey || config.chatApiKey || process.env.GOOGLE_GENERATIVE_AI_API_KEY || "",
-      PINECONE_API_KEY: config.storeConfig.apiKey || "",
-      PINECONE_INDEX: config.storeConfig.indexName || "",
-      PINECONE_NAMESPACE: config.storeConfig.namespace || "",
-      PINECONE_SPARSE_MODEL: config.storeConfig.sparseModel || "",
-      PINECONE_SPARSE_INDEX: config.storeConfig.sparseIndexName || "",
-      LANCEDB_MODE: config.storeConfig.mode || "local",
+      OPENAI_API_KEY: runtimeConfig.embeddingApiKey || runtimeConfig.chatApiKey || process.env.OPENAI_API_KEY || "",
+      ANTHROPIC_API_KEY: runtimeConfig.chatApiKey || runtimeConfig.embeddingApiKey || process.env.ANTHROPIC_API_KEY || "",
+      COHERE_API_KEY: runtimeConfig.embeddingApiKey || runtimeConfig.chatApiKey || process.env.COHERE_API_KEY || "",
+      GOOGLE_GENERATIVE_AI_API_KEY: runtimeConfig.embeddingApiKey || runtimeConfig.chatApiKey || process.env.GOOGLE_GENERATIVE_AI_API_KEY || "",
+      PINECONE_API_KEY: runtimeConfig.storeConfig.apiKey || "",
+      PINECONE_INDEX: runtimeConfig.storeConfig.indexName || "",
+      PINECONE_NAMESPACE: runtimeConfig.storeConfig.namespace || "",
+      PINECONE_SPARSE_MODEL: runtimeConfig.storeConfig.sparseModel || "",
+      PINECONE_SPARSE_INDEX: runtimeConfig.storeConfig.sparseIndexName || "",
+      LANCEDB_MODE: runtimeConfig.storeConfig.mode || "local",
       LANCEDB_PATH: absDb,
-      LANCEDB_URI: config.storeConfig.uri || "",
-      LANCEDB_API_KEY: config.storeConfig.apiKey || "",
-      LANCEDB_S3_URI: config.storeConfig.s3Uri || "",
-      AWS_ENDPOINT: config.storeConfig.s3Endpoint || "",
-      AWS_REGION: config.storeConfig.s3Region || "",
-      AWS_ACCESS_KEY_ID: config.storeConfig.s3AccessKeyId || "",
-      AWS_SECRET_ACCESS_KEY: config.storeConfig.s3SecretAccessKey || "",
-      LANCEDB_TABLE: config.storeConfig.tableName || "documents"
+      LANCEDB_URI: runtimeConfig.storeConfig.uri || "",
+      LANCEDB_API_KEY: runtimeConfig.storeConfig.apiKey || "",
+      LANCEDB_S3_URI: runtimeConfig.storeConfig.s3Uri || "",
+      AWS_ENDPOINT: runtimeConfig.storeConfig.s3Endpoint || "",
+      AWS_REGION: runtimeConfig.storeConfig.s3Region || "",
+      AWS_ACCESS_KEY_ID: runtimeConfig.storeConfig.s3AccessKeyId || "",
+      AWS_SECRET_ACCESS_KEY: runtimeConfig.storeConfig.s3SecretAccessKey || "",
+      LANCEDB_TABLE: runtimeConfig.storeConfig.tableName || "documents"
     }
   });
   child.unref();
@@ -4300,7 +4301,7 @@ async function createAdapter(config, onRateLimit) {
     }
     case "lancedb":
     default: {
-      const { LanceDBAdapter } = await import("./lancedb-ITW7V3K5.js");
+      const { LanceDBAdapter } = await import("./lancedb-RUTGJYW7.js");
       return new LanceDBAdapter({
         mode: overrides.mode,
         dbPath: overrides.dbPath,
@@ -4640,8 +4641,8 @@ async function readTextFiles(files) {
 }
 
 // src/commands/media.ts
-import { promises as fs9 } from "fs";
-import path10 from "path";
+import { promises as fs8 } from "fs";
+import path9 from "path";
 
 // ../../packages/core/src/media-store.ts
 import { promises as fs7 } from "fs";
@@ -4783,97 +4784,10 @@ function claimMediaAsset(id) {
   });
 }
 
-// ../../packages/marketplace/src/storage-provider.ts
-import { promises as fs8 } from "fs";
-import path9 from "path";
-var LocalStorageProvider = class {
-  id = "local";
-  name = "Local Storage";
-  async mediaDir() {
-    const dataDir = await requireDataDir();
-    const dir = path9.join(dataDir, "media");
-    await fs8.mkdir(dir, { recursive: true });
-    return dir;
-  }
-  async store(key, data, _mimeType) {
-    const dir = await this.mediaDir();
-    const filePath = path9.join(dir, key);
-    await fs8.mkdir(path9.dirname(filePath), { recursive: true });
-    await fs8.writeFile(filePath, data);
-    return `local://${key}`;
-  }
-  async storeFile(key, sourcePath, _mimeType) {
-    const dir = await this.mediaDir();
-    const filePath = path9.join(dir, key);
-    await fs8.mkdir(path9.dirname(filePath), { recursive: true });
-    await fs8.copyFile(sourcePath, filePath);
-    return `local://${key}`;
-  }
-  async retrieve(uri) {
-    const filePath = await this.resolvePath(uri);
-    if (!filePath) throw new Error(`Unsupported local storage URI: ${uri}`);
-    return fs8.readFile(filePath);
-  }
-  async resolvePath(uri) {
-    if (!uri.startsWith("local://")) return void 0;
-    const key = uri.slice("local://".length);
-    const dir = await this.mediaDir();
-    const filePath = path9.resolve(dir, key);
-    const relative = path9.relative(dir, filePath);
-    if (relative.startsWith("..") || path9.isAbsolute(relative)) {
-      throw new Error("Invalid local storage URI");
-    }
-    return filePath;
-  }
-  async delete(uri) {
-    const key = uri.replace("local://", "");
-    const dir = await this.mediaDir();
-    try {
-      await fs8.unlink(path9.join(dir, key));
-    } catch {
-    }
-  }
-  async stats() {
-    try {
-      const dir = await this.mediaDir();
-      return await computeDirStats(dir);
-    } catch {
-      return { usedBytes: 0, fileCount: 0 };
-    }
-  }
-};
-async function computeDirStats(dir) {
-  let usedBytes = 0;
-  let fileCount = 0;
-  async function walk2(d) {
-    let entries;
-    try {
-      entries = await fs8.readdir(d, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      const full = path9.join(d, entry.name);
-      if (entry.isDirectory()) {
-        await walk2(full);
-      } else {
-        try {
-          const stat = await fs8.stat(full);
-          usedBytes += stat.size;
-          fileCount++;
-        } catch {
-        }
-      }
-    }
-  }
-  await walk2(dir);
-  return { usedBytes, fileCount };
-}
-function createStorageProvider(_config) {
-  return new LocalStorageProvider();
-}
-
 // src/commands/media.ts
+import { isToolInstalled } from "@larkup/marketplace/installer";
+import { loadTool } from "@larkup/marketplace/loader";
+import { createStorageProvider } from "@larkup/marketplace/storage";
 var MIME_TYPES = {
   ".png": "image/png",
   ".jpg": "image/jpeg",
@@ -4915,12 +4829,12 @@ async function processMediaCommand(inputs, options) {
   const assets = await Promise.all(
     mediaFiles.map(async (filePath) => {
       const type = mediaType(filePath);
-      const stat = await fs9.stat(filePath);
-      const extension = path10.extname(filePath).toLowerCase() || ".bin";
+      const stat = await fs8.stat(filePath);
+      const extension = path9.extname(filePath).toLowerCase() || ".bin";
       const key = `${type}s/${Date.now()}_${Math.random().toString(36).slice(2)}${extension}`;
       const mimeType = MIME_TYPES[extension] || "application/octet-stream";
-      const storageUri = storage.storeFile ? await storage.storeFile(key, filePath, mimeType) : await storage.store(key, await fs9.readFile(filePath), mimeType);
-      return { type, fileName: path10.basename(filePath), mimeType, storageUri, fileSize: stat.size };
+      const storageUri = storage.storeFile ? await storage.storeFile(key, filePath, mimeType) : await storage.store(key, await fs8.readFile(filePath), mimeType);
+      return { type, fileName: path9.basename(filePath), mimeType, storageUri, fileSize: stat.size };
     })
   );
   const stored = await addMediaAssets(assets);
@@ -5002,7 +4916,7 @@ async function processMediaAsset(asset) {
       if (!tool2.processVideo)
         throw new Error("The installed Video & Audio tool cannot process videos.");
       await update("Extracting video audio", 20);
-      const outputDir = await fs9.mkdtemp(path10.join(process.cwd(), ".larkup", "tmp-media-"));
+      const outputDir = await fs8.mkdtemp(path9.join(process.cwd(), ".larkup", "tmp-media-"));
       try {
         const video = await tool2.processVideo(localFile, {
           outputDir,
@@ -5023,7 +4937,7 @@ async function processMediaAsset(asset) {
         dimensions = { width: video.meta.width, height: video.meta.height };
         frameCount = video.frames.length;
       } finally {
-        await fs9.rm(outputDir, { recursive: true, force: true }).catch(() => {
+        await fs8.rm(outputDir, { recursive: true, force: true }).catch(() => {
         });
       }
     } else {
@@ -5101,7 +5015,7 @@ async function indexPendingMedia() {
   spinner2.stop(`Indexed ${finalRun.totalChunks} chunks`);
 }
 function mediaType(filePath) {
-  const extension = path10.extname(filePath).toLowerCase();
+  const extension = path9.extname(filePath).toLowerCase();
   if ([".png", ".jpg", ".jpeg", ".webp", ".gif"].includes(extension)) return "image";
   if ([".mp4", ".webm", ".mov", ".mkv"].includes(extension)) return "video";
   if ([".mp3", ".m4a", ".wav", ".ogg", ".flac"].includes(extension)) return "audio";
@@ -5188,20 +5102,20 @@ async function indexCommand(inputs, options) {
 }
 
 // src/commands/generate.ts
-import { promises as fs10 } from "fs";
-import path11 from "path";
+import { promises as fs9 } from "fs";
+import path10 from "path";
 async function generateCommand(options) {
   await inServerScope(options.server, async () => {
     await requireActive();
     const config = await readConfig();
     if (options.out) {
-      const dir = path11.isAbsolute(options.out) ? options.out : path11.join(process.cwd(), options.out);
+      const dir = path10.isAbsolute(options.out) ? options.out : path10.join(process.cwd(), options.out);
       const server2 = generateServer(config);
-      await fs10.mkdir(dir, { recursive: true });
+      await fs9.mkdir(dir, { recursive: true });
       for (const f of server2.files) {
-        const dest = path11.join(dir, f.path);
-        await fs10.mkdir(path11.dirname(dest), { recursive: true });
-        await fs10.writeFile(dest, f.contents, "utf8");
+        const dest = path10.join(dir, f.path);
+        await fs9.mkdir(path10.dirname(dest), { recursive: true });
+        await fs9.writeFile(dest, f.contents, "utf8");
       }
       log.success(`Generated ${server2.files.length} files \u2192 ${dir}`);
     } else {
@@ -5506,6 +5420,13 @@ async function settingsCommand(options) {
 }
 
 // src/commands/marketplace.ts
+import { getAllTools, getToolById } from "@larkup/marketplace/registry";
+import {
+  getInstalledTool,
+  getInstalledTools,
+  installTool,
+  uninstallTool
+} from "@larkup/marketplace/installer";
 async function marketplaceCommand(action = "list", toolId) {
   if (action === "list") {
     const [tools, installed] = await Promise.all([getAllTools(), getInstalledTools()]);
@@ -5549,8 +5470,8 @@ async function marketplaceCommand(action = "list", toolId) {
 }
 
 // src/commands/deploy.ts
-import { promises as fs11 } from "fs";
-import path12 from "path";
+import { promises as fs10 } from "fs";
+import path11 from "path";
 async function deployCommand(target, options) {
   await inServerScope(options.server, async () => {
     await requireActive();
@@ -5586,13 +5507,13 @@ async function deployCommand(target, options) {
   });
 }
 async function copyGenerated(source, output) {
-  const destination = path12.resolve(output);
-  const relative = path12.relative(source, destination);
-  if (relative === "" || !relative.startsWith("..") && !path12.isAbsolute(relative)) {
+  const destination = path11.resolve(output);
+  const relative = path11.relative(source, destination);
+  if (relative === "" || !relative.startsWith("..") && !path11.isAbsolute(relative)) {
     throw new Error("Deployment output must be outside the generated server directory.");
   }
-  await fs11.mkdir(destination, { recursive: true });
-  await fs11.cp(source, destination, { recursive: true, force: true });
+  await fs10.mkdir(destination, { recursive: true });
+  await fs10.cp(source, destination, { recursive: true, force: true });
   return destination;
 }
 
@@ -5677,8 +5598,8 @@ function openCommandForPlatform(url) {
 }
 
 // src/commands/documents.ts
-import { promises as fs12 } from "fs";
-import path13 from "path";
+import { promises as fs11 } from "fs";
+import path12 from "path";
 
 // ../../packages/core/src/corpus-retriever.ts
 function applyFilters(docs, filter) {
@@ -5797,10 +5718,10 @@ async function documentsCommand(action = "list", idOrPath, options) {
     }
     if (action === "export") {
       const format = options.format === "jsonl" ? "jsonl" : "csv";
-      const output = path13.resolve(options.out || idOrPath || `corpus.${format}`);
+      const output = path12.resolve(options.out || idOrPath || `corpus.${format}`);
       const content = format === "jsonl" ? await exportCorpusAsJSONL(void 0, Number.MAX_SAFE_INTEGER) : await exportCorpusAsCSV(void 0, Number.MAX_SAFE_INTEGER);
-      await fs12.mkdir(path13.dirname(output), { recursive: true });
-      await fs12.writeFile(output, content, "utf8");
+      await fs11.mkdir(path12.dirname(output), { recursive: true });
+      await fs11.writeFile(output, content, "utf8");
       log.success(`Exported corpus \u2192 ${output}`);
       return;
     }
@@ -5826,7 +5747,7 @@ ${document.content}`);
       return;
     }
     if (action === "update") {
-      const content = options.file ? await fs12.readFile(path13.resolve(options.file), "utf8") : options.text;
+      const content = options.file ? await fs11.readFile(path12.resolve(options.file), "utf8") : options.text;
       const updated = await updateDocument(document.id, {
         title: options.title,
         content,

package/dist/{lancedb-ITW7V3K5.js → lancedb-RUTGJYW7.js}

@@ -112,7 +112,7 @@ var LanceDBAdapter = class {
       source: r.source,
       documentId: r.documentId,
       chunkIndex: r.chunkIndex,
-      metadata: r.metadata ? JSON.stringify(r.metadata) : void 0
+      metadata: JSON.stringify(r.metadata ?? {})
     };
   }
   async upsert(records) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larkup/cli",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "publishConfig": {
     "access": "public"
   },
@@ -28,9 +28,9 @@
     "cli-table3": "^0.6.5",
     "commander": "^15.0.0",
     "zod": "^4.4.3",
-    "@larkup/core": "0.2.2",
-    "@larkup/vector-stores": "0.1.22",
-    "@larkup/marketplace": "0.1.5"
+    "@larkup/core": "0.2.4",
+    "@larkup/marketplace": "0.1.7",
+    "@larkup/vector-stores": "0.1.23"
   },
   "devDependencies": {
     "tsup": "^8.0.0",

package/dist/chunk-P5JVXA7X.js

@@ -1,231 +0,0 @@
-// ../../packages/marketplace/src/tool-registry.ts
-import { promises as fs } from "fs";
-import path from "path";
-
-// ../../packages/marketplace/src/types.ts
-var DEFAULT_HUB_URL = process.env.LARKUP_HUB_URL ?? "https://hub.larkup.de";
-var STORAGE_WARNING_THRESHOLDS = [
-  1 * 1024 * 1024 * 1024,
-  // 1 GB
-  5 * 1024 * 1024 * 1024,
-  // 5 GB
-  10 * 1024 * 1024 * 1024
-  // 10 GB
-];
-
-// ../../packages/marketplace/src/tool-registry.ts
-var cachedRegistry = null;
-async function discoverLocalManifests() {
-  const registry = {};
-  const searchPaths = [
-    // Monorepo development: packages/tools/*
-    path.resolve(process.cwd(), "packages", "tools"),
-    // Next.js dev server runs in apps/web
-    path.resolve(process.cwd(), "..", "..", "packages", "tools"),
-    // Installed tools: .larkup/tools/node_modules/@larkup
-    path.resolve(process.cwd(), ".larkup", "tools", "node_modules", "@larkup"),
-    path.resolve(process.cwd(), "..", "..", ".larkup", "tools", "node_modules", "@larkup")
-  ];
-  for (const searchPath of searchPaths) {
-    try {
-      const entries = await fs.readdir(searchPath, { withFileTypes: true });
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue;
-        const manifestPath = path.join(searchPath, entry.name, "tool.manifest.json");
-        try {
-          const raw = await fs.readFile(manifestPath, "utf8");
-          const manifest = JSON.parse(raw);
-          if (manifest.id) {
-            registry[manifest.id] = manifest;
-          }
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  return registry;
-}
-async function fetchHubCatalog(hubUrl) {
-  const baseUrl = hubUrl ?? DEFAULT_HUB_URL;
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 5e3);
-    const res = await fetch(`${baseUrl}/v1/tools`, {
-      signal: controller.signal,
-      headers: { Accept: "application/json" }
-    });
-    clearTimeout(timeout);
-    if (!res.ok) return {};
-    const data = await res.json();
-    const registry = {};
-    for (const tool of data.tools ?? []) {
-      if (tool.id) registry[tool.id] = tool;
-    }
-    return registry;
-  } catch {
-    return {};
-  }
-}
-async function fetchToolFromHub(toolId, hubUrl) {
-  const baseUrl = hubUrl ?? DEFAULT_HUB_URL;
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 5e3);
-    const res = await fetch(`${baseUrl}/v1/tools/${toolId}`, {
-      signal: controller.signal,
-      headers: { Accept: "application/json" }
-    });
-    clearTimeout(timeout);
-    if (!res.ok) return null;
-    const data = await res.json();
-    return data.tool ?? null;
-  } catch {
-    return null;
-  }
-}
-var FALLBACK_REGISTRY = {
-  "video-audio": {
-    id: "video-audio",
-    name: "Video & Audio",
-    description: "Index video and audio files with transcription and frame analysis.",
-    category: "media",
-    version: "0.2.1",
-    pricing: "free",
-    emoji: "\u{1F3AC}",
-    icon: "Film",
-    packageName: "@larkup/tool-video-audio",
-    installSize: "~15 MB",
-    systemDeps: ["ffmpeg"],
-    author: "Larkup",
-    capabilities: [
-      "video-indexing",
-      "audio-indexing",
-      "transcription",
-      "frame-extraction",
-      "youtube-import"
-    ],
-    tags: ["transcription", "ffmpeg", "video", "audio", "whisper"],
-    downloads: 0,
-    repositoryUrl: "https://github.com/Larkup-AI/larkup-rag",
-    license: "Apache-2.0",
-    updatedAt: "2026-07-20",
-    configSchema: [
-      {
-        key: "frameInterval",
-        label: "Frame extraction interval (seconds)",
-        type: "text",
-        defaultValue: "10",
-        help: "Baseline cadence for duration-aware coverage frames; scene changes and a reserved ending pass are added separately."
-      },
-      {
-        key: "audioProvider",
-        label: "Audio Provider",
-        type: "select",
-        help: "Choose the provider used only for audio and video transcription.",
-        options: [
-          { label: "OpenAI", value: "openai" },
-          { label: "Groq", value: "groq" },
-          { label: "Deepgram", value: "deepgram" },
-          { label: "ElevenLabs", value: "elevenlabs" },
-          { label: "Local Whisper", value: "local" }
-        ]
-      },
-      {
-        key: "audioLanguage",
-        label: "Transcription language",
-        type: "text",
-        defaultValue: "auto",
-        help: "Use auto to infer Arabic from the media title and use provider detection otherwise. Enter a language code such as ar, ar-EG, en, or de to override it."
-      },
-      {
-        key: "audioApiKey",
-        label: "Audio API Key",
-        type: "password",
-        help: "Required for the selected audio provider and kept separate from the chat model key."
-      }
-    ]
-  },
-  "clip-embeddings": {
-    id: "clip-embeddings",
-    name: "CLIP Image Search",
-    description: "Direct image-to-image similarity search using CLIP/SigLIP embeddings.",
-    category: "embedding",
-    version: "0.1.0",
-    pricing: "free",
-    emoji: "\u{1F50D}",
-    icon: "ScanEye",
-    packageName: "@larkup/tool-clip-embeddings",
-    installSize: "~200 MB",
-    author: "Larkup",
-    capabilities: ["clip-embeddings", "image-similarity"],
-    tags: ["clip", "siglip", "image-search", "visual-similarity"],
-    downloads: 0,
-    repositoryUrl: "https://github.com/Larkup-AI/larkup-rag",
-    license: "Apache-2.0",
-    updatedAt: "2026-07-20",
-    comingSoon: true
-  },
-  "doc-editor": {
-    id: "doc-editor",
-    name: "Document Editor",
-    description: "AI-powered form filling and document editing with Canvas-style live preview.",
-    category: "utility",
-    version: "0.2.3",
-    pricing: "free",
-    emoji: "\u{1F4DD}",
-    icon: "FileEdit",
-    packageName: "@larkup/tool-doc-editor",
-    installSize: "~5 MB",
-    systemDeps: ["docker"],
-    author: "Larkup",
-    capabilities: ["document-editing", "form-filling", "document-preview"],
-    tags: ["pdf", "docx", "pptx", "form", "canvas", "editor", "fill"],
-    downloads: 0,
-    repositoryUrl: "https://github.com/Larkup-AI/larkup-rag",
-    license: "Apache-2.0",
-    updatedAt: "2026-07-20"
-  }
-};
-async function buildRegistry(opts) {
-  if (cachedRegistry) return cachedRegistry;
-  const registry = { ...FALLBACK_REGISTRY };
-  const localManifests = await discoverLocalManifests();
-  Object.assign(registry, localManifests);
-  if (!opts?.skipHub) {
-    const hubCatalog = await fetchHubCatalog(opts?.hubUrl);
-    Object.assign(registry, hubCatalog);
-  }
-  cachedRegistry = registry;
-  return registry;
-}
-function invalidateRegistryCache() {
-  cachedRegistry = null;
-}
-async function getAllTools() {
-  const registry = await buildRegistry();
-  return Object.values(registry).sort((a, b) => a.name.localeCompare(b.name));
-}
-async function getToolById(id) {
-  const registry = await buildRegistry();
-  return registry[id];
-}
-async function getToolsWithCapability(capability) {
-  const all = await getAllTools();
-  return all.filter((t) => t.capabilities.includes(capability));
-}
-async function getAllCategories() {
-  const all = await getAllTools();
-  const cats = new Set(all.map((t) => t.category));
-  return Array.from(cats).sort();
-}
-
-export {
-  fetchToolFromHub,
-  buildRegistry,
-  invalidateRegistryCache,
-  getAllTools,
-  getToolById,
-  getToolsWithCapability,
-  getAllCategories
-};

package/dist/chunk-TH2MPRMA.js

@@ -1,412 +0,0 @@
-import {
-  getToolById,
-  invalidateRegistryCache
-} from "./chunk-P5JVXA7X.js";
-import {
-  __require
-} from "./chunk-3RG5ZIWI.js";
-
-// ../../packages/marketplace/src/tool-loader.ts
-import { promises as fs2 } from "fs";
-import path2 from "path";
-import { pathToFileURL } from "url";
-
-// ../../packages/marketplace/src/tool-installer.ts
-import { promises as fs } from "fs";
-import path from "path";
-import { exec as execCb } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(execCb);
-function getToolsDir() {
-  return path.join(process.cwd(), ".larkup", "tools");
-}
-function getManifestPath() {
-  return path.join(getToolsDir(), "installed.json");
-}
-async function ensureDir() {
-  await fs.mkdir(getToolsDir(), { recursive: true });
-}
-async function readManifest() {
-  try {
-    const raw = await fs.readFile(getManifestPath(), "utf8");
-    const parsed = JSON.parse(raw);
-    if (!parsed.downloadCounts) parsed.downloadCounts = {};
-    for (const tool of parsed.tools ?? []) {
-      if (tool.packagePath && !tool.packageName) {
-        tool.packageName = tool.packagePath;
-        delete tool.packagePath;
-      }
-      if (!tool.source) tool.source = "local";
-      if (!tool.resolvedPath) {
-        tool.resolvedPath = tool.packageName;
-      }
-    }
-    return parsed;
-  } catch {
-    return { tools: [], downloadCounts: {}, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
-  }
-}
-async function writeManifest(manifest) {
-  await ensureDir();
-  manifest.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-  await fs.writeFile(getManifestPath(), JSON.stringify(manifest, null, 2), "utf8");
-}
-async function getInstalledTools() {
-  const manifest = await readManifest();
-  const tools = [...manifest.tools];
-  const bundledIds = (process.env.LARKUP_BUNDLED_TOOLS ?? "").split(",").map((id) => id.trim()).filter(Boolean);
-  for (const toolId of bundledIds) {
-    if (tools.some((tool) => tool.id === toolId)) continue;
-    const descriptor = await getToolById(toolId);
-    if (!descriptor) continue;
-    tools.push({
-      id: toolId,
-      version: descriptor.version,
-      installedAt: "bundled",
-      packageName: descriptor.packageName,
-      resolvedPath: descriptor.packageName,
-      source: "local",
-      config: buildDefaultConfig(descriptor)
-    });
-  }
-  return tools;
-}
-async function isToolInstalled(toolId) {
-  const tools = await getInstalledTools();
-  return tools.some((t) => t.id === toolId);
-}
-async function getInstalledTool(toolId) {
-  const tools = await getInstalledTools();
-  return tools.find((t) => t.id === toolId);
-}
-async function checkSystemDeps(toolId) {
-  const descriptor = await getToolById(toolId);
-  if (!descriptor?.systemDeps?.length) return [];
-  const target = detectDeploymentTarget();
-  const missing = [];
-  for (const dep of descriptor.systemDeps) {
-    if (target === "docker" && dep === "docker") continue;
-    try {
-      await execAsync(`which ${dep}`);
-    } catch {
-      missing.push(dep);
-    }
-  }
-  return missing;
-}
-function detectDeploymentTarget() {
-  const explicit = process.env.LARKUP_DEPLOYMENT_TARGET;
-  if (explicit && ["local", "docker", "serverless", "sandbox"].includes(explicit)) {
-    return explicit;
-  }
-  if (process.env.VERCEL || process.env.AWS_LAMBDA_FUNCTION_NAME) return "serverless";
-  if (process.env.DOCKER_CONTAINER || isDockerEnvironment()) return "docker";
-  if (process.env.E2B_SANDBOX_ID || process.env.MODAL_TASK_ID) return "sandbox";
-  return "local";
-}
-function isDockerEnvironment() {
-  try {
-    const fs3 = __require("fs");
-    return fs3.existsSync("/.dockerenv");
-  } catch {
-    return false;
-  }
-}
-async function ensureToolsPackageJson() {
-  const toolsDir = getToolsDir();
-  const pkgPath = path.join(toolsDir, "package.json");
-  try {
-    await fs.access(pkgPath);
-  } catch {
-    await ensureDir();
-    await fs.writeFile(
-      pkgPath,
-      JSON.stringify(
-        {
-          name: "larkup-tools",
-          version: "1.0.0",
-          private: true,
-          description: "Isolated directory for installed Larkup marketplace tools."
-        },
-        null,
-        2
-      ),
-      "utf8"
-    );
-  }
-}
-async function execInstall(packageName, version, target, onProgress) {
-  const toolsDir = getToolsDir();
-  switch (target) {
-    case "local":
-    case "docker": {
-      await ensureToolsPackageJson();
-      const install = async (specifier) => {
-        const installCmd = `npm install ${specifier} --prefix "${toolsDir}" --save --no-audit --no-fund`;
-        onProgress?.(`Running: npm install ${specifier}`);
-        const { stderr } = await execAsync(installCmd, {
-          cwd: toolsDir,
-          timeout: 12e4,
-          // 2 minute timeout
-          env: { ...process.env, NODE_ENV: "production" }
-        });
-        if (stderr && !stderr.includes("npm warn")) {
-          console.warn(`[marketplace] Install stderr: ${stderr}`);
-        }
-      };
-      try {
-        await install(`${packageName}@${version}`);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : "Install command failed";
-        if (!message.includes("ETARGET") && !message.includes("No matching version found")) {
-          throw new Error(`Failed to install ${packageName}: ${message}`);
-        }
-        onProgress?.(
-          `Catalog version ${version} is unavailable; installing the latest published version\u2026`
-        );
-        try {
-          await install(`${packageName}@latest`);
-        } catch (latestErr) {
-          const latestMessage = latestErr instanceof Error ? latestErr.message : "Install command failed";
-          throw new Error(`Failed to install ${packageName}: ${latestMessage}`);
-        }
-      }
-      const resolvedPath = path.join(toolsDir, "node_modules", packageName);
-      try {
-        await fs.access(resolvedPath);
-      } catch {
-        throw new Error(
-          `Package ${packageName} was installed but could not be found at ${resolvedPath}`
-        );
-      }
-      const packageJson = JSON.parse(
-        await fs.readFile(path.join(resolvedPath, "package.json"), "utf8")
-      );
-      return { resolvedPath, version: packageJson.version ?? version };
-    }
-    case "serverless": {
-      onProgress?.("Serverless environment detected \u2014 queuing for next deploy");
-      const pendingPath = path.join(toolsDir, "pending-tools.json");
-      let pending = { tools: [] };
-      try {
-        const raw = await fs.readFile(pendingPath, "utf8");
-        pending = JSON.parse(raw);
-      } catch {
-      }
-      pending.tools.push({ packageName, version });
-      await ensureDir();
-      await fs.writeFile(pendingPath, JSON.stringify(pending, null, 2), "utf8");
-      return { resolvedPath: path.join(toolsDir, "node_modules", packageName), version };
-    }
-    case "sandbox": {
-      onProgress?.("Installing in sandbox environment");
-      await ensureToolsPackageJson();
-      const installCmd = `npm install ${packageName}@${version} --prefix "${toolsDir}" --save --no-audit --no-fund`;
-      await execAsync(installCmd, { cwd: toolsDir, timeout: 12e4 });
-      return { resolvedPath: path.join(toolsDir, "node_modules", packageName), version };
-    }
-    default:
-      throw new Error(`Unsupported deployment target: ${target}`);
-  }
-}
-async function resolveManifest(toolId) {
-  const descriptor = await getToolById(toolId);
-  if (descriptor) return descriptor;
-  throw new Error(`Unknown tool: ${toolId}. Not found in local registry or Hub.`);
-}
-async function isWorkspaceTool(packageName) {
-  try {
-    const { stdout } = await execAsync(`pnpm ls -r --depth -1 --json 2>/dev/null || true`, {
-      cwd: process.cwd(),
-      timeout: 1e4
-    });
-    const data = JSON.parse(stdout || "[]");
-    return Array.isArray(data) && data.some((pkg) => pkg.name === packageName);
-  } catch {
-    return false;
-  }
-}
-async function installTool(toolId, onProgress) {
-  const report = (stage, percent, message) => {
-    onProgress?.({ toolId, stage, percent, message });
-  };
-  try {
-    report("checking-deps", 5, "Resolving tool manifest\u2026");
-    const descriptor = await resolveManifest(toolId);
-    if (descriptor.comingSoon) {
-      throw new Error(`${descriptor.name} is coming soon.`);
-    }
-    report("checking-deps", 15, "Checking system dependencies\u2026");
-    const missing = await checkSystemDeps(toolId);
-    if (missing.length > 0) {
-      const msg = `Missing system dependencies: ${missing.join(", ")}. Please install them first.`;
-      report("failed", 0, msg);
-      throw new Error(msg);
-    }
-    const isWorkspace = await isWorkspaceTool(descriptor.packageName);
-    const target = detectDeploymentTarget();
-    let resolvedPath;
-    let installedVersion = descriptor.version;
-    let source;
-    if (isWorkspace) {
-      report("downloading", 30, "Resolving workspace package\u2026");
-      try {
-        const modulePath = __require.resolve(descriptor.packageName, {
-          paths: [process.cwd()]
-        });
-        resolvedPath = path.dirname(modulePath);
-      } catch {
-        resolvedPath = path.join(process.cwd(), "node_modules", descriptor.packageName);
-      }
-      source = "local";
-      report("installing", 60, "Workspace package resolved.");
-    } else {
-      report("downloading", 30, `Downloading ${descriptor.packageName}@${descriptor.version}\u2026`);
-      const installed = await execInstall(
-        descriptor.packageName,
-        descriptor.version,
-        target,
-        (msg) => report("downloading", 50, msg)
-      );
-      resolvedPath = installed.resolvedPath;
-      installedVersion = installed.version;
-      source = target === "sandbox" ? "sandbox" : "registry";
-      report("installing", 70, "Package installed.");
-    }
-    report("installing", 80, "Registering tool\u2026");
-    await ensureDir();
-    const manifest = await readManifest();
-    const existing = manifest.tools.findIndex((t) => t.id === toolId);
-    const entry = {
-      id: toolId,
-      version: installedVersion,
-      installedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      packageName: descriptor.packageName,
-      resolvedPath,
-      source,
-      config: buildDefaultConfig(descriptor)
-    };
-    if (existing >= 0) {
-      manifest.tools[existing] = entry;
-    } else {
-      manifest.tools.push(entry);
-    }
-    manifest.downloadCounts[toolId] = (manifest.downloadCounts[toolId] ?? 0) + 1;
-    await writeManifest(manifest);
-    notifyHubInstall(toolId).catch(() => {
-    });
-    invalidateRegistryCache();
-    report("completed", 100, "Installed successfully.");
-  } catch (err) {
-    const message = err instanceof Error ? err.message : "Installation failed.";
-    report("failed", 0, message);
-    throw err;
-  }
-}
-async function uninstallTool(toolId) {
-  const manifest = await readManifest();
-  const tool = manifest.tools.find((t) => t.id === toolId);
-  manifest.tools = manifest.tools.filter((t) => t.id !== toolId);
-  await writeManifest(manifest);
-  if (tool?.source === "registry" && tool.packageName) {
-    try {
-      const toolsDir = getToolsDir();
-      await execAsync(`npm uninstall ${tool.packageName} --prefix "${toolsDir}"`, {
-        cwd: toolsDir,
-        timeout: 3e4
-      });
-    } catch {
-    }
-  }
-  invalidateRegistryCache();
-  const { unloadTool: unloadTool2 } = await import("./tool-loader-B2J2R64F.js");
-  unloadTool2(toolId);
-}
-async function notifyHubInstall(toolId) {
-  const hubUrl = process.env.LARKUP_HUB_URL ?? "https://hub.larkup.de";
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 3e3);
-    await fetch(`${hubUrl}/v1/tools/${toolId}/installed`, {
-      method: "POST",
-      signal: controller.signal,
-      headers: { "Content-Type": "application/json" }
-    });
-    clearTimeout(timeout);
-  } catch {
-  }
-}
-function buildDefaultConfig(descriptor) {
-  const config = {};
-  for (const field of descriptor.configSchema ?? []) {
-    if (field.defaultValue !== void 0) {
-      config[field.key] = field.defaultValue;
-    }
-  }
-  return config;
-}
-
-// ../../packages/marketplace/src/tool-loader.ts
-var moduleCache = /* @__PURE__ */ new Map();
-async function loadTool(toolId) {
-  if (moduleCache.has(toolId)) return moduleCache.get(toolId);
-  const installed = await getInstalledTool(toolId);
-  if (!installed) return null;
-  try {
-    const importPath = await resolveImportPath(installed);
-    const mod = await import(
-      /* webpackIgnore: true */
-      importPath
-    );
-    moduleCache.set(toolId, mod);
-    return mod;
-  } catch (err) {
-    console.error(`[marketplace] Failed to load tool "${toolId}":`, err);
-    return null;
-  }
-}
-async function resolveImportPath(installed) {
-  switch (installed.source) {
-    case "local":
-      return installed.packageName;
-    case "registry":
-    case "sandbox":
-      return resolvePackageEntry(installed.resolvedPath);
-    default:
-      return installed.packageName;
-  }
-}
-async function resolvePackageEntry(packageDir) {
-  const manifestPath = path2.join(packageDir, "package.json");
-  const manifest = JSON.parse(await fs2.readFile(manifestPath, "utf8"));
-  const rootExport = typeof manifest.exports === "object" ? manifest.exports["."] : manifest.exports;
-  const entry = (typeof rootExport === "object" ? rootExport.import ?? rootExport.default : rootExport) ?? manifest.main ?? "index.js";
-  return pathToFileURL(path2.resolve(packageDir, entry)).href;
-}
-function isToolLoaded(toolId) {
-  return moduleCache.has(toolId);
-}
-function unloadTool(toolId) {
-  moduleCache.delete(toolId);
-}
-async function hasCapability(capability) {
-  const { getToolsWithCapability } = await import("./tool-registry-W3JOGDE3.js");
-  const tools = await getToolsWithCapability(capability);
-  for (const t of tools) {
-    const installed = await getInstalledTool(t.id);
-    if (installed) return true;
-  }
-  return false;
-}
-
-export {
-  loadTool,
-  isToolLoaded,
-  unloadTool,
-  hasCapability,
-  getInstalledTools,
-  isToolInstalled,
-  getInstalledTool,
-  installTool,
-  uninstallTool
-};

package/dist/tool-loader-B2J2R64F.js

@@ -1,14 +0,0 @@
-import {
-  hasCapability,
-  isToolLoaded,
-  loadTool,
-  unloadTool
-} from "./chunk-TH2MPRMA.js";
-import "./chunk-P5JVXA7X.js";
-import "./chunk-3RG5ZIWI.js";
-export {
-  hasCapability,
-  isToolLoaded,
-  loadTool,
-  unloadTool
-};

package/dist/tool-registry-W3JOGDE3.js

@@ -1,19 +0,0 @@
-import {
-  buildRegistry,
-  fetchToolFromHub,
-  getAllCategories,
-  getAllTools,
-  getToolById,
-  getToolsWithCapability,
-  invalidateRegistryCache
-} from "./chunk-P5JVXA7X.js";
-import "./chunk-3RG5ZIWI.js";
-export {
-  buildRegistry,
-  fetchToolFromHub,
-  getAllCategories,
-  getAllTools,
-  getToolById,
-  getToolsWithCapability,
-  invalidateRegistryCache
-};