@hazeljs/cli 0.2.0-rc.7 → 0.2.0

package/@template/src/hello.controller.ts

@@ -1,6 +1,6 @@
 import { Controller, Get } from '@hazeljs/core';
 
-@Controller('/hello')
+@Controller('hello')
 export class HelloController {
   @Get()
   hello() {

package/README.md

@@ -44,13 +44,20 @@ The CLI provides commands to generate various HazelJS components, create new app
 
 ### Project Management
 
-#### Create New Application
+#### Create new application
 
+**Skeleton app (quick start, like create-next-app):**
+```bash
+hazel g app <appName>
+# Then: cd <appName> && npm install && npm run dev
+```
+
+**Full setup with interactive package selection:**
 ```bash
 hazel new <appName> [options]
 ```
 
-Creates a new HazelJS application with optional interactive setup.
+Creates a new HazelJS application. Use `hazel g app <name>` for a minimal skeleton; use `hazel new <name> -i` for interactive setup with optional packages.
 
 **Options:**
 - `-d, --dest <path>` - Destination path (default: current directory)
@@ -209,8 +216,35 @@ Or using the shorter alias:
 hazel g <component> <name> [options]
 ```
 
+#### Generation options
+
+- **One pattern:** `hazel g <type> <name> [--path <path>] [--dry-run] [--json]`
+- **List types:** `hazel g --list` — list all generator types
+- **List as JSON:** `hazel g --list --list-json` — output `{ "generators": [ ... ] }`
+- **Result as JSON:** add `--json` to any generator to get `{ "ok", "created", "nextSteps" }` on stdout
+- **Stable options:** `-p, --path`, `--dry-run`, and `--json` work the same for every generator.
+
+```bash
+# See what you can generate
+hazel g --list
+hazel g --list --list-json
+
+# Generate with JSON result
+hazel g controller users --json
+hazel g crud product --path src/products --json
+
+# Dry run (no files written)
+hazel g module orders --dry-run
+```
+
 ### Available Generators
 
+#### Skeleton app
+- `app` - Generate a skeleton HazelJS application (minimal template, like create-next-app). Use `hazel g app my-app` then `cd my-app && npm install && npm run dev`.
+
+#### Package setup
+- `setup` / `st` - Generate a minimal setup starter file for a HazelJS package (e.g. `hazel g setup swagger`).
+
 #### Core Components
 - `controller` / `c` - Generate a new controller
 - `service` / `s` - Generate a new service
@@ -232,6 +266,8 @@ hazel g <component> <name> [options]
 ### Generator Options
 
 - `-p, --path <path>` - Specify the path where the component should be generated (default: 'src')
+- `--dry-run` - Preview files without writing them
+- `--json` - Output result as JSON (created paths and next steps)
 - `-r, --route <route>` - Specify the route path (for CRUD generator)
 - `--platform <platform>` - For serverless, specify platform: `lambda` or `cloud-function` (default: 'lambda')
 
@@ -532,7 +568,8 @@ hazel start [-d] [-p <port>]       # Start application
 hazel test [pattern] [-w] [-c]     # Run tests
 
 # Code Generation (alias: g)
-hazel g crud <name>                # Complete CRUD resource
+hazel g app <name>                # Skeleton application
+hazel g crud <name>               # Complete CRUD resource
 hazel g controller <name>          # Controller
 hazel g service <name>             # Service
 hazel g module <name>              # Module

package/dist/commands/generate-agent.d.ts

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
+export declare function runAgent(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
 export declare function generateAgent(program: Command): void;

package/dist/commands/generate-agent.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAgent = runAgent;
 exports.generateAgent = generateAgent;
 const generator_1 = require("../utils/generator");
 const AGENT_TEMPLATE = `import { Agent, Tool } from '@hazeljs/agent';
@@ -40,19 +41,24 @@ class AgentGenerator extends generator_1.Generator {
         return AGENT_TEMPLATE;
     }
 }
+async function runAgent(name, options) {
+    const generator = new AgentGenerator();
+    return generator.generate({
+        name,
+        path: options.path,
+        dryRun: options.dryRun,
+        data: { description: `A ${name} agent` },
+    });
+}
 function generateAgent(program) {
     program
         .command('agent <name>')
         .description('Generate a new AI agent with @Agent and @Tool decorators')
         .option('-p, --path <path>', 'Path where the agent should be generated')
         .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
         .action(async (name, options) => {
-        const generator = new AgentGenerator();
-        await generator.generate({
-            name,
-            path: options.path,
-            dryRun: options.dryRun,
-            data: { description: `A ${name} agent` },
-        });
+        const result = await runAgent(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

package/dist/commands/generate-ai-service.d.ts

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
+export declare function runAIService(name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
 export declare function generateAIService(program: Command): void;

package/dist/commands/generate-ai-service.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAIService = runAIService;
 exports.generateAIService = generateAIService;
 const generator_1 = require("../utils/generator");
 const AI_SERVICE_TEMPLATE = `import { Service } from '@hazeljs/core';
@@ -34,6 +35,10 @@ class AIServiceGenerator extends generator_1.Generator {
         return AI_SERVICE_TEMPLATE;
     }
 }
+async function runAIService(name, options) {
+    const generator = new AIServiceGenerator();
+    return generator.generate({ name, path: options.path, dryRun: options.dryRun });
+}
 function generateAIService(program) {
     program
         .command('ai-service <name>')
@@ -41,8 +46,9 @@ function generateAIService(program) {
         .alias('ai')
         .option('-p, --path <path>', 'Path where the AI service should be generated')
         .option('--dry-run', 'Preview files without writing them')
+        .option('--json', 'Output result as JSON')
         .action(async (name, options) => {
-        const generator = new AIServiceGenerator();
-        await generator.generate({ name, path: options.path, dryRun: options.dryRun });
+        const result = await runAIService(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
     });
 }

package/dist/commands/generate-app.d.ts

@@ -1,2 +1,9 @@
 import { Command } from 'commander';
+import type { GenerateResult, GenerateCLIOptions } from '../utils/generator';
 export declare function generateApp(program: Command): void;
+/** Run the skeleton app generator (used by `hazel g app <name>`). Creates a minimal app, no install/git. */
+export declare function runApp(name: string, options: GenerateCLIOptions & {
+    path?: string;
+}): Promise<GenerateResult>;
+/** Register `app <name>` under the generate command (skeleton app, like create-next-app). */
+export declare function registerGenerateApp(generateCommand: Command): void;

package/dist/commands/generate-app.interactive-packages.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/generate-app.interactive-packages.test.js

@@ -0,0 +1,107 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const inquirer_1 = __importDefault(require("inquirer"));
+const commander_1 = require("commander");
+const generate_app_1 = require("./generate-app");
+jest.mock('fs');
+jest.mock('child_process', () => ({ execSync: jest.fn() }));
+jest.mock('inquirer');
+describe('generateApp interactive package wiring', () => {
+    const mockFs = fs_1.default;
+    const mockExec = child_process_1.execSync;
+    const mockInquirer = inquirer_1.default;
+    let exitSpy;
+    let logSpy;
+    beforeAll(() => {
+        exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+    });
+    afterAll(() => {
+        exitSpy.mockRestore();
+        logSpy.mockRestore();
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockExec.mockImplementation(() => undefined);
+        mockFs.mkdirSync.mockImplementation(() => undefined);
+        mockFs.copyFileSync.mockImplementation(() => undefined);
+        mockFs.writeFileSync.mockImplementation(() => undefined);
+        mockFs.readFileSync.mockReturnValue(JSON.stringify({ name: 'x', description: 'y' }));
+        const allPackages = [
+            '@hazeljs/config',
+            '@hazeljs/swagger',
+            '@hazeljs/prisma',
+            '@hazeljs/typeorm',
+            '@hazeljs/audit',
+            '@hazeljs/auth',
+            '@hazeljs/oauth',
+            '@hazeljs/cache',
+            '@hazeljs/cron',
+            '@hazeljs/websocket',
+            '@hazeljs/ai',
+            '@hazeljs/agent',
+            '@hazeljs/rag',
+            '@hazeljs/pdf-to-audio',
+            '@hazeljs/data',
+            '@hazeljs/event-emitter',
+            '@hazeljs/gateway',
+            '@hazeljs/graphql',
+            '@hazeljs/grpc',
+            '@hazeljs/kafka',
+            '@hazeljs/messaging',
+            '@hazeljs/ml',
+        ];
+        mockInquirer.prompt.mockResolvedValue({
+            description: 'My app',
+            author: 'Me',
+            license: 'Apache-2.0',
+            packages: allPackages,
+        });
+        // Simulate template exists and has some files/dirs
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s.includes(path_1.default.join('@template')))
+                return true; // template exists
+            if (s.endsWith(path_1.default.join('.', 'my-app')) || s.endsWith(path_1.default.join(process.cwd(), '.', 'my-app')))
+                return false; // dest doesn't exist
+            if (s.endsWith(path_1.default.join('my-app', 'package.json')))
+                return true; // updatePackageJson path
+            if (s.endsWith(path_1.default.join('my-app', 'src')))
+                return true;
+            return false;
+        });
+        mockFs.readdirSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s.includes('@template') && s.endsWith('@template'))
+                return ['package.json', 'src'];
+            if (s.includes('@template') && s.endsWith(path_1.default.join('@template', 'src')))
+                return ['index.ts', 'app.module.ts', 'hello.controller.ts'];
+            return [];
+        });
+        mockFs.lstatSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s.endsWith('src'))
+                return { isDirectory: () => true };
+            return { isDirectory: () => false };
+        });
+    });
+    it('covers interactive selection and scaffolding boilerplate', async () => {
+        const program = new commander_1.Command();
+        (0, generate_app_1.generateApp)(program);
+        await program.parseAsync(['new', 'my-app', '--dest', '.', '--interactive'], { from: 'user' });
+        expect(mockInquirer.prompt).toHaveBeenCalled();
+        // git init + npm install should be attempted (mocked)
+        expect(mockExec).toHaveBeenCalled();
+        // boilerplate writes (app.module/index/env files) should happen
+        expect(mockFs.writeFileSync).toHaveBeenCalled();
+        expect(exitSpy).not.toHaveBeenCalled();
+        const out = logSpy.mock.calls.map((c) => String(c[0])).join('\n');
+        expect(out).toContain('Project created successfully');
+    });
+});

package/dist/commands/generate-app.js

@@ -4,11 +4,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateApp = generateApp;
+exports.runApp = runApp;
+exports.registerGenerateApp = registerGenerateApp;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const chalk_1 = __importDefault(require("chalk"));
 const inquirer_1 = __importDefault(require("inquirer"));
+const generator_1 = require("../utils/generator");
 function copyRecursiveSync(src, dest) {
     if (fs_1.default.existsSync(src)) {
         fs_1.default.mkdirSync(dest, { recursive: true });
@@ -34,6 +37,94 @@ function updatePackageJson(destPath, appName, description) {
         fs_1.default.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
     }
 }
+/** Create a minimal skeleton app at destPath (template copy + package.json). No git, no install. */
+function createSkeletonAtDest(destPath, appName, description) {
+    const templatePath = path_1.default.join(__dirname, '../../@template');
+    if (fs_1.default.existsSync(templatePath)) {
+        copyRecursiveSync(templatePath, destPath);
+        updatePackageJson(destPath, appName, description);
+    }
+    else {
+        fs_1.default.mkdirSync(destPath, { recursive: true });
+        fs_1.default.mkdirSync(path_1.default.join(destPath, 'src'), { recursive: true });
+        const packageJson = {
+            name: appName,
+            version: '0.1.0',
+            description,
+            main: 'dist/index.js',
+            scripts: {
+                build: 'tsc',
+                start: 'node dist/index.js',
+                dev: 'ts-node-dev --respawn --transpile-only src/index.ts',
+                test: 'jest',
+                lint: 'eslint "src/**/*.ts"',
+                'lint:fix': 'eslint "src/**/*.ts" --fix',
+                format: 'prettier --write "src/**/*.ts"',
+            },
+            dependencies: { '@hazeljs/core': '^0.2.0', 'reflect-metadata': '^0.2.2' },
+            devDependencies: {
+                '@types/jest': '^29.5.12',
+                '@types/node': '^20.0.0',
+                '@typescript-eslint/eslint-plugin': '^8.18.2',
+                '@typescript-eslint/parser': '^8.18.2',
+                eslint: '^8.56.0',
+                'eslint-config-prettier': '^9.1.0',
+                'eslint-plugin-prettier': '^5.1.3',
+                jest: '^29.7.0',
+                prettier: '^3.2.5',
+                'ts-jest': '^29.1.2',
+                'ts-node-dev': '^2.0.0',
+                typescript: '^5.3.3',
+            },
+        };
+        fs_1.default.writeFileSync(path_1.default.join(destPath, 'package.json'), JSON.stringify(packageJson, null, 2));
+        const indexContent = `import 'reflect-metadata';
+import { HazelApp, HazelModule, Controller, Get } from '@hazeljs/core';
+
+@Controller('/')
+export class AppController {
+  @Get()
+  hello() {
+    return { message: 'Hello from HazelJS!' };
+  }
+}
+
+@HazelModule({
+  controllers: [AppController],
+})
+export class AppModule {}
+
+async function bootstrap() {
+  const app = new HazelApp(AppModule);
+  app.enableCors({ origin: '*', methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'] });
+  const port = parseInt(process.env.PORT || '3000', 10);
+  await app.listen(port);
+}
+
+bootstrap();
+`;
+        fs_1.default.writeFileSync(path_1.default.join(destPath, 'src', 'index.ts'), indexContent);
+        const tsConfig = {
+            compilerOptions: {
+                target: 'ES2020',
+                module: 'commonjs',
+                lib: ['ES2020'],
+                outDir: './dist',
+                rootDir: './src',
+                strict: true,
+                esModuleInterop: true,
+                skipLibCheck: true,
+                forceConsistentCasingInFileNames: true,
+                experimentalDecorators: true,
+                emitDecoratorMetadata: true,
+            },
+            include: ['src/**/*'],
+            exclude: ['node_modules', 'dist'],
+        };
+        fs_1.default.writeFileSync(path_1.default.join(destPath, 'tsconfig.json'), JSON.stringify(tsConfig, null, 2));
+        fs_1.default.writeFileSync(path_1.default.join(destPath, '.gitignore'), 'node_modules/\ndist/\n.env\n.DS_Store\ncoverage/\n*.log\n');
+    }
+}
 function scaffoldPackageBoilerplate(destPath, packages) {
     const srcPath = path_1.default.join(destPath, 'src');
     // Build up enhanced app.module.ts imports based on selected packages
@@ -446,3 +537,53 @@ coverage/
         }
     });
 }
+/** Run the skeleton app generator (used by `hazel g app <name>`). Creates a minimal app, no install/git. */
+async function runApp(name, options) {
+    const parentDir = options.path || '.';
+    const destPath = path_1.default.join(process.cwd(), parentDir, name);
+    if (options.dryRun) {
+        return {
+            ok: true,
+            created: [destPath],
+            dryRun: true,
+            nextSteps: [`cd ${name}`, 'npm install', 'npm run dev'],
+        };
+    }
+    if (fs_1.default.existsSync(destPath)) {
+        return {
+            ok: false,
+            created: [],
+            error: `Destination already exists: ${destPath}`,
+        };
+    }
+    try {
+        createSkeletonAtDest(destPath, name, 'A HazelJS application');
+        return {
+            ok: true,
+            created: [destPath],
+            nextSteps: [`cd ${name}`, 'npm install', 'npm run dev'],
+        };
+    }
+    catch (error) {
+        return {
+            ok: false,
+            created: [],
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/** Register `app <name>` under the generate command (skeleton app, like create-next-app). */
+function registerGenerateApp(generateCommand) {
+    generateCommand
+        .command('app <name>')
+        .description('Generate a skeleton HazelJS application (minimal template, no install)')
+        .option('-p, --path <path>', 'Parent directory for the app', '.')
+        .option('--dry-run', 'Preview without writing files')
+        .option('--json', 'Output result as JSON')
+        .action(async (name, options) => {
+        const result = await runApp(name, options);
+        (0, generator_1.printGenerateResult)(result, { json: options.json });
+        if (!result.ok)
+            process.exit(1);
+    });
+}

package/dist/commands/generate-app.new-command.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/generate-app.new-command.test.js

@@ -0,0 +1,86 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const child_process_1 = require("child_process");
+const inquirer_1 = __importDefault(require("inquirer"));
+const commander_1 = require("commander");
+const generate_app_1 = require("./generate-app");
+jest.mock('fs');
+jest.mock('child_process', () => ({ execSync: jest.fn() }));
+jest.mock('inquirer');
+describe('generateApp (hazel new)', () => {
+    const mockFs = fs_1.default;
+    const mockExec = child_process_1.execSync;
+    const mockInquirer = inquirer_1.default;
+    let exitSpy;
+    let logSpy;
+    let errSpy;
+    beforeAll(() => {
+        exitSpy = jest.spyOn(process, 'exit').mockImplementation(() => undefined);
+        logSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
+        errSpy = jest.spyOn(console, 'error').mockImplementation(() => undefined);
+    });
+    afterAll(() => {
+        exitSpy.mockRestore();
+        logSpy.mockRestore();
+        errSpy.mockRestore();
+    });
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockExec.mockImplementation(() => undefined);
+        mockFs.mkdirSync.mockImplementation(() => undefined);
+        mockFs.writeFileSync.mockImplementation(() => undefined);
+        mockFs.copyFileSync.mockImplementation(() => undefined);
+        mockFs.readdirSync.mockReturnValue([]);
+        mockFs.lstatSync.mockReturnValue({ isDirectory: () => false });
+        mockInquirer.prompt.mockResolvedValue({});
+    });
+    it('exits if destination already exists', async () => {
+        // dest exists
+        mockFs.existsSync.mockImplementation((p) => String(p).endsWith('my-app'));
+        const program = new commander_1.Command();
+        (0, generate_app_1.generateApp)(program);
+        await program.parseAsync(['new', 'my-app', '--dest', '.'], { from: 'user' });
+        expect(exitSpy).toHaveBeenCalledWith(1);
+    });
+    it('creates basic structure when template missing and skip install/git', async () => {
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s.includes('@template'))
+                return false;
+            if (s.endsWith('my-app'))
+                return false;
+            return false;
+        });
+        const program = new commander_1.Command();
+        (0, generate_app_1.generateApp)(program);
+        await program.parseAsync(['new', 'my-app', '--dest', '.', '--skip-install', '--skip-git'], { from: 'user' });
+        expect(mockFs.mkdirSync).toHaveBeenCalled();
+        expect(mockFs.writeFileSync).toHaveBeenCalled();
+        expect(mockExec).not.toHaveBeenCalled(); // skipped install + git
+        expect(exitSpy).not.toHaveBeenCalled();
+    });
+    it('runs interactive prompt when -i is set', async () => {
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s.includes('@template'))
+                return false;
+            if (s.endsWith('my-app'))
+                return false;
+            return false;
+        });
+        mockInquirer.prompt.mockResolvedValue({
+            description: 'My app',
+            author: 'Me',
+            license: 'MIT',
+            packages: [],
+        });
+        const program = new commander_1.Command();
+        (0, generate_app_1.generateApp)(program);
+        await program.parseAsync(['new', 'my-app', '--dest', '.', '--skip-install', '--skip-git', '--interactive'], { from: 'user' });
+        expect(mockInquirer.prompt).toHaveBeenCalled();
+    });
+});

package/dist/commands/generate-app.skeleton.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/generate-app.skeleton.test.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const generate_app_1 = require("./generate-app");
+jest.mock('fs');
+describe('runApp (skeleton app)', () => {
+    const mockFs = fs_1.default;
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockFs.mkdirSync.mockImplementation(() => undefined);
+        mockFs.writeFileSync.mockImplementation(() => undefined);
+        mockFs.copyFileSync.mockImplementation(() => undefined);
+        mockFs.readdirSync.mockReturnValue([]);
+        mockFs.lstatSync.mockReturnValue({ isDirectory: () => false });
+    });
+    it('should return dry-run result without touching fs', async () => {
+        const result = await (0, generate_app_1.runApp)('my-app', { path: '.', dryRun: true });
+        expect(result.ok).toBe(true);
+        expect(result.dryRun).toBe(true);
+        expect(result.created[0]).toContain(path_1.default.join(process.cwd(), 'my-app'));
+        expect(mockFs.mkdirSync).not.toHaveBeenCalled();
+        expect(mockFs.writeFileSync).not.toHaveBeenCalled();
+    });
+    it('should fail if destination already exists', async () => {
+        mockFs.existsSync.mockReturnValue(true);
+        const result = await (0, generate_app_1.runApp)('my-app', { path: '.', dryRun: false });
+        expect(result.ok).toBe(false);
+        expect(result.error).toContain('Destination already exists');
+    });
+    it('should create skeleton when destination does not exist', async () => {
+        // destPath doesn't exist; templatePath also doesn't exist -> fallback basic structure
+        mockFs.existsSync.mockImplementation((p) => {
+            const s = String(p);
+            if (s.endsWith(path_1.default.join('.', 'my-app')) || s.endsWith(path_1.default.join(process.cwd(), '.', 'my-app')))
+                return false;
+            if (s.includes('@template'))
+                return false;
+            return false;
+        });
+        const result = await (0, generate_app_1.runApp)('my-app', { path: '.', dryRun: false });
+        expect(result.ok).toBe(true);
+        expect(result.created).toHaveLength(1);
+        expect(mockFs.mkdirSync).toHaveBeenCalled();
+        expect(mockFs.writeFileSync).toHaveBeenCalled();
+        expect(result.nextSteps).toEqual(['cd my-app', 'npm install', 'npm run dev']);
+    });
+});

package/dist/commands/generate-auth.d.ts

@@ -1,2 +1,4 @@
 import { Command } from 'commander';
+import { GenerateResult, GenerateCLIOptions } from '../utils/generator';
+export declare function runAuth(_name: string, options: GenerateCLIOptions): Promise<GenerateResult>;
 export declare function generateAuth(command: Command): void;