Phase 0: Parse Arguments

Phase 0:

Parse Arguments

What Is This

Phase 0: Parse Arguments is the initial and critical step of the asset-spec skill on the Happycapy Skills platform. This phase is responsible for interpreting and validating the command-line arguments supplied by the user when invoking the asset specification workflow. Its primary function is to extract, normalize, and verify the target asset context (system, level, or character) and review mode from user input, which determines what asset specs will be generated and how the review workflow proceeds.

This phase supports a flexible argument syntax, allowing users to specify the type and name of the asset context as well as an optional review mode. If no arguments are provided, Phase 0 contains logic to check the current asset manifest and assist the user in selecting the next appropriate context for specification.

Why Use It

Argument parsing is foundational for automated workflows, particularly in complex pipelines like game asset specification. By rigorously interpreting user input, Phase 0 ensures that the asset-spec skill operates on the correct target and under the preferred review conditions. This avoids ambiguity, reduces manual errors, and enables downstream phases to work with normalized, validated parameters.

Accurate argument parsing is especially important in collaborative or iterative game design environments, where multiple teams may engage with the asset pipeline at different stages. Phase 0’s logic ensures that only valid contexts are processed and that the workflow can adapt based on project state, such as identifying unspecced assets from the manifest when explicit arguments are not supplied.

How to Use It

The asset-spec skill is invoked via a command-line interface or chat command, following this general argument structure:

/asset-spec [system:<name> | level:<name> | character:<name>] [--review full|lean|solo]

Argument Extraction Logic:

1. Target Type and Name:

   • The command expects a positional argument in the form system:<name>, level:<name>, or character:<name>.
   • The string after the colon (<name>) is extracted and normalized to kebab-case (lowercase, hyphen-separated).

2. Review Mode:

   • The optional flag --review can be set to full, lean, or solo.
   • If omitted, the default review mode is full.

Example Command Invocations:

/asset-spec system:tower-defense --review lean
/asset-spec level:iron-gate-fortress
/asset-spec character:frost-warden --review solo

Argument Parsing Pseudocode:

import re

def parse_arguments(args):
    # Example: args = ['system:tower-defense', '--review', 'lean']
    target_type = None
    target_name = None
    review_mode = 'full'  # Default

    # Extract target type and name
    for arg in args:
        match = re.match(r'^(system|level|character):(.+)$', arg)
        if match:
            target_type = match.group(1)
            # Normalize to kebab-case
            target_name = match.group(2).strip().lower().replace(' ', '-')
    
    # Extract review mode
    if '--review' in args:
        idx = args.index('--review')
        if idx + 1 < len(args):
            review_mode = args[idx + 1]

    if not target_type or not target_name:
        raise ValueError("Usage: /asset-spec system:<name> [--review full|lean|solo]")

    return target_type, target_name, review_mode

No Argument Behavior:

When invoked with no arguments, Phase 0 attempts to auto-select a context by checking for design/assets/asset-manifest.md. If found, it identifies the next context (system, level, or character) with assets marked as "Needed" but lacking a spec file. The user is prompted via AskUserQuestion to confirm or select a different target. If the manifest does not exist, the skill returns a usage message with examples.

When to Use It

Phase 0 should be executed at the start of every asset spec generation session using the asset-spec skill. It is intended for use after your art bible and game design documents (GDDs or level design docs) are approved, but before asset production begins. This is the point where asset requirements have been defined but not yet broken down into detailed, per-asset specifications for art and AI generation.

This phase is especially useful:

• When you need to specify assets for a newly approved system, level, or character.
• When you want to generate specs for multiple contexts in sequence, using the manifest to guide the workflow.
• When you wish to control the review process, for example, by invoking a solo review instead of a full team review.

Important Notes

• Strict Argument Syntax: The skill requires explicit context and name formatting (system:<name>, etc.). Names must be normalized to kebab-case.
• Manifest-Driven Fallback: If arguments are omitted, logic is in place to guide the user based on project status, but an asset manifest is required for this to work.
• Review Modes:
  • full (default): Both art-director and technical-artist are engaged in parallel.
  • lean: Streamlined review with fewer participants.
  • solo: Single-user review for rapid iteration.
• Usage Enforcement: If the manifest is missing and no arguments are supplied, the skill aborts with a clear error message and usage guidance.
• Integration: This phase is designed to precede all asset spec generation logic. Downstream phases rely on the output of argument parsing for correct operation.

By rigorously handling input arguments, Phase 0 ensures that the asset-spec skill on Happycapy Skills operates efficiently, accurately, and in alignment with the project's asset pipeline requirements.