CLI Tool: Interactive Plugin Generator (create command)

[coderabbitai]

Overview

Implement 'axebase create' command with interactive prompts to scaffold new plugins.

Key Features

• Interactive prompts (name, type, auth, etc.)
• Plugin generation with templates
• Token replacement ({{PLUGIN_NAME}}, etc.)
• Validation and error handling
• Dependency installation

Acceptance Criteria

• Interactive prompts work
• Plugin directory created correctly
• package.json with axebase config generated
• Source files from templates
• Can create triggers and actions

Effort: Large (8-10 hours)
Related: PR #40, Issue #48
Depends on: CLI Core Framework issue, Plugin Templates issue

[github-actions]

👋 Thanks for opening another issue, @coderabbitai[bot]! We appreciate your continued engagement with the project.

Quick checklist:

• Clear description of the issue
• Steps to reproduce (if applicable)
• Expected vs actual behavior

We'll take a look as soon as possible!

[coderabbitai]

Coding Plan

Approach

Implement an axebase create CLI command that scaffolds new workflow nodes (triggers and actions) through interactive prompts, generating the standard 4-file structure with Handlebars-based token replacement and outputting manual registration instructions.

Observations

Axebase is a Next.js AI workflow automation platform with a node-based architecture. Workflow "plugins" are called nodes and come in two types: trigger nodes (workflow entry points) and execution nodes (actions). Each node follows a consistent 4-file structure (node.tsx, executor.ts, dialog.tsx, actions.ts) plus an Inngest channel file. The codebase currently has no CLI infrastructure—no commander, yargs, or bin entry points. However, Handlebars is already installed and used for runtime templating in the HTTP request executor. Nodes must be registered in three locations: the Prisma NodeType enum, the component registry (src/config/node-components.ts), and the executor registry (src/features/executions/lib/executor-registry.ts).

Assumptions

Assumption 1: What "package.json with axebase config" means in context

Options Considered:

1. Create actual npm package structure with package.json in each plugin directory
2. Generate a simple manifest file (plugin.json) describing the node configuration
3. Skip this requirement since plugins are internal modules

Chosen Option: 2

Rationale: Generate a plugin.json manifest file that describes the node metadata (name, type, description, icon) which can serve as documentation and could evolve into a package.json pattern if external plugins are added later.

Assumption 2: Dependency installation scope

Options Considered:

1. Run npm install after generation for the main project
2. Skip dependency installation since all needed dependencies already exist
3. Check and prompt for any missing peer dependencies

Chosen Option: 2

Rationale: Skip automatic dependency installation since all required dependencies (React, Handlebars, Inngest, etc.) are already installed project-wide. The CLI will note this in its completion output.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Phase 1: CLI Infrastructure Setup

Establish the foundational CLI framework by installing necessary dependencies, creating the entry point, and configuring the package to expose the axebase command. This phase creates the scaffolding upon which the create command will be built.

Task 1: Install CLI Dependencies

Add the required CLI libraries to enable command parsing and interactive prompts.

• Add commander for command-line argument parsing and subcommand structure
• Add @inquirer/prompts for modern, Promise-based interactive prompts
• Add chalk for colorized terminal output to improve UX
• These are devDependencies since the CLI is a development tool

Task 2: Create CLI Entry Point and Structure

Set up the CLI directory structure and main entry point that will host all CLI commands.

• Create bin/ directory at project root for CLI executables
• Create bin/axebase.ts as the main CLI entry point with shebang for Node execution
• Initialize Commander program with version, description, and help configuration
• Export the program for command registration from separate files
• Create bin/commands/ directory to organize individual command implementations

Task 3: Configure Package for CLI Execution

Update package.json to expose the CLI command and add development scripts.

• Add bin field to package.json mapping axebase to bin/axebase.ts
• Add npm script axebase that runs the CLI via tsx for TypeScript execution
• Add npm script axebase:create as a convenience alias for the create command
• Ensure tsx is available (already in devDependencies per exploration)

🤖 Prompt for AI agents

Set up the foundational CLI infrastructure for the `axebase` command. The goal
is to create the entry point, directory structure, and package configuration
needed to run CLI commands.

**Install dependencies:**
- Add `commander`, `@inquirer/prompts`, and `chalk` as devDependencies

**Create CLI structure:**
- Create `bin/` directory at project root
- Create `bin/axebase.ts` with shebang (`#!/usr/bin/env node`) as the main entry
point
- Initialize Commander program with version from package.json, description, and
help configuration
- Create `bin/commands/` directory for command implementations
- Export the Commander program instance for use by command modules

**Configure package.json:**
- Add `bin` field mapping `axebase` to `bin/axebase.ts`
- Add npm script `axebase` that executes the CLI via `tsx bin/axebase.ts`
- Add npm script `axebase:create` as convenience alias for the create command

The CLI entry point should be structured to allow easy registration of
subcommands from separate files.

Phase 2: Template System

Create the Handlebars template files that will be used to generate node scaffolding. Templates follow the existing patterns from manual-trigger and http-request implementations, with placeholders for customization.

Task 1: Create Trigger Node Templates

Build template files for generating new trigger nodes, following the manual-trigger pattern.

• Create bin/templates/trigger/ directory for trigger node templates
• Create node.tsx.hbs template with BaseTriggerNode extension, memo wrapper, dialog state, and useNodeStatus hook
• Create executor.ts.hbs template with NodeExecutor interface implementation and basic context pass-through
• Create dialog.tsx.hbs template with react-hook-form setup, zod schema placeholder, and basic dialog structure
• Create actions.ts.hbs template with "use server" directive and realtime token fetch function
• Include placeholders: {{PLUGIN_NAME}}, {{PLUGIN_NAME_PASCAL}}, {{PLUGIN_NAME_UPPER_SNAKE}}, {{DESCRIPTION}}, {{ICON}}

Task 2: Create Execution Node Templates

Build template files for generating new execution/action nodes, following the http-request pattern.

• Create bin/templates/execution/ directory for execution node templates
• Create node.tsx.hbs template with BaseExecutionNode extension (both source and target handles)
• Create executor.ts.hbs template with NodeExecutor implementation, context transformation placeholder, and status publishing
• Create dialog.tsx.hbs template with form fields structure and validation schema
• Create actions.ts.hbs template matching the trigger version but with execution-specific channel reference
• Templates should mirror trigger templates but use BaseExecutionNode and appropriate handle configuration

Task 3: Create Shared Templates

Build templates for shared infrastructure files that both node types require.

• Create bin/templates/shared/ directory for common templates
• Create channel.ts.hbs template for Inngest realtime channel definition with status topic
• Create plugin.json.hbs manifest template containing name, type, description, icon, and version fields
• Create index.ts.hbs barrel export file that re-exports node component and executor

🤖 Prompt for AI agents

Create Handlebars template files for generating trigger nodes, execution nodes,
and shared infrastructure. The goal is to create reusable templates based on
existing manual-trigger and http-request patterns.

**Trigger Node Templates (bin/templates/trigger/):**
- `node.tsx.hbs`: BaseTriggerNode component with memo wrapper, dialog state
management, and useNodeStatus hook. Include placeholders for
`{{PLUGIN_NAME_PASCAL}}`, `{{DESCRIPTION}}`, and `{{ICON}}`
- `executor.ts.hbs`: NodeExecutor interface implementation with basic context
pass-through pattern
- `dialog.tsx.hbs`: React Hook Form setup with zod schema placeholder and basic
dialog structure
- `actions.ts.hbs`: Server action with "use server" directive and realtime token
fetch function

**Execution Node Templates (bin/templates/execution/):**
- `node.tsx.hbs`: BaseExecutionNode component with both source and target
handles
- `executor.ts.hbs`: NodeExecutor implementation with context transformation
placeholder and status publishing
- `dialog.tsx.hbs`: Form fields structure with validation schema
- `actions.ts.hbs`: Similar to trigger version but with execution-specific
channel reference

**Shared Templates (bin/templates/shared/):**
- `channel.ts.hbs`: Inngest realtime channel definition with status topic
- `plugin.json.hbs`: Manifest with name, type, description, icon, and version
fields
- `index.ts.hbs`: Barrel export re-exporting node component and executor

**Template placeholders to support:**
`{{PLUGIN_NAME}}` (kebab-case), `{{PLUGIN_NAME_PASCAL}}` (PascalCase),
`{{PLUGIN_NAME_UPPER_SNAKE}}` (UPPER_SNAKE_CASE), `{{DESCRIPTION}}`, `{{ICON}}`

Phase 3: Create Command Implementation

Implement the interactive axebase create command that prompts users for plugin details, validates input, generates files from templates, and provides registration instructions.

Task 1: Implement Interactive Prompts

Create the prompt flow that gathers all necessary information for plugin generation.

• Create bin/commands/create.ts as the create command implementation
• Implement prompts for: plugin name (kebab-case validated), display name, description, plugin type (trigger/execution)
• Implement prompt for icon selection from common Lucide icons (provide list of 10-15 common workflow icons)
• Add name validation ensuring kebab-case format and no conflicts with existing node directories
• Validate that the target directory doesn't already exist
• Support both interactive mode (default) and flag-based mode for scripting (--name, --type, etc.)

Task 2: Implement Template Processing

Build the template processing engine that transforms templates into generated files.

• Create bin/lib/template-processor.ts for Handlebars template compilation and rendering
• Register Handlebars helpers for case transformations: pascalCase, camelCase, upperSnakeCase, kebabCase
• Implement function to load template files from the templates directory
• Implement function to process all templates for a given plugin type with provided context variables
• Handle file writing with proper directory creation using Node.js fs/promises

Task 3: Implement File Generation Logic

Create the orchestration logic that generates all plugin files in the correct locations.

• Determine target directory based on plugin type: src/features/triggers/components/{name}/ or src/features/executions/components/{name}/
• Generate all four node files (node.tsx, executor.ts, dialog.tsx, actions.ts) from templates
• Generate channel file in src/inngest/channels/{name}.ts
• Generate plugin.json manifest in the node directory
• Generate index.ts barrel export in the node directory
• Use chalk for colorized success/error output showing each created file

Task 4: Implement Registration Instructions Output

Provide clear post-generation instructions for manual registration steps.

• Output formatted instructions after successful generation using chalk for visibility
• Include exact code snippets for adding the NodeType enum value to prisma/schema.prisma
• Include import statement and registry entry for src/config/node-components.ts
• Include import statement and registry entry for src/features/executions/lib/executor-registry.ts
• Include reminder to run npx prisma migrate dev after schema update
• Include reminder to add the node to src/components/node-selector.tsx arrays

Task 5: Implement Validation and Error Handling

Add comprehensive validation and graceful error handling throughout the command.

• Validate plugin name format (must be kebab-case, alphanumeric with hyphens)
• Check for naming conflicts with existing NodeType enum values
• Check target directory doesn't already exist before generation
• Wrap file operations in try/catch with descriptive error messages
• Implement rollback on partial failure (delete created files if generation fails midway)
• Validate template files exist before attempting generation

🤖 Prompt for AI agents

Implement the `axebase create` command that interactively scaffolds new workflow
nodes. The goal is to gather user input, validate it, generate files from
templates, and provide registration instructions.

**Interactive Prompts (bin/commands/create.ts):**
- Use `@inquirer/prompts` to gather: plugin name (validated kebab-case), display
name, description, plugin type (trigger/execution), and icon (select from 10-15
common Lucide icons)
- Support flag-based mode with `--name`, `--type`, `--description`, `--icon` for
scripting
- Validate plugin name is kebab-case (alphanumeric with hyphens only)
- Validate target directory doesn't exist
- Check for naming conflicts with existing NodeType enum values

**Template Processing (bin/lib/template-processor.ts):**
- Use Handlebars to compile and render templates
- Register helpers: `pascalCase`, `camelCase`, `upperSnakeCase`, `kebabCase` for
name transformations
- Load template files from `bin/templates/{trigger|execution|shared}/`
- Process templates with context variables (plugin name variations, description,
icon)
- Write generated files using Node.js fs/promises with proper directory creation

**File Generation:**
- Determine target directory: `src/features/triggers/components/{name}/` or
`src/features/executions/components/{name}/`
- Generate: node.tsx, executor.ts, dialog.tsx, actions.ts, index.ts, plugin.json
in node directory
- Generate channel file: `src/inngest/channels/{name}.ts`
- Use chalk for colorized output showing each created file

**Registration Instructions:**
- Output formatted instructions with chalk after successful generation
- Include exact code snippets for:
  - Adding NodeType enum value to `prisma/schema.prisma`
  - Import and registry entry for `src/config/node-components.ts`
- Import and registry entry for
`src/features/executions/lib/executor-registry.ts`
  - Adding node to `src/components/node-selector.tsx` arrays
- Remind user to run `npx prisma migrate dev`

**Validation and Error Handling:**
- Validate all inputs before generation
- Wrap file operations in try/catch with descriptive error messages
- Implement rollback mechanism to delete created files on partial failure
- Validate template files exist before generation

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Set up the foundational CLI infrastructure for the `axebase` command. The goal
is to create the entry point, directory structure, and package configuration
needed to run CLI commands.

**Install dependencies:**
- Add `commander`, `@inquirer/prompts`, and `chalk` as devDependencies

**Create CLI structure:**
- Create `bin/` directory at project root
- Create `bin/axebase.ts` with shebang (`#!/usr/bin/env node`) as the main entry
point
- Initialize Commander program with version from package.json, description, and
help configuration
- Create `bin/commands/` directory for command implementations
- Export the Commander program instance for use by command modules

**Configure package.json:**
- Add `bin` field mapping `axebase` to `bin/axebase.ts`
- Add npm script `axebase` that executes the CLI via `tsx bin/axebase.ts`
- Add npm script `axebase:create` as convenience alias for the create command

The CLI entry point should be structured to allow easy registration of
subcommands from separate files.
===============================================================================

Task: 2

Create Handlebars template files for generating trigger nodes, execution nodes,
and shared infrastructure. The goal is to create reusable templates based on
existing manual-trigger and http-request patterns.

**Trigger Node Templates (bin/templates/trigger/):**
- `node.tsx.hbs`: BaseTriggerNode component with memo wrapper, dialog state
management, and useNodeStatus hook. Include placeholders for
`{{PLUGIN_NAME_PASCAL}}`, `{{DESCRIPTION}}`, and `{{ICON}}`
- `executor.ts.hbs`: NodeExecutor interface implementation with basic context
pass-through pattern
- `dialog.tsx.hbs`: React Hook Form setup with zod schema placeholder and basic
dialog structure
- `actions.ts.hbs`: Server action with "use server" directive and realtime token
fetch function

**Execution Node Templates (bin/templates/execution/):**
- `node.tsx.hbs`: BaseExecutionNode component with both source and target
handles
- `executor.ts.hbs`: NodeExecutor implementation with context transformation
placeholder and status publishing
- `dialog.tsx.hbs`: Form fields structure with validation schema
- `actions.ts.hbs`: Similar to trigger version but with execution-specific
channel reference

**Shared Templates (bin/templates/shared/):**
- `channel.ts.hbs`: Inngest realtime channel definition with status topic
- `plugin.json.hbs`: Manifest with name, type, description, icon, and version
fields
- `index.ts.hbs`: Barrel export re-exporting node component and executor

**Template placeholders to support:**
`{{PLUGIN_NAME}}` (kebab-case), `{{PLUGIN_NAME_PASCAL}}` (PascalCase),
`{{PLUGIN_NAME_UPPER_SNAKE}}` (UPPER_SNAKE_CASE), `{{DESCRIPTION}}`, `{{ICON}}`
===============================================================================

Task: 3

Implement the `axebase create` command that interactively scaffolds new workflow
nodes. The goal is to gather user input, validate it, generate files from
templates, and provide registration instructions.

**Interactive Prompts (bin/commands/create.ts):**
- Use `@inquirer/prompts` to gather: plugin name (validated kebab-case), display
name, description, plugin type (trigger/execution), and icon (select from 10-15
common Lucide icons)
- Support flag-based mode with `--name`, `--type`, `--description`, `--icon` for
scripting
- Validate plugin name is kebab-case (alphanumeric with hyphens only)
- Validate target directory doesn't exist
- Check for naming conflicts with existing NodeType enum values

**Template Processing (bin/lib/template-processor.ts):**
- Use Handlebars to compile and render templates
- Register helpers: `pascalCase`, `camelCase`, `upperSnakeCase`, `kebabCase` for
name transformations
- Load template files from `bin/templates/{trigger|execution|shared}/`
- Process templates with context variables (plugin name variations, description,
icon)
- Write generated files using Node.js fs/promises with proper directory creation

**File Generation:**
- Determine target directory: `src/features/triggers/components/{name}/` or
`src/features/executions/components/{name}/`
- Generate: node.tsx, executor.ts, dialog.tsx, actions.ts, index.ts, plugin.json
in node directory
- Generate channel file: `src/inngest/channels/{name}.ts`
- Use chalk for colorized output showing each created file

**Registration Instructions:**
- Output formatted instructions with chalk after successful generation
- Include exact code snippets for:
  - Adding NodeType enum value to `prisma/schema.prisma`
  - Import and registry entry for `src/config/node-components.ts`
- Import and registry entry for
`src/features/executions/lib/executor-registry.ts`
  - Adding node to `src/components/node-selector.tsx` arrays
- Remind user to run `npx prisma migrate dev`

**Validation and Error Handling:**
- Validate all inputs before generation
- Wrap file operations in try/catch with descriptive error messages
- Implement rollback mechanism to delete created files on partial failure
- Validate template files exist before generation

💡 Iterate on the plan with: @coderabbitai <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For assumption 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!