Command Execution

/**
 * Execute a specific command from GitBook command list
 * @param commands - Array of available GitBook commands
 * @param command - Command name to execute
 * @param args - Array of positional arguments
 * @param kwargs - Object of named arguments/options
 * @returns Promise resolving to command result
 */
function exec(commands, command, args, kwargs): Promise<any>;

const commands = require('gitbook-cli/lib/commands');

// Execute build command
try {
  const result = await commands.exec(gitbook.commands, 'build', ['.'], {
    output: './output',
    format: 'website'
  });
  console.log('Build completed successfully');
} catch (error) {
  console.error('Build failed:', error.message);
}

// Execute serve command with options
await commands.exec(gitbook.commands, 'serve', ['.'], {
  port: 4000,
  lrport: 35729,
  watch: true
});

/**
 * Display formatted help for list of commands
 * @param commands - Array of GitBook commands to document
 * @returns void (prints to console)
 */
function help(commands): void;

const commands = require('gitbook-cli/lib/commands');

// Display help for all available commands
const gitbook = await manager.ensureAndLoad(process.cwd());
commands.help(gitbook.commands);

// Output format:
//     build                           Build the book
//         --log                       Minimum log level (Default is info)
//         --format                    Format to build (Default is website)
//         --[no-]timing               Print timing debug information
//     
//     serve                           Serve the book as a website  
//         --port                      Port for server (Default is 4000)
//         --lrport                    Port for livereload server

# List locally installed GitBook versions
gitbook ls
# Displays all installed versions with current selection marked

# Show currently activated GitBook version for a project
gitbook current
# Resolves version from book.json or uses default

# List available GitBook versions from NPM registry
gitbook ls-remote
# Shows all published versions and release tags

# Download and install a GitBook version
gitbook fetch [version]
# version defaults to '*' (latest) if not specified
# Example: gitbook fetch 2.6.7

# Update to latest version of a release tag
gitbook update [tag]
# tag defaults to 'latest' if not specified
# Example: gitbook update beta

# Remove an installed GitBook version
gitbook uninstall [version]
# Example: gitbook uninstall 2.5.0

# Create an alias pointing to a local GitBook folder
gitbook alias [folder] [version]
# folder defaults to current directory
# version defaults to 'latest'
# Example: gitbook alias /path/to/dev-gitbook dev

# Display help for GitBook commands
gitbook help
# Shows available commands from the loaded GitBook version

# Execute any GitBook command through version proxy
gitbook <command> [args...] [options...]

# Common GitBook commands (version-dependent):
gitbook build .                    # Build book to static website
gitbook serve . --port 3000        # Serve book with live reload
gitbook init ./new-book            # Initialize new GitBook project
gitbook pdf . output.pdf           # Export book as PDF
gitbook epub . output.epub         # Export book as EPUB
gitbook mobi . output.mobi         # Export book as MOBI

# Version-specific command execution:
gitbook build . --gitbook=2.6.7    # Use specific GitBook version

-v, --gitbook [version]    # Specify GitBook version to use
-d, --debug               # Enable verbose error output and stack traces
-V, --version             # Display running versions of CLI and GitBook

# Check versions
gitbook -V
# Output: CLI version: 2.3.2, GitBook version: 3.2.3

# Enable debug output
gitbook build . --debug
# Shows detailed error information if build fails

# Use specific version for single command
gitbook serve . --gitbook=2.6.7 --port 4000

try {
  await commands.exec(gitbookCommands, 'nonexistent', [], {});
} catch (error) {
  if (error.message.includes("doesn't exist")) {
    console.error('Command not found. Available commands:');
    commands.help(gitbookCommands);
  } else {
    console.error('Execution failed:', error.message);
  }
}

interface Command {
  name: string;              // Command name (e.g., 'build', 'serve')
  description: string;       // Human-readable description
  options?: CommandOption[]; // Array of command options
  exec: (args: string[], kwargs: object) => Promise<any>; // Execution function
}

interface CommandOption {
  name: string;           // Option name (without dashes)
  description: string;    // Option description
  defaults?: any;         // Default value if not provided
  values?: string[];      // Allowed values for validation
}

{
  name: "build",
  description: "Build the book", 
  options: [
    {
      name: "log",
      description: "Minimum log level",
      defaults: "info",
      values: ["debug", "info", "warn", "error"]
    },
    {
      name: "format", 
      description: "Format to build",
      defaults: "website",
      values: ["website", "json", "ebook"]
    },
    {
      name: "timing",
      description: "Print timing debug information",
      defaults: false
    }
  ],
  exec: async function(args, kwargs) {
    // Command implementation
  }
}