Claude-Code-Workflow/.claude/skills/command-generator/phases/01-parameter-validation.md

Phase 1: Parameter Validation

Validate all required parameters for command generation.

Objective

Ensure all required parameters are provided before proceeding with command generation:

• skillName: Command identifier (required)
• description: Command description (required)
• location: Target scope - "project" or "user" (required)
• group: Optional grouping subdirectory
• argumentHint: Optional argument hint string

Input

Parameters received from skill invocation:

• skillName: string (required)
• description: string (required)
• location: "project" | "user" (required)
• group: string (optional)
• argumentHint: string (optional)

Validation Rules

Required Parameters

const requiredParams = {
  skillName: {
    type: 'string',
    minLength: 1,
    pattern: /^[a-z][a-z0-9-]*$/,  // lowercase, alphanumeric, hyphens
    error: 'skillName must be lowercase alphanumeric with hyphens, starting with a letter'
  },
  description: {
    type: 'string',
    minLength: 10,
    error: 'description must be at least 10 characters'
  },
  location: {
    type: 'string',
    enum: ['project', 'user'],
    error: 'location must be "project" or "user"'
  }
};

Optional Parameters

const optionalParams = {
  group: {
    type: 'string',
    pattern: /^[a-z][a-z0-9-]*$/,
    default: null,
    error: 'group must be lowercase alphanumeric with hyphens'
  },
  argumentHint: {
    type: 'string',
    default: '',
    error: 'argumentHint must be a string'
  }
};

Execution Steps

Step 1: Extract Parameters

// Extract from skill args
const params = {
  skillName: args.skillName,
  description: args.description,
  location: args.location,
  group: args.group || null,
  argumentHint: args.argumentHint || ''
};

Step 2: Validate Required Parameters

function validateRequired(params, rules) {
  const errors = [];
  
  for (const [key, rule] of Object.entries(rules)) {
    const value = params[key];
    
    // Check existence
    if (value === undefined || value === null || value === '') {
      errors.push(`${key} is required`);
      continue;
    }
    
    // Check type
    if (typeof value !== rule.type) {
      errors.push(`${key} must be a ${rule.type}`);
      continue;
    }
    
    // Check minLength
    if (rule.minLength && value.length < rule.minLength) {
      errors.push(`${key} must be at least ${rule.minLength} characters`);
    }
    
    // Check pattern
    if (rule.pattern && !rule.pattern.test(value)) {
      errors.push(rule.error);
    }
    
    // Check enum
    if (rule.enum && !rule.enum.includes(value)) {
      errors.push(`${key} must be one of: ${rule.enum.join(', ')}`);
    }
  }
  
  return errors;
}

const requiredErrors = validateRequired(params, requiredParams);
if (requiredErrors.length > 0) {
  throw new Error(`Validation failed:\n${requiredErrors.join('\n')}`);
}

Step 3: Validate Optional Parameters

function validateOptional(params, rules) {
  const warnings = [];
  
  for (const [key, rule] of Object.entries(rules)) {
    const value = params[key];
    
    if (value !== null && value !== undefined && value !== '') {
      if (rule.pattern && !rule.pattern.test(value)) {
        warnings.push(`${key}: ${rule.error}`);
      }
    }
  }
  
  return warnings;
}

const optionalWarnings = validateOptional(params, optionalParams);
// Log warnings but continue

Step 4: Normalize Parameters

const validatedParams = {
  skillName: params.skillName.trim().toLowerCase(),
  description: params.description.trim(),
  location: params.location.trim().toLowerCase(),
  group: params.group ? params.group.trim().toLowerCase() : null,
  argumentHint: params.argumentHint ? params.argumentHint.trim() : ''
};

Output

{
  status: 'validated',
  params: validatedParams,
  warnings: optionalWarnings
}

Next Phase

Proceed to Phase 2: Target Path Resolution with validatedParams.