@liquidmetal-ai/raindrop 0.8.0 → 0.9.0

package/bundle/commands/build/env/set.js

@@ -1,12 +1,12 @@
 import {
   BaseCommand
-} from "../../../chunk-MCRKUPJY.js";
+} from "../../../chunk-OZWZILJX.js";
 import {
   __toESM,
   init_cjs_shims,
   require_lib,
   valueOf
-} from "../../../chunk-G6NE675D.js";
+} from "../../../chunk-HMD2JXLE.js";
 
 // src/commands/build/env/set.ts
 init_cjs_shims();
@@ -26,18 +26,30 @@ sets an env var/secret.
     ...BaseCommand.HIDDEN_FLAGS,
     root: import_core.Flags.string({ char: "r", description: "root directory", required: false, default: process.cwd() }),
     manifest: import_core.Flags.string({
-      char: "M",
       description: "project manifest",
       required: false,
       default: "raindrop.manifest"
     }),
     output: import_core.Flags.string({ char: "o", description: "output format", default: "table" }),
-    versionId: import_core.Flags.string({
+    "version-id": import_core.Flags.string({
       char: "v",
-      aliases: ["version"],
       description: "version ID",
       required: false
     }),
+    version: import_core.Flags.string({
+      description: "version ID (alias for --version-id)",
+      required: false,
+      hidden: true
+    }),
+    versionId: import_core.Flags.string({
+      description: "version ID (deprecated, use --version-id)",
+      required: false,
+      hidden: true,
+      deprecated: {
+        message: "use --version-id instead",
+        version: "2.0.0"
+      }
+    }),
     application: import_core.Flags.string({
       char: "a",
       description: "application to start",
@@ -94,13 +106,14 @@ sets an env var/secret.
       secretValue = Buffer.concat(chunks).toString("utf8");
     }
     const config = await this.loadConfig();
+    const versionId = this.flags["version-id"] || this.flags.version || this.flags.versionId || config.versionId || "";
     await catalogService.setEnvs({
       userId,
       organizationId,
       envs: [
         {
           applicationName: valueOf(app.name),
-          currentVersionId: this.flags.versionId || config.versionId || "",
+          currentVersionId: versionId,
           key: this.args.var,
           value: secretValue || "",
           isSecret

package/bundle/commands/build/find.js

@@ -1,9 +1,9 @@
 import {
   source_default
-} from "../../chunk-MVQYQJHI.js";
+} from "../../chunk-6GTBXHHK.js";
 import {
   BaseCommand
-} from "../../chunk-MCRKUPJY.js";
+} from "../../chunk-OZWZILJX.js";
 import {
   EPOCH_TS,
   QueryModulesResponseSchema,
@@ -14,7 +14,7 @@ import {
   timestampDate,
   toJsonString,
   valueOf
-} from "../../chunk-G6NE675D.js";
+} from "../../chunk-HMD2JXLE.js";
 
 // src/commands/build/find.ts
 init_cjs_shims();
@@ -46,7 +46,6 @@ Find modules for a specific application and version.
     ...BaseCommand.HIDDEN_FLAGS,
     root: import_core.Flags.string({ char: "r", description: "root directory", required: false, default: process.cwd() }),
     manifest: import_core.Flags.string({
-      char: "M",
       description: "project manifest",
       required: false,
       default: "raindrop.manifest"
@@ -56,11 +55,16 @@ Find modules for a specific application and version.
       description: "application",
       required: false
     }),
-    version: import_core.Flags.string({
+    "version-id": import_core.Flags.string({
       char: "v",
-      description: "application version",
+      description: "application version ID",
       required: false
     }),
+    version: import_core.Flags.string({
+      description: "application version ID (alias for --version-id)",
+      required: false,
+      hidden: true
+    }),
     moduleType: import_core.Flags.string({
       description: "filter by module type (e.g. smartbucket)",
       required: false
@@ -112,9 +116,12 @@ Find modules for a specific application and version.
     let applicationName;
     let applicationVersionId;
     if (!flags.all) {
-      if (!flags.version) {
+      const normalizedVersion = this.flags["version-id"] || this.flags.version;
+      if (!normalizedVersion) {
         const config = await this.loadConfig();
         applicationVersionId = config.versionId;
+      } else {
+        applicationVersionId = normalizedVersion;
       }
       if (!flags.application) {
         const apps = await this.loadManifest();
@@ -276,9 +283,10 @@ ${source_default.bold(appKey)}${workosInfo} ${source_default.dim(`(${modules.len
     return result;
   }
   async queryResources(flags) {
-    if (!flags.version) {
+    let versionId = this.flags["version-id"] || this.flags.version;
+    if (!versionId) {
       const config = await this.loadConfig();
-      flags.version = config.versionId;
+      versionId = config.versionId;
     }
     if (!flags.application) {
       const apps = await this.loadManifest();
@@ -293,7 +301,7 @@ ${source_default.bold(appKey)}${workosInfo} ${source_default.dim(`(${modules.len
     const resp = await catalogService.queryResources({
       userId,
       applicationName: flags.application,
-      applicationVersionId: flags.version || "",
+      applicationVersionId: versionId || "",
       organizationId
     });
     if (flags.output === "table") {

package/bundle/commands/build/generate.js

@@ -4,17 +4,17 @@ import {
   codegenPlan,
   gatherEnvForHandler,
   renderCodegenPlan
-} from "../../chunk-W2L3MYN6.js";
+} from "../../chunk-AKNNZNIC.js";
 import {
   BaseCommand
-} from "../../chunk-MCRKUPJY.js";
+} from "../../chunk-OZWZILJX.js";
 import {
   __toESM,
   getCurrentVersion,
   init_cjs_shims,
   require_lib,
   valueOf
-} from "../../chunk-G6NE675D.js";
+} from "../../chunk-HMD2JXLE.js";
 
 // src/commands/build/generate.ts
 init_cjs_shims();
@@ -28,7 +28,7 @@ var Generate = class extends BaseCommand {
   static flags = {
     root: import_core.Flags.string({ char: "r", description: "root directory", required: false, default: process.cwd() }),
     manifest: import_core.Flags.string({
-      char: "M",
+      char: "m",
       description: "project manifest",
       required: false,
       default: "raindrop.manifest"

package/bundle/commands/build/init.js

@@ -2,17 +2,17 @@ import {
   codegenPlan,
   fileExists,
   renderCodegenPlan
-} from "../../chunk-W2L3MYN6.js";
+} from "../../chunk-AKNNZNIC.js";
 import {
   BaseCommand
-} from "../../chunk-MCRKUPJY.js";
+} from "../../chunk-OZWZILJX.js";
 import {
   __toESM,
   getCurrentVersion,
   init_cjs_shims,
   mustManifestFromString,
   require_lib
-} from "../../chunk-G6NE675D.js";
+} from "../../chunk-HMD2JXLE.js";
 
 // src/commands/build/init.ts
 init_cjs_shims();

package/bundle/commands/build/list-templates.js

@@ -0,0 +1,63 @@
+import {
+  listTemplates
+} from "../../chunk-6CDCK5IP.js";
+import {
+  source_default
+} from "../../chunk-MVQYQJHI.js";
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/build/list-templates.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+var ListTemplates = class extends BaseCommand {
+  static args = {};
+  static description = "list available Raindrop templates";
+  static examples = [
+    `<%= config.bin %> <%= command.id %>
+List all available templates in text format.
+`,
+    `<%= config.bin %> <%= command.id %> -o json
+List templates in JSON format.
+`
+  ];
+  static flags = {
+    output: import_core.Flags.string({
+      char: "o",
+      description: "output format",
+      default: "text",
+      options: ["text", "json"]
+    })
+  };
+  async run() {
+    const templates = listTemplates();
+    if (this.flags.output === "json") {
+      console.log(JSON.stringify(templates, null, 2));
+      return;
+    }
+    this.log(source_default.bold.underline("\nAvailable Raindrop Templates\n"));
+    for (const template of templates) {
+      this.log(source_default.bold.cyan(`${template.id}`));
+      this.log(`  ${source_default.bold("Name:")} ${template.name}`);
+      this.log(`  ${source_default.bold("Type:")} ${template.type}`);
+      this.log(`  ${source_default.bold("Description:")} ${template.description}`);
+      if (template.type === "clone" && template.githubPath) {
+        this.log(`  ${source_default.dim(`Source: ${template.githubPath}`)}`);
+      }
+      this.log("");
+    }
+    this.log(source_default.dim(`Total: ${templates.length} template${templates.length !== 1 ? "s" : ""}`));
+    this.log(source_default.dim("\nTo clone a template, run:"));
+    this.log(source_default.dim("  raindrop build clone <template-id> <directory>"));
+    this.log("");
+  }
+};
+export {
+  ListTemplates as default
+};

package/bundle/commands/build/list.js

@@ -1,10 +1,10 @@
 import {
   List,
   statusString
-} from "../../chunk-CMCEP64V.js";
-import "../../chunk-MVQYQJHI.js";
-import "../../chunk-MCRKUPJY.js";
-import "../../chunk-G6NE675D.js";
+} from "../../chunk-MNUILM7W.js";
+import "../../chunk-6GTBXHHK.js";
+import "../../chunk-OZWZILJX.js";
+import "../../chunk-HMD2JXLE.js";
 export {
   List as default,
   statusString

package/bundle/commands/build/package-template.js

@@ -0,0 +1,238 @@
+import {
+  BaseCommand
+} from "../../chunk-MCRKUPJY.js";
+import {
+  __toESM,
+  init_cjs_shims,
+  require_lib
+} from "../../chunk-G6NE675D.js";
+
+// src/commands/build/package-template.ts
+init_cjs_shims();
+var import_core = __toESM(require_lib(), 1);
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import os from "node:os";
+var PackageTemplate = class extends BaseCommand {
+  static args = {
+    "app-name": import_core.Args.string({ description: "Name for the template application (kebab-case)", required: true }),
+    description: import_core.Args.string({ description: "Description of the template", required: true }),
+    path: import_core.Args.string({ description: "Destination path for the template", required: true })
+  };
+  static description = "Package the current raindrop project as a template";
+  static examples = [
+    '<%= config.bin %> <%= command.id %> my-app "A sample application" ./templates'
+  ];
+  static flags = {
+    ...BaseCommand.HIDDEN_FLAGS
+  };
+  async run() {
+    const { "app-name": appName, description, path: destPath } = this.args;
+    if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(appName)) {
+      this.error("App name must be in kebab-case format (e.g., my-app-name)", { exit: 1 });
+    }
+    const projectRoot = process.cwd();
+    const destDir = path.resolve(destPath, appName);
+    try {
+      await fs.access(destDir);
+      this.warn(`Directory ${destDir} already exists. It will be overwritten.`);
+    } catch {
+    }
+    await fs.mkdir(destDir, { recursive: true });
+    this.log(`Packaging template from ${projectRoot} to ${destDir}...`);
+    await this.copyProjectFiles(projectRoot, destDir);
+    await this.updatePackageJson(destDir, appName);
+    await this.updateManifest(destDir, appName);
+    await this.copyRaindropDocs(destDir);
+    await this.removeGitInfo(destDir);
+    await this.createDocsReadme(destDir, appName, description);
+    await this.createGitignore(destDir);
+    this.log(`
+Template packaged successfully at ${destDir}`);
+  }
+  async copyProjectFiles(source, dest) {
+    const excludeDirs = ["node_modules", "dist", "build", ".git"];
+    const excludeFiles = [".env", ".env.local", ".env.production", "secrets.json"];
+    const copyRecursive = async (src, dst) => {
+      const entries = await fs.readdir(src, { withFileTypes: true });
+      for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const dstPath = path.join(dst, entry.name);
+        if (entry.isDirectory()) {
+          if (excludeDirs.includes(entry.name)) {
+            continue;
+          }
+          await fs.mkdir(dstPath, { recursive: true });
+          await copyRecursive(srcPath, dstPath);
+        } else {
+          if (excludeFiles.includes(entry.name)) {
+            continue;
+          }
+          await fs.copyFile(srcPath, dstPath);
+        }
+      }
+    };
+    await copyRecursive(source, dest);
+  }
+  async updatePackageJson(destDir, appName) {
+    const packageJsonPath = path.join(destDir, "package.json");
+    try {
+      const content = await fs.readFile(packageJsonPath, "utf-8");
+      const packageJson = JSON.parse(content);
+      packageJson.name = appName;
+      await fs.writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2) + "\n", "utf-8");
+      this.log(`Updated package.json with name: ${appName}`);
+    } catch (_error) {
+      this.warn(`Could not update package.json: ${_error}`);
+    }
+  }
+  async updateManifest(destDir, appName) {
+    const manifestPath = path.join(destDir, "raindrop.manifest");
+    try {
+      const content = await fs.readFile(manifestPath, "utf-8");
+      const updated = content.replace(/^application\s+"[^"]+"\s*{/m, `application "${appName}" {`);
+      await fs.writeFile(manifestPath, updated, "utf-8");
+      this.log(`Updated raindrop.manifest with application: ${appName}`);
+    } catch (_error) {
+      this.warn(`Could not update raindrop.manifest: ${_error}`);
+    }
+  }
+  async copyRaindropDocs(destDir) {
+    const raindropDir = path.join(os.homedir(), ".raindrop");
+    const indexPath = path.join(raindropDir, "index.json");
+    try {
+      const manifestPath = path.join(process.cwd(), "raindrop.manifest");
+      const manifestContent = await fs.readFile(manifestPath, "utf-8");
+      const appNameMatch = manifestContent.match(/^application\s+"([^"]+)"\s*{/m);
+      if (!appNameMatch) {
+        this.warn("Could not parse application name from raindrop.manifest");
+        await fs.mkdir(path.join(destDir, "docs"), { recursive: true });
+        return;
+      }
+      const currentAppName = appNameMatch[1];
+      const indexContent = await fs.readFile(indexPath, "utf-8");
+      const index = JSON.parse(indexContent);
+      let sessionId = null;
+      if (index.applications && index.applications[currentAppName]) {
+        sessionId = index.applications[currentAppName].latest_session_id;
+      }
+      if (!sessionId) {
+        this.warn(`Could not find raindrop session for application: ${currentAppName}`);
+        await fs.mkdir(path.join(destDir, "docs"), { recursive: true });
+        return;
+      }
+      const appDocsDir = path.join(raindropDir, sessionId);
+      try {
+        await fs.access(appDocsDir);
+      } catch {
+        this.warn(`Raindrop docs directory not found: ${appDocsDir}`);
+        await fs.mkdir(path.join(destDir, "docs"), { recursive: true });
+        return;
+      }
+      const destDocsDir = path.join(destDir, "docs");
+      await fs.mkdir(destDocsDir, { recursive: true });
+      const entries = await fs.readdir(appDocsDir, { withFileTypes: true });
+      for (const entry of entries) {
+        const srcPath = path.join(appDocsDir, entry.name);
+        const dstPath = path.join(destDocsDir, entry.name);
+        if (entry.isDirectory()) {
+          await fs.mkdir(dstPath, { recursive: true });
+          const copyDir = async (src, dst) => {
+            const subEntries = await fs.readdir(src, { withFileTypes: true });
+            for (const subEntry of subEntries) {
+              const subSrc = path.join(src, subEntry.name);
+              const subDst = path.join(dst, subEntry.name);
+              if (subEntry.isDirectory()) {
+                await fs.mkdir(subDst, { recursive: true });
+                await copyDir(subSrc, subDst);
+              } else {
+                await fs.copyFile(subSrc, subDst);
+              }
+            }
+          };
+          await copyDir(srcPath, dstPath);
+        } else {
+          await fs.copyFile(srcPath, dstPath);
+        }
+      }
+      this.log(`Copied raindrop docs from ${appDocsDir}`);
+    } catch (_error) {
+      this.warn(`Could not copy raindrop docs: ${_error}`);
+      await fs.mkdir(path.join(destDir, "docs"), { recursive: true });
+    }
+  }
+  async removeGitInfo(destDir) {
+    const gitDir = path.join(destDir, ".git");
+    try {
+      await fs.rm(gitDir, { recursive: true, force: true });
+      this.log("Removed .git directory");
+    } catch {
+    }
+  }
+  async createDocsReadme(destDir, appName, description) {
+    const docsDir = path.join(destDir, "docs");
+    const readmePath = path.join(docsDir, "README.md");
+    const readmeContent = `# ${appName}
+
+## Description
+
+${description}
+
+## Usage
+
+Instructions for using this template will be added here.
+`;
+    await fs.writeFile(readmePath, readmeContent, "utf-8");
+    this.log("Created docs/README.md");
+  }
+  async createGitignore(destDir) {
+    const gitignorePath = path.join(destDir, ".gitignore");
+    const gitignoreContent = `# Dependencies
+node_modules/
+.pnpm-store/
+
+# Build outputs
+dist/
+build/
+*.tsbuildinfo
+
+# Environment variables
+.env
+.env.local
+.env.production
+.env.*.local
+
+# Secrets
+secrets.json
+*.key
+*.pem
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+logs/
+
+# Testing
+coverage/
+.nyc_output/
+
+# Raindrop local config
+.raindrop/
+`;
+    await fs.writeFile(gitignorePath, gitignoreContent, "utf-8");
+    this.log("Created .gitignore");
+  }
+};
+export {
+  PackageTemplate as default
+};

package/bundle/commands/build/sandbox.js

@@ -1,18 +1,18 @@
 import {
   sandbox
-} from "../../chunk-XYJACVNA.js";
-import "../../chunk-MGM2L2T3.js";
-import "../../chunk-VXAZKB3J.js";
-import "../../chunk-W2L3MYN6.js";
-import "../../chunk-PU4RCSXF.js";
+} from "../../chunk-YDVG2SA2.js";
+import "../../chunk-OROAB5YF.js";
+import "../../chunk-DOTQ3CSX.js";
+import "../../chunk-AKNNZNIC.js";
+import "../../chunk-ZQQFKWNC.js";
 import {
   BaseCommand
-} from "../../chunk-MCRKUPJY.js";
+} from "../../chunk-OZWZILJX.js";
 import {
   __toESM,
   init_cjs_shims,
   require_lib
-} from "../../chunk-G6NE675D.js";
+} from "../../chunk-HMD2JXLE.js";
 
 // src/commands/build/sandbox.ts
 init_cjs_shims();
@@ -33,20 +33,26 @@ var Sandbox = class extends BaseCommand {
       hidden: true
     }),
     manifest: import_core.Flags.string({ default: "raindrop.manifest", description: "project manifest" }),
-    version: import_core.Flags.string({
+    "version-id": import_core.Flags.string({
       char: "v",
-      description: "application version to sandbox",
+      description: "application version ID to sandbox",
       required: false
+    }),
+    version: import_core.Flags.string({
+      description: "application version ID to sandbox (alias for --version-id)",
+      required: false,
+      hidden: true
     })
   };
   async run() {
+    const versionId = this.flags["version-id"] || this.flags.version;
     let applications;
     try {
       applications = await sandbox({
         command: this,
         isSandboxed: true,
         impersonate: this.flags.impersonate,
-        versionId: this.flags.version
+        versionId
       });
     } catch (error) {
       if (error instanceof Error) {

package/bundle/commands/build/start.js

@@ -1,12 +1,12 @@
 import {
   BaseCommand
-} from "../../chunk-MCRKUPJY.js";
+} from "../../chunk-OZWZILJX.js";
 import {
   __toESM,
   init_cjs_shims,
   require_lib,
   valueOf
-} from "../../chunk-G6NE675D.js";
+} from "../../chunk-HMD2JXLE.js";
 
 // src/commands/build/start.ts
 init_cjs_shims();
@@ -23,7 +23,6 @@ Start a Raindrop application.
     ...BaseCommand.HIDDEN_FLAGS,
     root: import_core.Flags.string({ char: "r", description: "root directory", required: false, default: process.cwd() }),
     manifest: import_core.Flags.string({
-      char: "M",
       description: "project manifest",
       required: false,
       default: "raindrop.manifest"
@@ -33,11 +32,16 @@ Start a Raindrop application.
       description: "application to start",
       required: false
     }),
-    version: import_core.Flags.string({
+    "version-id": import_core.Flags.string({
       char: "v",
-      description: "application version to start",
+      description: "application version ID to start",
       required: false
     }),
+    version: import_core.Flags.string({
+      description: "application version ID to start (alias for --version-id)",
+      required: false,
+      hidden: true
+    }),
     impersonate: import_core.Flags.string({
       char: "i",
       description: "impersonate organization",
@@ -61,7 +65,7 @@ Start a Raindrop application.
       }
       applicationName = valueOf(app.name);
     }
-    const currentVersionId = this.flags.version ?? config.versionId;
+    const currentVersionId = (this.flags["version-id"] || this.flags.version) ?? config.versionId;
     if (!currentVersionId) {
       this.error("Expected a --version flag to be provided when a version is not currently set");
     }