Multi-Command CLI Structure

import { makeComposableBuilder } from 'cli-forge';

export const withInitCommand = makeComposableBuilder((args) =>
  args.command('init', {
    description: 'Initialize a new project',
    builder: (cmd) =>
      cmd
        .option('name', {
          type: 'string',
          description: 'Project name',
          required: true,
        })
        .option('template', {
          type: 'string',
          description: 'Template to use',
          choices: ['basic', 'typescript', 'react'] as const,
          default: 'basic' as const,
        })
        .option('git', {
          type: 'boolean',
          description: 'Initialize git repository',
          default: true,
        }),

    handler: (args): { projectPath: string; template: string } => {
      console.log(`Initializing project: ${args.name}`);
      console.log(`  Template: ${args.template}`);
      console.log(`  Git: ${args.git ? 'yes' : 'no'}`);

      return {
        projectPath: `./${args.name}`,
        template: args.template,
      };
    },
  })
);

import { makeComposableBuilder } from 'cli-forge';

export interface BuildResult {
  success: boolean;
  outputDir: string;
  files: string[];
}

export const withBuildCommand = makeComposableBuilder((args) =>
  args.command('build', {
    description: 'Build the project for production',
    builder: (cmd) =>
      cmd
        .option('outDir', {
          type: 'string',
          description: 'Output directory',
          default: 'dist',
        })
        .option('minify', {
          type: 'boolean',
          description: 'Minify output',
          default: false,
        })
        .option('sourcemap', {
          type: 'boolean',
          description: 'Generate source maps',
          default: true,
        }),

    handler: (args): BuildResult => {
      console.log('Building project...');
      console.log(`  outDir: ${args.outDir}`);
      console.log(`  minify: ${args.minify}`);
      console.log(`  sourcemap: ${args.sourcemap}`);

      return {
        success: true,
        outputDir: args.outDir,
        files: ['index.js', 'styles.css'],
      };
    },
  })
);

import { makeComposableBuilder } from 'cli-forge';

export interface ServerInfo {
  url: string;
  port: number;
  host: string;
}

export const withServeCommand = makeComposableBuilder((args) =>
  args.command('serve', {
    description: 'Start development server',
    builder: (cmd) =>
      cmd
        .option('port', {
          type: 'number',
          alias: ['p'],
          description: 'Port to listen on',
          default: 3000,
        })
        .option('host', {
          type: 'string',
          description: 'Host to bind to',
          default: 'localhost',
        })
        .option('open', {
          type: 'boolean',
          description: 'Open browser automatically',
          default: false,
        }),

    handler: (args): ServerInfo => {
      const url = `http://${args.host}:${args.port}`;
      console.log(`Starting server on port ${args.port}...`);
      console.log(`  Host: ${args.host}`);
      console.log(`  URL: ${url}`);

      if (args.open) {
        console.log('Opening browser...');
      }

      return {
        url,
        port: args.port,
        host: args.host,
      };
    },
  })
);

import { cli, chain, makeComposableBuilder } from 'cli-forge';

import { withInitCommand } from './commands/init';
import { withBuildCommand, BuildResult } from './commands/build';
import { withServeCommand, ServerInfo } from './commands/serve';
import { group } from 'console';

const app = cli('project-cli', {
  description: 'Project management CLI',
  builder: (args) =>
    chain(args, withInitCommand, withBuildCommand, withServeCommand)
      .command('build-and-serve', {
        builder: (args) => {
          const siblings = args.getParent().getChildren();
          const withBuildArgs = siblings.build.getBuilder()!;
          const withServeArgs = siblings.serve.getBuilder()!;
          return chain(args, withBuildArgs, withServeArgs);
        },
        handler: async (args, ctx) => {
          const siblings = ctx.command.getParent().getChildren();
          const buildHandler = siblings.build.getHandler();
          const serveHandler = siblings.serve.getHandler();

          const buildResult = buildHandler
            ? await buildHandler({
                minify: args.minify,
                sourcemap: args.sourcemap,
                outDir: args.outDir,
              })
            : undefined;

          const serverInfo = serveHandler
            ? await serveHandler({
                port: args.port,
                host: args.host,
                open: args.open,
              })
            : undefined;

          console.log('Build successful:', buildResult);
          console.log('Server info:', serverInfo);

          return {
            buildResult,
            serverInfo,
          };
        },
      })
      .command({
        name: 'foo',
        builder: (args) =>
          args.command('bar', {
            handler: () => {
              console.log('bar');
            },
          }),
      })
      .option('foo', {
        type: 'string',
        group: 'Bar',
      })
      .group('Bar', ['foo'])
      .enableInteractiveShell(),
  // handler: async (_args, ctx) => {
  //   // Child handlers are typed - can invoke programmatically if needed
  //   const children = ctx.command.getChildren();

  //   const { init, build } = {
  //     init: children.init.getHandler(),
  //     build: children.build.getHandler(),
  //   };

  //   const result = init?.({
  //     git: true,
  //     name: 'MyProject',
  //     template: 'typescript',
  //   });

  //   const buildResult = build?.({
  //     minify: true,
  //     sourcemap: false,
  //     outDir: 'dist',
  //   });

  //   console.log('Build result:', buildResult);
  // },
});

export default app;

// Export types for consumers who want to use commands programmatically
export type { BuildResult, ServerInfo };

if (require.main === module) {
  app.forge();
}

1multi-command-cli/
2  cli.ts              # Entry point, registers commands
3  commands/
4    init.ts           # Initialize project
5    build.ts          # Build for production
6    serve.ts          # Development server