1. Parse Arguments

Parse Arguments:

The Foundation of Engine Setup Automation

The "Parse Arguments" skill is the entry point to the setup-engine automation on the Happycapy Skills platform. By interpreting user input and contextual project data, this skill streamlines the process of selecting and configuring a game development engine within a project workspace. Whether you are specifying an engine and version directly, requesting a refresh of reference materials, or seeking interactive guidance, "Parse Arguments" ensures the right operational path is taken for your project's needs.

What Is This Skill?

The setup-engine skill is designed to manage the project's game engine and its versioning lifecycle. At its core, "Parse Arguments" is responsible for analyzing the command-line arguments provided by the user. This analysis determines the intended action and mode of operation, such as configuring a new engine, upgrading to a newer version, or updating engine documentation. The results of this parsing phase dictate how the rest of the setup process proceeds, making it a critical component of the overall workflow.

The supported argument patterns are as follows:

• Full specification: /setup-engine godot 4.6
• Engine only: /setup-engine unity
• No arguments: /setup-engine
• Refresh documentation: /setup-engine refresh
• Upgrade engine version: /setup-engine upgrade 4.5 4.6

Each mode triggers a specific workflow, enabling both direct and interactive engine management.

Why Use Argument Parsing?

Parsing arguments brings precision and flexibility to the setup process. Without robust argument parsing, the system would not be able to distinguish between user intents, leading to ambiguous operations or unnecessary manual intervention. This skill allows:

• Automation: Users can script or repeat engine setup tasks with explicit commands.
• Guided onboarding: New users can invoke guided selection when they lack details.
• Consistency: Ensures every project captures engine and version info in a standard way.
• Extensibility: Future workflows (such as engine upgrades or knowledge refreshes) are easy to add by defining new argument patterns.

By leveraging argument parsing, the platform can automate complex processes with minimal user input, reducing setup errors and accelerating onboarding.

How to Use the Parse Arguments Skill

Command Patterns and Examples

The skill can be invoked directly by the user via the command interface. Here are the main usage patterns:

1. Full specification

/setup-engine godot 4.6

• Pins the Godot engine, version 4.6, in CLAUDE.md.
• Fetches and links up-to-date documentation if version knowledge is beyond the LLM's training data.

2. Engine only

/setup-engine unity

• Determines the latest stable version of Unity.
• Pins both the engine and version in CLAUDE.md.
• Populates reference documentation as needed.

3. No arguments (guided mode)

/setup-engine

• Triggers an interactive selection process.
• Reads design/gdd/game-concept.md to infer suitable engines based on genre, scope, platform, and team size.
• If no concept is available, prompts the user to run /brainstorm or provide project details.

4. Refresh documentation

/setup-engine refresh

• Updates the engine reference documentation using WebSearch/WebFetch tools.
• Ensures docs reflect the latest information, especially for engine versions beyond the LLM's knowledge cutoff.

5. Upgrade

/setup-engine upgrade 4.5 4.6

• Initiates a migration workflow to move from version 4.5 to 4.6.
• May include update guides, compatibility notes, and project migration recommendations.

Code Example:

Argument Parsing Logic

A simplified pseudocode example for argument parsing:

def parse_arguments(args):
    if args == []:
        return "guided"
    if args[0] == "refresh":
        return "refresh"
    if args[0] == "upgrade" and len(args) == 3:
        return ("upgrade", args[1], args[2])
    if len(args) == 2:
        return ("full_spec", args[0], args[1])
    if len(args) == 1:
        return ("engine_only", args[0])
    raise ValueError("Invalid arguments")

This logic ensures that each supported mode is detected and routed to the appropriate workflow.

When to Use This Skill

Use the "Parse Arguments" skill whenever you need to:

• Pin a new engine or version to your project.
• Upgrade to a newer engine version safely.
• Refresh reference docs for the latest engine features.
• Guide new team members through engine selection.
• Ensure project metadata is standardized and up-to-date.

It is especially valuable when starting a new project, migrating between engine versions, or ensuring documentation accuracy for engines that have evolved since the last LLM training cycle.

Important Notes

• Argument parsing is strictly positional and expects the patterns described above.
• The skill interacts with project files (such as CLAUDE.md and design/gdd/game-concept.md) to extract or update metadata.
• WebSearch and WebFetch tools are used when engine version details exceed the LLM's knowledge cutoff.
• Guided mode falls back to interactive prompts if insufficient project data is available.
• The skill is user-invocable and can be called as needed throughout the project lifecycle.

By understanding and using the "Parse Arguments" skill effectively, teams can automate and streamline the foundational steps of modern game development setup.