@liquidmetal-ai/raindrop 0.7.0 → 0.8.0

package/bundle/commands/query/chunk-search.js

@@ -0,0 +1,123 @@
+import {
+  ulid
+} from "../../chunk-CDQRD3JA.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  RagSearchResponseSchema,
+  __toESM,
+  init_cjs_shims,
+  require_lib,
+  toJsonString
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/query/chunk-search.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var RagSearch = class _RagSearch extends BaseCommand {
+  static args = {
+    query: import_core.Args.string({
+      description: "search query to run",
+      required: true
+    })
+  };
+  static description = "Run a RAG (Retrieval Augmented Generation) search query against a Smart Bucket";
+  static examples = [
+    `<%= config.bin %> query chunk-search "What is LiquidMetal?"
+Run a RAG search query against a Smart Bucket.
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    buckets: import_core.Flags.string({
+      char: "b",
+      description: "Bucket names to search in, version can be specified with #, e.g. my-bucket#versionId",
+      multiple: true,
+      required: false
+    }),
+    moduleIds: import_core.Flags.string({
+      char: "m",
+      description: "Module IDs to search in",
+      multiple: true,
+      required: false
+    }),
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "text",
+      options: ["text", "json"]
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    }),
+    manifest: import_core.Flags.string({
+      char: "M",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest",
+      hidden: true
+    })
+  };
+  async searchAgent(query) {
+    if (this.flags.buckets?.length && this.flags.moduleIds?.length) {
+      this.error("Cannot specify both --buckets and --moduleIds flags. Please use only one type of filter.");
+    }
+    if (this.flags.buckets?.some((bucket) => !bucket.includes("#"))) {
+      await this.loadConfig();
+    }
+    const { client: searchAgentService, userId, organizationId } = await this.searchAgentService();
+    const response = await searchAgentService.ragSearch({
+      userId,
+      organizationId,
+      bucketLocations: [
+        ...(this.flags.buckets || []).map((bucket) => {
+          const [bucketName, version] = bucket.split("#");
+          return {
+            bucketLocation: {
+              case: "bucket",
+              value: {
+                name: bucketName,
+                version: version || this.raindropConfig?.versionId || ""
+              }
+            }
+          };
+        }),
+        ...(this.flags.moduleIds || []).map((moduleId) => ({
+          bucketLocation: {
+            case: "moduleId",
+            value: moduleId
+          }
+        }))
+      ],
+      requestId: ulid(),
+      input: query
+    });
+    if (this.flags.output === "json") {
+      console.log(toJsonString(RagSearchResponseSchema, response, { prettySpaces: 2 }));
+    } else {
+      console.log("\nSearch Results:\n");
+      for (const result of response.results) {
+        console.log("----------------------------------------");
+        console.log(`Type: ${result.type || "N/A"}`);
+        console.log(`Score: ${result.score || 0}`);
+        console.log(`Source: ${result.source ? `${result.source.bucket?.bucketName}/${result.source.object}` : "N/A"}`);
+        console.log(`Content: ${result.text || "N/A"}`);
+        console.log("----------------------------------------\n");
+      }
+      if (response.results.length === 0) {
+        console.log("No results found.");
+      }
+    }
+  }
+  async run() {
+    const { args } = await this.parse(_RagSearch);
+    await this.searchAgent(args.query);
+  }
+};
+export {
+  RagSearch as default
+};

package/bundle/commands/query/document.js

@@ -0,0 +1,126 @@
+import {
+  ulid
+} from "../../chunk-CDQRD3JA.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  DocumentChatResponseSchema,
+  __toESM,
+  init_cjs_shims,
+  require_lib,
+  toJsonString
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/query/document.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var DocumentChat = class _DocumentChat extends BaseCommand {
+  static args = {
+    query: import_core.Args.string({
+      description: "question or query about the document",
+      required: true
+    })
+  };
+  static description = "Chat with a document stored in a Smart Bucket";
+  static examples = [
+    `<%= config.bin %> query document "What is the main topic of this document?" -b my-bucket -o document.pdf
+Chat with a document in a Smart Bucket using bucket name.
+`,
+    `<%= config.bin %> query document "What is the main topic of this document?" -m module-id -o document.pdf
+Chat with a document in a Smart Bucket using module ID.
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    bucket: import_core.Flags.string({
+      char: "b",
+      description: "Bucket name containing the document, version can be specified with #, e.g. my-bucket#versionId",
+      required: false
+    }),
+    moduleId: import_core.Flags.string({
+      char: "m",
+      description: "Module ID containing the document",
+      required: false
+    }),
+    objectId: import_core.Flags.string({
+      char: "o",
+      description: "Object ID of the document to chat with",
+      required: true
+    }),
+    output: import_core.Flags.string({
+      char: "O",
+      description: "output format",
+      default: "text",
+      options: ["text", "json"]
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    }),
+    manifest: import_core.Flags.string({
+      char: "M",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest",
+      hidden: true
+    })
+  };
+  async documentChat(query) {
+    if (this.flags.bucket && this.flags.moduleId) {
+      this.error("Cannot specify both --bucket and --moduleId flags. Please use only one type of location.");
+    }
+    if (!this.flags.bucket && !this.flags.moduleId) {
+      this.error("Must specify either --bucket or --moduleId flag to identify the document location.");
+    }
+    if (this.flags.bucket && !this.flags.bucket.includes("#")) {
+      await this.loadConfig();
+    }
+    const { client: searchAgentService, userId, organizationId } = await this.searchAgentService();
+    let bucketLocation;
+    if (this.flags.bucket) {
+      const [bucketName, version] = this.flags.bucket.split("#");
+      bucketLocation = {
+        bucketLocation: {
+          case: "bucket",
+          value: {
+            name: bucketName,
+            version: version || this.raindropConfig?.versionId || ""
+          }
+        }
+      };
+    } else {
+      bucketLocation = {
+        bucketLocation: {
+          case: "moduleId",
+          value: this.flags.moduleId
+        }
+      };
+    }
+    const response = await searchAgentService.documentChat({
+      userId,
+      organizationId,
+      bucketLocation,
+      objectId: this.flags.objectId,
+      requestId: ulid(),
+      input: query
+    });
+    if (this.flags.output === "json") {
+      console.log(toJsonString(DocumentChatResponseSchema, response, { prettySpaces: 2 }));
+    } else {
+      console.log("\nDocument Chat Response:\n");
+      console.log("----------------------------------------");
+      console.log(response.answer);
+      console.log("----------------------------------------\n");
+    }
+  }
+  async run() {
+    const { args } = await this.parse(_DocumentChat);
+    await this.documentChat(args.query);
+  }
+};
+export {
+  DocumentChat as default
+};

package/bundle/commands/query/events.js

@@ -0,0 +1,98 @@
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib,
+  valueOf
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/query/events.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var Events = class extends BaseCommand {
+  static args = {};
+  static description = "query and stream Raindrop application events";
+  static examples = [
+    `<%= config.bin %> <%= command.id %> .
+`
+  ];
+  static flags = {
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "table",
+      options: ["text", "table", "json"]
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    }),
+    manifest: import_core.Flags.string({
+      char: "m",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest",
+      hidden: true
+    }),
+    application: import_core.Flags.string({
+      char: "a",
+      description: "application",
+      required: false
+    }),
+    version: import_core.Flags.string({
+      char: "v",
+      description: "application version",
+      required: false
+    }),
+    rainbowAuthService: import_core.Flags.string({
+      default: "https://liquidmetal.run/api/connect",
+      hidden: true,
+      env: "LIQUIDMETAL_RAINBOW_AUTH_SERVICE"
+    }),
+    raindropCatalogService: import_core.Flags.string({
+      env: "RAINDROP_CATALOG_SERVICE",
+      description: "URL of the catalog service",
+      hidden: true
+    })
+  };
+  async run() {
+    if (!this.flags.version) {
+      const config = await this.loadConfig();
+      if (!config.versionId) {
+        this.error("No version provided or found in config", { exit: 1 });
+      }
+      this.flags.version = config.versionId;
+    }
+    if (!this.flags.application) {
+      const apps = await this.loadManifest();
+      const app = apps[0];
+      if (app === void 0) {
+        this.error("No application provided or found in manifest", { exit: 1 });
+      }
+      this.flags.application = valueOf(app.name);
+    }
+    const {
+      client: eventStreamService,
+      organizationId: defaultOrganizationId,
+      userId
+    } = await this.eventStreamService();
+    const organizationId = this.flags.impersonate ?? defaultOrganizationId;
+    for await (const resp of eventStreamService.tailEvents({
+      userId,
+      organizationId,
+      applicationName: this.flags.application,
+      applicationVersionId: this.flags.version
+    })) {
+      for (const event of resp.events) {
+        console.log(event);
+      }
+    }
+  }
+};
+export {
+  Events as default
+};

package/bundle/commands/query/reindex.js

@@ -0,0 +1,147 @@
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/query/reindex.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "path";
+var QueryReindex = class extends BaseCommand {
+  static description = "Reindex all objects in a bucket by downloading and re-uploading them";
+  static examples = [
+    `<%= config.bin %> query reindex -b my-bucket
+Reindex all objects in my-bucket by downloading and re-uploading them
+`,
+    `<%= config.bin %> query reindex -b my-bucket --parallel 5
+Reindex objects with 5 parallel operations instead of the default 10
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    bucket: import_core.Flags.string({
+      char: "b",
+      description: "bucket name version can be specified with #, e.g. my-bucket#versionId",
+      required: true
+    }),
+    parallel: import_core.Flags.integer({
+      char: "p",
+      description: "number of parallel operations",
+      default: 10
+    }),
+    dryRun: import_core.Flags.boolean({
+      char: "d",
+      description: "show what would be reindexed without actually doing it",
+      default: false
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    }),
+    manifest: import_core.Flags.string({
+      char: "M",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest",
+      hidden: true
+    })
+  };
+  async run() {
+    if (this.flags.bucket && !this.flags.bucket.includes("#")) {
+      await this.loadConfig();
+    }
+    const bucketLocation = {
+      bucketLocation: {
+        case: "bucket",
+        value: {
+          name: this.flags.bucket.split("#")[0],
+          version: this.flags.bucket.includes("#") ? this.flags.bucket.split("#")[1] : this.raindropConfig?.versionId
+        }
+      }
+    };
+    const { client: objectService, userId, organizationId } = await this.objectService();
+    console.log(`Fetching object list from bucket: ${this.flags.bucket}`);
+    const listResponse = await objectService.listObjects({
+      userId,
+      organizationId,
+      bucketLocation
+    });
+    if (!listResponse.objects || listResponse.objects.length === 0) {
+      console.log("No objects found in bucket");
+      return;
+    }
+    console.log(`Found ${listResponse.objects.length} objects to reindex`);
+    if (this.flags.dryRun) {
+      console.log("\nDry run - would reindex the following objects:");
+      for (const obj of listResponse.objects) {
+        console.log(`  - ${obj.key}`);
+      }
+      return;
+    }
+    const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), "raindrop-reindex-"));
+    try {
+      const batchSize = this.flags.parallel;
+      let processed = 0;
+      let failed = 0;
+      for (let i = 0; i < listResponse.objects.length; i += batchSize) {
+        const batch = listResponse.objects.slice(i, i + batchSize);
+        const promises = batch.map(async (obj) => {
+          try {
+            console.log(`Processing: ${obj.key}`);
+            const getResponse = await objectService.getObject({
+              userId,
+              organizationId,
+              key: obj.key,
+              bucketLocation
+            });
+            if (!getResponse.content) {
+              throw new Error("No content received");
+            }
+            const tempFile = path.join(tempDir, `${Date.now()}-${Math.random()}`);
+            await fs.writeFile(tempFile, getResponse.content);
+            const fileContent = await fs.readFile(tempFile);
+            await objectService.putObject({
+              userId,
+              organizationId,
+              key: obj.key,
+              content: fileContent,
+              contentType: getResponse.contentType || "application/octet-stream",
+              bucketLocation
+            });
+            await fs.unlink(tempFile);
+            console.log(`Completed: ${obj.key}`);
+            return true;
+          } catch (error) {
+            console.error(`Failed: ${obj.key} - ${error instanceof Error ? error.message : String(error)}`);
+            return false;
+          }
+        });
+        const results = await Promise.all(promises);
+        processed += results.filter(Boolean).length;
+        failed += results.filter((r) => !r).length;
+        console.log(`Batch ${Math.floor(i / batchSize) + 1} completed. Progress: ${processed + failed}/${listResponse.objects.length}`);
+      }
+      console.log("\nReindexing completed:");
+      console.log(`  Successfully processed: ${processed}`);
+      console.log(`  Failed: ${failed}`);
+      console.log(`  Total: ${listResponse.objects.length}`);
+    } finally {
+      try {
+        await fs.rm(tempDir, { recursive: true });
+      } catch (_error) {
+        console.warn(`Warning: Could not clean up temp directory ${tempDir}`);
+      }
+    }
+  }
+};
+export {
+  QueryReindex as default
+};

package/bundle/commands/query/search.js

@@ -0,0 +1,169 @@
+import {
+  ulid
+} from "../../chunk-CDQRD3JA.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/query/search.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var AgentSearch = class _AgentSearch extends BaseCommand {
+  static args = {
+    query: import_core.Args.string({
+      description: "search query",
+      required: false
+    })
+  };
+  static description = "Run a search query against a smart bucket using natural language";
+  static examples = [
+    `<%= config.bin %> query search "What is LiquidMetal?" --buckets my-bucket-1 my-bucket-2
+Run a new supervisor agent search query across multiple buckets.
+`,
+    `<%= config.bin %> query search --requestId 01HNG4V2RJXS5T --page 2
+Get page 2 of previous search results.
+`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS,
+    buckets: import_core.Flags.string({
+      char: "b",
+      description: "Bucket names to search in, version can be specified with #, e.g. my-bucket#versionId",
+      multiple: true,
+      required: false
+    }),
+    moduleIds: import_core.Flags.string({
+      char: "m",
+      description: "Module IDs to search in",
+      multiple: true,
+      required: false
+    }),
+    requestId: import_core.Flags.string({
+      description: "request ID for pagination",
+      required: false
+    }),
+    page: import_core.Flags.integer({
+      char: "p",
+      description: "page number for paginated results",
+      default: 1
+    }),
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "text",
+      options: ["text", "json"]
+    }),
+    impersonate: import_core.Flags.string({
+      char: "i",
+      description: "impersonate organization",
+      required: false,
+      hidden: true
+    }),
+    manifest: import_core.Flags.string({
+      char: "M",
+      description: "project manifest",
+      required: false,
+      default: "raindrop.manifest",
+      hidden: true
+    })
+  };
+  async run() {
+    if (this.flags.buckets?.length && this.flags.moduleIds?.length) {
+      this.error("Cannot specify both --buckets and --moduleIds flags. Please use only one type of filter.");
+    }
+    if (this.flags.buckets?.some((bucket) => !bucket.includes("#"))) {
+      await this.loadConfig();
+    }
+    const { args, flags } = await this.parse(_AgentSearch);
+    const { client: searchAgentService, userId, organizationId } = await this.searchAgentService();
+    let response;
+    let requestId;
+    if (flags.requestId) {
+      if (!flags.page) {
+        this.error("Page number is required when using requestId");
+        return;
+      }
+      response = await searchAgentService.getPaginatedResults({
+        requestId: flags.requestId,
+        page: flags.page,
+        pageSize: 15,
+        userId,
+        organizationId
+      });
+      if (!response?.results?.length) {
+        this.error(`No results found for request ID: ${flags.requestId}. The search session might have expired.`);
+        return;
+      }
+      requestId = flags.requestId;
+    } else {
+      if (!args.query) {
+        this.error("Search query is required when not using requestId");
+        return;
+      }
+      requestId = ulid();
+      response = await searchAgentService.runSupervisorAgent({
+        requestId,
+        input: args.query,
+        bucketLocations: [
+          ...(this.flags.buckets || []).map((bucket) => {
+            const [bucketName, version] = bucket.split("#");
+            return {
+              bucketLocation: {
+                case: "bucket",
+                value: {
+                  name: bucketName,
+                  version: version || this.raindropConfig?.versionId || ""
+                }
+              }
+            };
+          }),
+          ...(this.flags.moduleIds || []).map((moduleId) => ({
+            bucketLocation: {
+              case: "moduleId",
+              value: moduleId
+            }
+          }))
+        ],
+        userId,
+        organizationId
+      });
+    }
+    if (flags.output === "json") {
+      console.log(JSON.stringify({ requestId, ...response }, null, 2));
+    } else {
+      if (!flags.requestId) {
+        console.log(`Request ID: ${requestId}`);
+      }
+      console.log("\nSearch Results:\n");
+      for (const result of response.results) {
+        console.log("----------------------------------------");
+        console.log(`Type: ${result.type || "N/A"}`);
+        console.log(`Score: ${result.score || 0}`);
+        console.log(`Source: ${result.source ? `${result.source.bucket?.bucketName}/${result.source.object}` : "N/A"}`);
+        console.log(`Content: ${result.text || "N/A"}`);
+        console.log("----------------------------------------\n");
+      }
+      if (response.pagination) {
+        console.log("\nPagination Info:");
+        console.log(`Page ${response.pagination.page} of ${response.pagination.totalPages}`);
+        console.log(`Total Results: ${response.pagination.total}`);
+        console.log(`Has More: ${response.pagination.hasMore ? "Yes" : "No"}`);
+        if (response.pagination.hasMore) {
+          console.log(`
+To see next page, run:`);
+          console.log(
+            `npx raindrop query agent-search --requestId ${requestId} --page ${response.pagination.page + 1}`
+          );
+        }
+      }
+    }
+  }
+};
+export {
+  AgentSearch as default
+};

package/bundle/commands/tail.js

@@ -0,0 +1,31 @@
+import {
+  BaseCommand
+} from "../chunk-MCRKUPJY.js";
+import {
+  init_cjs_shims
+} from "../chunk-G6NE675D.js";
+
+// src/commands/tail.ts
+init_cjs_shims();
+var Tail = class extends BaseCommand {
+  static args = {};
+  static description = 'Legacy command - use "raindrop logs tail" instead';
+  static examples = [
+    `<%= config.bin %> logs tail`,
+    `<%= config.bin %> logs tail --application my-app`,
+    `<%= config.bin %> logs tail --application my-app --version v1.2.3`
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS
+  };
+  async run() {
+    this.log('\u26A0\uFE0F  Command moved to "raindrop logs tail"');
+    this.log("");
+    this.log("Please use: raindrop logs tail");
+    this.log("");
+    this.log("For more options, see: raindrop logs --help");
+  }
+};
+export {
+  Tail as default
+};