@hyperdrive.bot/cli 1.0.12 → 1.0.16

package/dist/commands/module/create.js

@@ -6,6 +6,27 @@ import { existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { basename, join } from 'node:path';
 import open from 'open';
 import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
+const FRAMEWORK_MODULE_TYPE_MAP = {
+    actix: 'backend',
+    angular: 'frontend',
+    aspnet: 'backend',
+    django: 'backend',
+    express: 'backend',
+    fastapi: 'backend',
+    fastify: 'backend',
+    flask: 'backend',
+    gin: 'backend',
+    koa: 'backend',
+    nextjs: 'frontend',
+    rails: 'backend',
+    react: 'frontend',
+    serverless: 'backend',
+    'serverless-express': 'backend',
+    'serverless-nestjs': 'backend',
+    spring: 'backend',
+    svelte: 'frontend',
+    vue: 'frontend',
+};
 export default class ModuleCreate extends Command {
     static description = 'Create a new project';
     static examples = [
@@ -47,6 +68,14 @@ export default class ModuleCreate extends Command {
         installCommand: Flags.string({
             description: 'Install command',
         }),
+        json: Flags.boolean({
+            default: false,
+            description: 'Output raw JSON response (requires all flags to be provided, skips interactive prompts)',
+        }),
+        'module-type': Flags.string({
+            description: 'Module deployment type (determines API Gateway vs CloudFront vs CDK)',
+            options: ['backend', 'frontend', 'cdk'],
+        }),
         name: Flags.string({
             description: 'Name of the project',
         }),
@@ -64,6 +93,9 @@ export default class ModuleCreate extends Command {
         slug: Flags.string({
             description: 'Slug of the project',
         }),
+        subdomain: Flags.string({
+            description: 'Subdomain prefix for custom domain URLs (e.g., "api", "app", "www", "" for apex)',
+        }),
         sourceDirectory: Flags.string({
             description: 'Source code directory (e.g., src, lib, . for root) - default: src for Lambda, . for static',
         }),
@@ -72,9 +104,12 @@ export default class ModuleCreate extends Command {
         }),
     };
     async run() {
-        this.log(chalk.green('🚀 Let\'s create a new Hyperdrive project!'));
         const { flags } = await this.parse(ModuleCreate);
-        const responses = await this.promptUser(flags);
+        const isJson = flags.json;
+        if (!isJson) {
+            this.log(chalk.green('🚀 Let\'s create a new Hyperdrive project!'));
+        }
+        const responses = isJson ? {} : await this.promptUser(flags);
         const service = new HyperdriveSigV4Service(flags.domain);
         const combinedData = { ...flags, ...responses };
         try {
@@ -82,7 +117,7 @@ export default class ModuleCreate extends Command {
             const sourceLocation = combinedData.sourceLocation;
             const gitInfo = this.parseGitUrl(sourceLocation);
             let gitConfig = {};
-            if (gitInfo) {
+            if (gitInfo && !isJson) {
                 this.log(chalk.blue(`\n🔍 Checking access to ${gitInfo.provider} repository...`));
                 const accessResult = await service.gitCheckRepoAccess({
                     provider: gitInfo.provider,
@@ -145,6 +180,11 @@ export default class ModuleCreate extends Command {
                     gitConfig = {};
                 }
             }
+            // Map kebab-case flag to camelCase API field
+            if (combinedData['module-type']) {
+                combinedData.moduleType = combinedData['module-type'];
+                delete combinedData['module-type'];
+            }
             // Filter out undefined values and ensure all required fields are strings
             const cleanedData = Object.fromEntries(Object.entries({ ...combinedData, ...gitConfig }).filter(([_, value]) => value !== undefined));
             // Convert sourceLocation from SSH to HTTPS format (API requirement)
@@ -162,10 +202,14 @@ export default class ModuleCreate extends Command {
             }
             const result = await service.moduleCreate(cleanedData);
             writeFileSync('.hyperdrive.json', JSON.stringify(result, null, 2), 'utf8');
+            if (isJson) {
+                this.log(JSON.stringify(result, null, 2));
+                return;
+            }
             this.log(chalk.blue('✨ Project created successfully! Here are the details:'));
             this.log(JSON.stringify(result, null, 2));
-            // Post-create: Offer Dockerfile generation
-            if (gitInfo && result.slug) {
+            // Post-create: Offer Dockerfile generation (skip for CDK modules)
+            if (gitInfo && result.slug && combinedData.moduleType !== 'cdk') {
                 await this.offerDockerfileGeneration(service, result.slug);
             }
         }
@@ -381,7 +425,8 @@ export default class ModuleCreate extends Command {
         this.log(chalk.white(`  hyperdrive module dockerfile --slug ${slug}`));
     }
     async promptUser(flags) {
-        const prompts = [];
+        let prompts = [];
+        const isCdk = flags['module-type'] === 'cdk';
         if (!flags.name) {
             prompts.push({
                 message: chalk.yellow('📛 Enter the project name:'),
@@ -411,89 +456,122 @@ export default class ModuleCreate extends Command {
                 validate: (input) => Boolean(input) || 'Default branch is required.',
             });
         }
-        if (!flags.runtime) {
-            prompts.push({
-                choices: [
-                    { name: 'Node.js', value: 'nodejs' },
-                    { name: 'Python', value: 'python' },
-                    { name: 'Go', value: 'go' },
-                    { name: 'Rust', value: 'rust' },
-                    { name: 'Java', value: 'java' },
-                    { name: '.NET', value: 'dotnet' },
-                    { name: 'Ruby', value: 'ruby' },
-                ],
-                default: 'nodejs',
-                message: chalk.yellow('⚡ What is the runtime?'),
-                name: 'runtime',
-                type: 'list',
-            });
-        }
-        if (!flags.runtimeVersion) {
-            prompts.push({
-                default: '20',
-                message: chalk.yellow('📦 What runtime version? (e.g., 20 for Node, 3.12 for Python)'),
-                name: 'runtimeVersion',
-            });
+        // Skip runtime/buildRuntime/framework prompts for CDK modules
+        if (!isCdk) {
+            if (!flags.runtime) {
+                prompts.push({
+                    choices: [
+                        { name: 'Node.js', value: 'nodejs' },
+                        { name: 'Python', value: 'python' },
+                        { name: 'Go', value: 'go' },
+                        { name: 'Rust', value: 'rust' },
+                        { name: 'Java', value: 'java' },
+                        { name: '.NET', value: 'dotnet' },
+                        { name: 'Ruby', value: 'ruby' },
+                    ],
+                    default: 'nodejs',
+                    message: chalk.yellow('⚡ What is the runtime?'),
+                    name: 'runtime',
+                    type: 'list',
+                });
+            }
+            if (!flags.runtimeVersion) {
+                prompts.push({
+                    default: '20',
+                    message: chalk.yellow('📦 What runtime version? (e.g., 20 for Node, 3.12 for Python)'),
+                    name: 'runtimeVersion',
+                });
+            }
+            if (!flags.buildRuntime) {
+                prompts.push({
+                    choices: [
+                        { name: 'Node.js', value: 'nodejs' },
+                        { name: 'Python', value: 'python' },
+                        { name: 'Go', value: 'go' },
+                        { name: 'Rust', value: 'rust' },
+                        { name: 'Java', value: 'java' },
+                        { name: '.NET', value: 'dotnet' },
+                        { name: 'Ruby', value: 'ruby' },
+                    ],
+                    default: 'nodejs',
+                    message: chalk.yellow('🐳 What build runtime should be used for the Docker template?'),
+                    name: 'buildRuntime',
+                    type: 'list',
+                });
+            }
+            if (!flags.framework) {
+                prompts.push({
+                    choices: [
+                        { name: 'Serverless Framework (sls deploy)', value: 'serverless' },
+                        { name: 'Serverless + Express (serverless-http)', value: 'serverless-express' },
+                        { name: 'Serverless + NestJS', value: 'serverless-nestjs' },
+                        { name: 'Express.js', value: 'express' },
+                        { name: 'Fastify', value: 'fastify' },
+                        { name: 'Koa', value: 'koa' },
+                        { name: 'Next.js', value: 'nextjs' },
+                        { name: 'React', value: 'react' },
+                        { name: 'Vue', value: 'vue' },
+                        { name: 'Angular', value: 'angular' },
+                        { name: 'Svelte', value: 'svelte' },
+                        { name: 'Flask', value: 'flask' },
+                        { name: 'Django', value: 'django' },
+                        { name: 'FastAPI', value: 'fastapi' },
+                        { name: 'Gin (Go)', value: 'gin' },
+                        { name: 'Actix (Rust)', value: 'actix' },
+                        { name: 'Spring (Java)', value: 'spring' },
+                        { name: 'ASP.NET', value: 'aspnet' },
+                        { name: 'Rails', value: 'rails' },
+                        { name: 'Other', value: 'other' },
+                    ],
+                    message: chalk.yellow('🏗️ What is the framework?'),
+                    name: 'framework',
+                    type: 'list',
+                });
+            }
         }
-        if (!flags.buildRuntime) {
+        // Collect framework answer before subdomain/moduleType prompts (needed for inference)
+        const answers = prompts.length > 0 ? await inquirer.prompt(prompts) : {};
+        prompts = [];
+        const resolvedFramework = (flags.framework || answers.framework);
+        const resolvedSlug = (flags.slug || answers.slug);
+        if (flags.subdomain === undefined) {
             prompts.push({
-                choices: [
-                    { name: 'Node.js', value: 'nodejs' },
-                    { name: 'Python', value: 'python' },
-                    { name: 'Go', value: 'go' },
-                    { name: 'Rust', value: 'rust' },
-                    { name: 'Java', value: 'java' },
-                    { name: '.NET', value: 'dotnet' },
-                    { name: 'Ruby', value: 'ruby' },
-                ],
-                default: 'nodejs',
-                message: chalk.yellow('🐳 What build runtime should be used for the Docker template?'),
-                name: 'buildRuntime',
-                type: 'list',
+                default: resolvedSlug || '',
+                message: chalk.yellow('🌐 Subdomain prefix (leave empty for apex/root domain):'),
+                name: 'subdomain',
             });
         }
-        if (!flags.framework) {
+        if (!flags['module-type']) {
+            const inferredType = resolvedFramework ? FRAMEWORK_MODULE_TYPE_MAP[resolvedFramework] : undefined;
             prompts.push({
                 choices: [
-                    { name: 'Serverless Framework (sls deploy)', value: 'serverless' },
-                    { name: 'Serverless + Express (serverless-http)', value: 'serverless-express' },
-                    { name: 'Serverless + NestJS', value: 'serverless-nestjs' },
-                    { name: 'Express.js', value: 'express' },
-                    { name: 'Fastify', value: 'fastify' },
-                    { name: 'Koa', value: 'koa' },
-                    { name: 'Next.js', value: 'nextjs' },
-                    { name: 'React', value: 'react' },
-                    { name: 'Vue', value: 'vue' },
-                    { name: 'Angular', value: 'angular' },
-                    { name: 'Svelte', value: 'svelte' },
-                    { name: 'Flask', value: 'flask' },
-                    { name: 'Django', value: 'django' },
-                    { name: 'FastAPI', value: 'fastapi' },
-                    { name: 'Gin (Go)', value: 'gin' },
-                    { name: 'Actix (Rust)', value: 'actix' },
-                    { name: 'Spring (Java)', value: 'spring' },
-                    { name: 'ASP.NET', value: 'aspnet' },
-                    { name: 'Rails', value: 'rails' },
-                    { name: 'Other', value: 'other' },
+                    { name: 'Backend (API Gateway)', value: 'backend' },
+                    { name: 'Frontend (CloudFront)', value: 'frontend' },
+                    { name: 'CDK (Infrastructure)', value: 'cdk' },
                 ],
-                message: chalk.yellow('🏗️ What is the framework?'),
-                name: 'framework',
+                ...(inferredType ? { default: inferredType } : {}),
+                message: chalk.yellow('🏗️ What is the module deployment type?'),
+                name: 'moduleType',
                 type: 'list',
             });
         }
-        if (!flags.buildCommand) {
-            prompts.push({
-                message: chalk.yellow('🔨 What is the build command?'),
-                name: 'buildCommand',
-            });
-        }
-        if (!flags.runCommand) {
-            prompts.push({
-                message: chalk.yellow('🚀 What is the command to run the application in production/live environments?'),
-                name: 'runCommand',
-            });
+        // Skip build/run command prompts for CDK modules
+        if (!isCdk) {
+            if (!flags.buildCommand) {
+                prompts.push({
+                    message: chalk.yellow('🔨 What is the build command?'),
+                    name: 'buildCommand',
+                });
+            }
+            if (!flags.runCommand) {
+                prompts.push({
+                    message: chalk.yellow('🚀 What is the command to run the application in production/live environments?'),
+                    name: 'runCommand',
+                });
+            }
         }
-        return inquirer.prompt(prompts);
+        const laterAnswers = prompts.length > 0 ? await inquirer.prompt(prompts) : {};
+        return { ...answers, ...laterAnswers };
     }
     suggestSlug() {
         const packagePath = join(process.cwd(), 'package.json');

package/dist/commands/module/list.d.ts

@@ -4,6 +4,7 @@ export default class ModuleList extends Command {
     static examples: string[];
     static flags: {
         domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
 }

package/dist/commands/module/list.js

@@ -2,23 +2,40 @@ import { Command, Flags } from '@oclif/core';
 import chalk from 'chalk';
 import { HyperdriveSigV4Service } from '../../services/hyperdrive-sigv4.js';
 import { printTable } from '../../utils/table.js';
+const MODULE_TYPE_DISPLAY = {
+    backend: 'Backend',
+    cdk: 'CDK',
+    frontend: 'Frontend',
+};
 export default class ModuleList extends Command {
     static description = 'List all modules/projects';
     static examples = [
         '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --json',
     ];
     static flags = {
         domain: Flags.string({
             char: 'd',
             description: 'Tenant domain (for multi-domain setups)',
         }),
+        json: Flags.boolean({
+            default: false,
+            description: 'Output raw JSON response',
+        }),
     };
     async run() {
         const { flags } = await this.parse(ModuleList);
+        const isJson = flags.json;
         try {
             const service = new HyperdriveSigV4Service(flags.domain);
-            this.log(chalk.blue('🔍 Fetching modules...'));
+            if (!isJson) {
+                this.log(chalk.blue('🔍 Fetching modules...'));
+            }
             const modules = await service.moduleList();
+            if (isJson) {
+                this.log(JSON.stringify(modules, null, 2));
+                return;
+            }
             if (!modules || modules.length === 0) {
                 this.log(chalk.yellow('⚠️  No modules found'));
                 return;
@@ -35,6 +52,10 @@ export default class ModuleList extends Command {
                     minWidth: 15,
                     get: (row) => chalk.cyan(row.slug),
                 },
+                moduleType: {
+                    header: 'Type',
+                    get: (row) => MODULE_TYPE_DISPLAY[row.moduleType] || 'Backend',
+                },
                 framework: {
                     header: 'Framework',
                 },

package/dist/commands/module/sync.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Module Sync Command
+ *
+ * Generates structured architecture summaries for modules.
+ * For each module: clone → detect _bmad or invoke Claude → validate YAML → upload via API.
+ * Replaces the deprecated `project sync` command with module-level ownership.
+ */
+import { Command } from '@oclif/core';
+export default class ModuleSync extends Command {
+    static args: {
+        module: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        domain: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private syncAllModules;
+    private syncSingleModule;
+    private syncModule;
+    private detectBmadDocs;
+    private runClaude;
+    private validateYaml;
+    private readGutEntities;
+    private mergeEntityRegistries;
+}