Hugin Agent Scaffold Generator

Generate starter files for a new Hugin agent by reading templates from this plugin and customizing them.

Arguments

Parse the user's arguments to extract:

1. agentname: Name for the agent (required, snakecase)
2. type: One of minimal, tool, or pipeline (default: minimal)

Example invocations:

• /hugin-agent-creator:hugin-scaffold my_agent - Creates minimal agent
• /hugin-agent-creator:hugin-scaffold data_processor tool - Creates agent with custom tool
• /hugin-agent-creator:hugin-scaffold report_generator pipeline - Creates multi-stage pipeline

Implementation Steps

Step 1: Parse Arguments

Extract agentname and type from user input. Validate agentname is snake_case.

Step 2: Create Directory Structure

Use Bash to create the directories:

mkdir -p [agent_name]/configs [agent_name]/tasks [agent_name]/templates
# For 'tool' type also:
mkdir -p [agent_name]/tools

Step 3: Read and Customize Templates

IMPORTANT: Read the actual template files from this plugin, then customize them.

For ALL types, read these templates:

1. Read templates/minimal-config.yaml from this plugin

- Replace myagent with [agentname] - Replace mysystem with [agentname]system - For 'tool' type: add the custom tool to the tools list - Write to [agentname]/configs/[agent_name].yaml

1. Read templates/minimal-task.yaml from this plugin

- Replace mytask with [agentname]task - Write to [agentname]/tasks/[agentname]task.yaml

1. Read templates/minimal-template.yaml from this plugin

- Replace mysystem with [agentname]system - Write to [agentname]/templates/[agentname]system.yaml

For 'tool' type, also read:

1. Read templates/tool-definition.yaml from this plugin

- Replace mytool with [agentname]tool - Write to [agentname]/tools/[agentname]tool.yaml

1. Read templates/tool-implementation.py from this plugin

- Replace mytool with [agentname]tool - Write to [agentname]/tools/[agentname]tool.py

For 'pipeline' type:

Instead of the single task, create 3 stage tasks:

1. Read templates/minimal-task.yaml as base, then create:

tasks/stage1extract.yaml: ```yaml name: stage1extract description: Extract data from input (Stage 1) parameters: rawinput: type: string description: Raw input data required: false default: "Sample input data" tasksequence: - stage2transform - stage3output passresultas: extracted_data prompt: | STAGE 1: EXTRACT

Raw Input: {{ raw_input.value }}

Your task: 1. Parse the raw input 2. Extract key information 3. Use finish with your structured extraction as the result

The result will be passed to Stage 2. ```

tasks/stage2transform.yaml: ```yaml name: stage2transform description: Transform extracted data (Stage 2) parameters: extracteddata: type: string description: Data from Stage 1 required: false default: "" passresultas: transformeddata prompt: | STAGE 2: TRANSFORM

Extracted Data: {{ extracted_data.value }}

Your task: 1. Transform the extracted data 2. Apply any necessary processing 3. Use finish with your transformed result

The result will be passed to Stage 3. ```

tasks/stage3output.yaml: ```yaml name: stage3output description: Generate final output (Stage 3) parameters: transformed_data: type: string description: Data from Stage 2 required: false default: "" prompt: | STAGE 3: OUTPUT

Transformed Data: {{ transformed_data.value }}

Your task: 1. Generate the final output 2. Format it appropriately 3. Use finish with your final result ```

1. Update the system template for pipeline context:

```yaml name: [agentname]system template: | You are a data processing assistant working in a multi-stage pipeline.

Follow your stage instructions carefully. Your output will be passed to the next stage.

Always use the finish tool when your stage is complete, including your result. ```

Step 4: Print Success Message

After creating all files, print:

Created [agent_name] agent ([type] type)

Directory: ./[agent_name]/

Files created:
  - configs/[agent_name].yaml
  - tasks/[task_name].yaml
  - templates/[agent_name]_system.yaml
  [If tool type:]
  - tools/[agent_name]_tool.yaml
  - tools/[agent_name]_tool.py

Run your agent:
  uv run hugin run --task [task_name] --task-path ./[agent_name]

Next steps:
  1. Edit configs/[agent_name].yaml to customize the agent
  2. Edit tasks/[task_name].yaml to define your task logic
  3. Edit templates/[agent_name]_system.yaml for the system prompt
  [If tool type:]
  4. Implement your tool in tools/[agent_name]_tool.py
  [If pipeline type:]
  4. Customize each stage task in tasks/

For more guidance: /hugin-agent-creator:hugin-guide

Template File Locations

All templates are in this plugin's templates/ directory:

• templates/minimal-config.yaml
• templates/minimal-task.yaml
• templates/minimal-template.yaml
• templates/tool-definition.yaml
• templates/tool-implementation.py

Always read these files rather than hardcoding their content. This ensures scaffolded agents use the latest template versions.