Phase 1: Parse Arguments

Phase 1:

Parse Arguments - Happycapy Skills Platform

What Is This?

The "Phase 1: Parse Arguments" skill is the initial step in the launch-checklist workflow for the Happycapy Skills platform. Its primary function is to read and interpret the arguments provided when a user explicitly invokes the /launch-checklist command. The skill expects a single argument: either a specific launch date (e.g., 2024-09-02) or the special keyword dry-run. Based on this input, the skill determines the operational mode for the remainder of the launch checklist process.

This phase acts as a gatekeeper, ensuring that all subsequent actions-such as gathering project context, scanning the codebase, and generating the launch checklist-operate with a clear understanding of the user's intent. The skill does not proceed unless the invocation is explicit and the argument is valid.

Why Use It?

Precise argument parsing is critical in automated workflows, especially those with potentially irreversible effects, such as generating and storing launch checklists or creating sign-off entries. By enforcing explicit invocation and argument validation, this phase prevents accidental or unintended operations, reducing the risk of errors in the sensitive pre-launch phase.

The dry-run mode is particularly valuable. It provides a safe environment where the full launch checklist is generated without writing any files or creating persistent sign-off entries. This allows teams to review and refine the checklist process without affecting production data or triggering official launch procedures.

Key reasons to use this skill include:

• Safety: Ensures that launch procedures are only triggered intentionally.
• Clarity: Establishes the operational context (actual launch vs. dry run) for downstream processes.
• Flexibility: Supports both real and test scenarios with a single interface.
• Auditability: Reduces ambiguity by requiring explicit user input.

How to Use It

The "Phase 1: Parse Arguments" skill is designed for explicit, user-driven invocation. It does not activate automatically based on context or background triggers. To use the skill, a user must enter the following command within the Happycapy platform:

/launch-checklist [launch-date or 'dry-run']

Argument Structure

• Launch Date: Enter a date in an accepted format (e.g., 2024-09-02). This instructs the skill to prepare the checklist for an actual, scheduled launch.
• Dry-Run: Enter the literal string dry-run. This tells the skill to simulate the checklist generation without writing files or creating sign-off entries.

Code Example:

Argument Parsing Logic

Below is a representative pseudocode snippet demonstrating how this phase might be implemented:

import sys
from datetime import datetime

def parse_arguments(args):
    if len(args) != 2:
        raise ValueError("Usage: /launch-checklist [launch-date or 'dry-run']")
    argument = args[1]
    if argument.lower() == 'dry-run':
        mode = 'dry-run'
        launch_date = None
    else:
        try:
            launch_date = datetime.strptime(argument, "%Y-%m-%d")
            mode = 'launch'
        except ValueError:
            raise ValueError("Invalid date format. Use YYYY-MM-DD or 'dry-run'")
    return mode, launch_date

## Example usage:
## mode, launch_date = parse_arguments(sys.argv)

Integration with the Happycapy Skills Platform

This skill is configured with the following capabilities (as specified in SKILL.md):

• Allowed tools: Read, Glob, Grep, Write
• Explicit invocation required: Will only run when /launch-checklist is directly called by the user

The parsed mode (launch or dry-run) is passed to subsequent phases, controlling behaviors such as whether to write files or just simulate actions.

When to Use It

Invoke "Phase 1: Parse Arguments" at the very start of any launch readiness operation with the launch-checklist skill. Typical scenarios include:

• Pre-launch Review: When preparing for a real launch, supply the target launch date to initialize the checklist process.
• Practice Runs: When the team wants to simulate the checklist workflow to verify readiness or train team members, use dry-run.
• Checklist Validation: When updating or debugging the checklist process, use dry-run to avoid making persistent changes.

Do not use this skill for background automation or in response to contextual cues. It is strictly for explicit, manual initiation to maintain safety and avoid side effects.

Important Notes

• Explicit Invocation Only: The skill will not auto-invoke based on context. Users must run /launch-checklist with the desired argument.
• No Side Effects in Dry-Run: When dry-run is supplied, no sign-off entries are created and no files are written. All operations are simulated.
• Argument Validation: The skill enforces strict validation. Invalid arguments result in immediate errors and halt further processing.
• Workflow Control: The parsed result is foundational for all following phases, affecting everything from context gathering to file I/O permissions.

By centralizing argument parsing in Phase 1, the launch-checklist skill ensures that every launch preparation is deliberate, traceable, and tailored to the user's explicit intent. This approach minimizes risk while maximizing control and transparency throughout the launch readiness workflow.