Code Generation

turbo generate [generator] [options]
turbo gen [generator] [options]        # shorthand
turbo g [generator] [options]          # shorter shorthand

# Interactive generation
turbo generate

# Generate with specific generator
turbo generate my-custom-generator

# Generate with configuration
turbo generate --config=./gen-config.js

--tag <tag>                        # Generator tag/version (default: "latest")
--config <file> / -c               # Generator configuration file
--root <path> / -r                 # Repository root directory
--args <args...> / -a              # Arguments passed to generator

# Generation examples
turbo generate --tag=canary
turbo generate --config=./custom-gen.js my-generator
turbo generate my-generator --args="name=my-app" "template=react"

# Interactive generator selection
turbo generate

# Generate with specific configuration
turbo generate --config=./generators/workspace.js

# Generate with custom arguments
turbo generate my-app-generator --args="name=new-app" "framework=nextjs"

# Use canary version of generators
turbo generate --tag=canary my-generator

turbo generate workspace [options]
turbo gen workspace [options]          # shorthand
turbo gen w [options]                   # shorter shorthand

# Generate empty workspace
turbo generate workspace --name=my-new-app --empty

# Generate workspace from template
turbo generate workspace --name=web-app --copy=@myorg/template-app

# Generate workspace from GitHub template
turbo generate workspace --copy="https://github.com/user/repo/tree/main/apps/example"

--name <name> / -n                 # Workspace name
--empty / -b                       # Generate empty workspace (default: true)
--copy <source> / -c               # Copy from existing workspace or GitHub URL
--destination <path> / -d          # Output destination directory
--type <type> / -t                 # Workspace type
--root <path> / -r                 # Repository root
--example-path <path> / -p         # GitHub subdirectory path
--show-all-dependencies            # Show all available dependencies

# Local workspace as template
--copy=@myorg/existing-app

# GitHub repository (main branch)
--copy="https://github.com/user/repo"

# GitHub repository with specific branch
--copy="https://github.com/user/repo/tree/feature-branch"

# GitHub repository with subdirectory
--copy="https://github.com/user/repo/tree/main/apps/example"

# GitHub with branch and subdirectory (use --example-path)
--copy="https://github.com/user/repo/tree/feature/branch"
--example-path="apps/example"

# Create empty React application
turbo generate workspace --name=new-react-app --type=app --empty

# Copy from existing local workspace
turbo generate workspace --name=admin-panel --copy=@myorg/web-app

# Copy from GitHub template
turbo generate workspace \
  --name=new-service \
  --copy="https://github.com/company/templates/tree/main/services/api"

# Generate library with custom destination
turbo generate workspace \
  --name=ui-components \
  --type=lib \
  --destination=packages/ui

# Copy complex GitHub template with specific path
turbo generate workspace \
  --name=mobile-app \
  --copy="https://github.com/company/templates/tree/feature/mobile" \
  --example-path="apps/react-native"

turbo generate run [generator] [options]
turbo gen run [generator] [options]     # shorthand  
turbo gen r [generator] [options]       # shorter shorthand

# Run custom generator
turbo generate run my-component-generator

# Run with custom config and arguments
turbo generate run api-generator \
  --config=./gen/api-config.js \
  --args="service=user" "database=postgres"

--config <file> / -c               # Generator configuration file
--root <path> / -r                 # Repository root
--args <args...> / -a              # Arguments passed to generator

# Run component generator
turbo generate run component-generator --args="name=Button" "variant=primary"

# Run API generator with config
turbo generate run api-generator \
  --config=./generators/api.config.js \
  --args="resource=user" "crud=true"

# Run custom page generator
turbo generate run page-generator --args="route=/dashboard" "auth=required"

# Generator configuration file examples
./turbo/generators/config.js       # Default generator config location
./generators/custom.config.js      # Custom config file location

# Usage with configuration
turbo generate --config=./turbo/generators/workspace.js
turbo generate workspace --config=./generators/component.js

// Example generator configuration (JavaScript)
module.exports = {
  name: 'component-generator',
  description: 'Generates React components with TypeScript',
  prompts: [
    {
      type: 'input',
      name: 'name',
      message: 'Component name:',
    },
    {
      type: 'select',
      name: 'variant',
      message: 'Component variant:',
      choices: ['basic', 'form', 'layout'],
    },
  ],
  actions: [
    {
      type: 'add',
      path: 'components/{{kebabCase name}}/{{pascalCase name}}.tsx',
      templateFile: 'templates/component.hbs',
    },
  ],
};

interface GenerateOptions {
  tag: string;
  generator_name?: string;
  config?: string;
  root?: string;
  args: string[];
  command?: GenerateCommand;
}

interface GenerateWorkspaceOptions {
  name?: string;
  empty: boolean;
  copy?: string;
  destination?: string;
  type?: string;
  root?: string;
  example_path?: string;
  show_all_dependencies: boolean;
}

interface GeneratorCustomOptions {
  generator_name?: string;
  config?: string;
  root?: string;
  args: string[];
}

interface GeneratorConfig {
  name: string;
  description?: string;
  prompts?: GeneratorPrompt[];
  actions: GeneratorAction[];
}

interface GeneratorPrompt {
  type: "input" | "select" | "multiselect" | "confirm";
  name: string;
  message: string;
  choices?: string[] | PromptChoice[];
  default?: any;
  validate?: (input: any) => boolean | string;
}

interface PromptChoice {
  name: string;
  value: any;
  disabled?: boolean;
}

interface GeneratorAction {
  type: "add" | "modify" | "delete";
  path: string;
  template?: string;
  templateFile?: string;
  data?: Record<string, any>;
}

interface WorkspaceTemplate {
  name: string;
  path: string;
  type: "app" | "lib" | "tool";
  framework?: string;
  language?: string;
  dependencies: string[];
}