Claude-Code-Workflow/.claude/skills/skill-generator/templates/autonomous-action.md

Autonomous Action Template

Template for action files in Autonomous execution mode.

Purpose

Generate Action files for Autonomous execution mode, defining independent executable action units.

Usage Context

Phase	Usage
Phase 3 (Phase Generation)	Generated when config.execution_mode === 'autonomous'
Generation Trigger	Generate one action file for each config.autonomous_config.actions
Output Location	.claude/skills/{skill-name}/phases/actions/{action-id}.md

---

Template Structure

# Action: {{action_name}}

{{action_description}}

## Purpose

{{purpose}}

## Preconditions

{{preconditions_list}}

## Scripts

\`\`\`yaml
# Declare scripts used in this action (optional)
# - script-id        # Corresponds to scripts/script-id.py or .sh
\`\`\`

## Execution

\`\`\`javascript
async function execute(state) {
  {{execution_code}}

  // Script execution example
  // const result = await ExecuteScript('script-id', { input: state.context.data });
  // if (!result.success) throw new Error(result.stderr);
}
\`\`\`

## State Updates

\`\`\`javascript
return {
  stateUpdates: {
    {{state_updates}}
  }
};
\`\`\`

## Error Handling

| Error Type | Recovery |
|------------|----------|
{{error_handling_table}}

## Next Actions (Hints)

{{next_actions_hints}}

Variable Descriptions

Variable	Description
{{action_name}}	Action name
{{action_description}}	Action description
{{purpose}}	Detailed purpose
{{preconditions_list}}	List of preconditions
{{execution_code}}	Execution code
{{state_updates}}	State updates
{{error_handling_table}}	Error handling table
{{next_actions_hints}}	Next action hints

Action Lifecycle

State-driven execution flow:

  state.status === 'pending'
       |
       v
  +-- Init --+          <- 1 execution, environment preparation
  | Create working directory
  | Initialize context
  | status -> running
  +----+----+
       |
       v
  +-- CRUD Loop --+     <- N iterations, core business
  | Orchestrator selects action  |    List / Create / Edit / Delete
  | execute(state)  |    Shared pattern: collect input -> operate context.items -> return updates
  | Update state
  +----+----+
       |
       v
  +-- Complete --+      <- 1 execution, save results
  | Serialize output
  | status -> completed
  +----------+

Shared state structure:
  state.status          -> 'pending' | 'running' | 'completed'
  state.context.items   -> Business data array
  state.completed_actions -> List of executed action IDs

Action Type Templates

1. Initialize Action (Init)

Trigger condition: state.status === 'pending', executes once

# Action: Initialize

Initialize Skill execution state.

## Purpose

Set initial state, prepare execution environment.

## Preconditions

- [ ] state.status === 'pending'

## Execution

\`\`\`javascript
async function execute(state) {
  Bash(\`mkdir -p "\${workDir}"\`);

  return {
    stateUpdates: {
      status: 'running',
      started_at: new Date().toISOString(),
      context: { items: [], metadata: {} }
    }
  };
}
\`\`\`

## Next Actions

- Success: Enter main processing loop (Orchestrator selects first CRUD action)
- Failure: action-abort

2. CRUD Actions (List / Create / Edit / Delete)

Trigger condition: state.status === 'running', loop until user exits

Example shows Create action demonstrating shared pattern. List / Edit / Delete follow same structure with different execution logic and state update fields.

# Action: Create Item

Create new item.

## Purpose

Collect user input, append new record to context.items.

## Preconditions

- [ ] state.status === 'running'

## Execution

\`\`\`javascript
async function execute(state) {
  // 1. Collect input
  const input = await AskUserQuestion({
    questions: [{
      question: "Please enter item name:",
      header: "Name",
      multiSelect: false,
      options: [{ label: "Manual input", description: "Enter custom name" }]
    }]
  });

  // 2. Operate context.items (core logic differs by action type)
  const newItem = {
    id: Date.now().toString(),
    name: input["Name"],
    status: 'pending',
    created_at: new Date().toISOString()
  };

  // 3. Return state update
  return {
    stateUpdates: {
      context: {
        ...state.context,
        items: [...(state.context.items || []), newItem]
      },
      last_action: 'create'
    }
  };
}
\`\`\`

## Next Actions

- Continue operations: Orchestrator selects next action based on state
- User exit: action-complete

Other CRUD Actions Differences:

Action	Core Logic	Extra Preconditions	Key State Field
List	items.forEach(-> console.log)	None	current_view: 'list'
Create	items.push(newItem)	None	last_created_id
Edit	items.map(-> replace matching)	selected_item_id !== null	updated_at
Delete	items.filter(-> exclude matching)	selected_item_id !== null	Confirm dialog -> execute

3. Complete Action

Trigger condition: User explicitly exits or termination condition met, executes once

# Action: Complete

Complete task and exit.

## Purpose

Serialize final state, end Skill execution.

## Preconditions

- [ ] state.status === 'running'

## Execution

\`\`\`javascript
async function execute(state) {
  Write(\`\${workDir}/final-output.json\`, JSON.stringify(state.context, null, 2));

  const summary = {
    total_items: state.context.items?.length || 0,
    duration: Date.now() - new Date(state.started_at).getTime(),
    actions_executed: state.completed_actions.length
  };

  console.log(\`Task complete: \${summary.total_items} items, \${summary.actions_executed} operations\`);

  return {
    stateUpdates: {
      status: 'completed',
      completed_at: new Date().toISOString(),
      summary
    }
  };
}
\`\`\`

## Next Actions

- None (terminal state)

Generation Function

function generateAction(actionConfig, skillConfig) {
  return `# Action: ${actionConfig.name}

${actionConfig.description || `Execute ${actionConfig.name} operation`}

## Purpose

${actionConfig.purpose || 'TODO: Describe detailed purpose of this action'}

## Preconditions

${actionConfig.preconditions?.map(p => `- [ ] ${p}`).join('\n') || '- [ ] No special preconditions'}

## Execution

\`\`\`javascript
async function execute(state) {
  // TODO: Implement action logic

  return {
    stateUpdates: {
      completed_actions: [...state.completed_actions, '${actionConfig.id}']
    }
  };
}
\`\`\`

## State Updates

\`\`\`javascript
return {
  stateUpdates: {
    // TODO: Define state updates
${actionConfig.effects?.map(e => `    // Effect: ${e}`).join('\n') || ''}
  }
};
\`\`\`

## Error Handling

| Error Type | Recovery |
|------------|----------|
| Data validation failed | Return error, no state update |
| Execution exception | Log error, increment error_count |

## Next Actions (Hints)

- Success: Orchestrator decides based on state
- Failure: Retry or action-abort
`;
}