red64-cli 0.1.0

package/framework/agents/claude/.claude/commands/red64/spec-quick.md

@@ -0,0 +1,360 @@
+---
+description: Quick spec generation with interactive or automatic mode
+allowed-tools: Read, SlashCommand, TodoWrite, Bash, Write, Glob
+argument-hint: <project-description> [--auto]
+---
+
+# Quick Spec Generator
+
+<background_information>
+- **Mission**: Execute all spec phases (init → requirements → design → tasks) in a single command
+- **Success Criteria**:
+  - Interactive mode: User controls progression with approval prompts at each phase
+  - Automatic mode: All phases execute without interruption when `--auto` flag provided
+  - All generated specs maintain quality comparable to manual workflow
+</background_information>
+
+<instructions>
+## ⚠️ CRITICAL: Automatic Mode Execution Rules
+
+**If `--auto` flag is present in `$ARGUMENTS`, you are in AUTOMATIC MODE.**
+
+In Automatic Mode:
+- Execute ALL 4 phases in a continuous loop without stopping
+- Use TodoWrite to track progress (4 tasks: init, requirements, design, tasks)
+- Each phase completion updates TodoWrite and continues immediately
+- IGNORE any "Next Step" messages from Phase 2-4 (they are for standalone usage)
+- Stop ONLY after Phase 4 completes or if error occurs
+
+**Progress tracking with TodoWrite**:
+- Phase 1 complete = 1/4 tasks done → Continue to Phase 2
+- Phase 2 complete = 2/4 tasks done → Continue to Phase 3
+- Phase 3 complete = 3/4 tasks done → Continue to Phase 4
+- Phase 4 complete = 4/4 tasks done → Output summary and exit
+
+---
+
+## Core Task
+Execute 4 spec phases sequentially. In automatic mode, execute all phases without stopping. In interactive mode, prompt user for approval between phases.
+
+## Execution Steps
+
+### Step 1: Parse Arguments and Initialize
+
+Parse `$ARGUMENTS`:
+- If contains `--auto`: **Automatic Mode** (execute all 4 phases)
+- Otherwise: **Interactive Mode** (prompt at each phase)
+- Extract description (remove `--auto` flag if present)
+
+Example:
+```
+"User profile with avatar upload --auto" → mode=automatic, description="User profile with avatar upload"
+"User profile feature" → mode=interactive, description="User profile feature"
+```
+
+**Create TodoWrite task list**:
+```json
+[
+  {"content": "Initialize spec", "activeForm": "Initializing spec", "status": "pending"},
+  {"content": "Generate requirements", "activeForm": "Generating requirements", "status": "pending"},
+  {"content": "Generate design", "activeForm": "Generating design", "status": "pending"},
+  {"content": "Generate tasks", "activeForm": "Generating tasks", "status": "pending"}
+]
+```
+
+Display mode banner and proceed to Step 2.
+
+### Step 2: Execute Phase Loop
+
+Execute these 4 phases in order:
+
+---
+
+#### Phase 1: Initialize Spec (Direct Implementation)
+
+**Update TodoWrite**: Mark task 1 as `in_progress`.
+
+**Core Logic**:
+
+1. **Generate Feature Name**:
+   - Convert description to kebab-case
+   - Example: "User profile with avatar upload" → "user-profile-avatar-upload"
+   - Keep name concise (2-4 words ideally)
+
+2. **Check Uniqueness**:
+   - Use Glob to check `.red64/specs/*/`
+   - If feature name exists, append `-2`, `-3`, etc.
+
+3. **Create Directory**:
+   - Use Bash: `mkdir -p .red64/specs/{feature-name}`
+
+4. **Initialize Files from Templates**:
+
+   a. Read templates:
+   ```
+   - .red64/settings/templates/specs/init.json
+   - .red64/settings/templates/specs/requirements-init.md
+   ```
+
+   b. Replace placeholders:
+   ```
+   {{FEATURE_NAME}} → feature-name
+   {{TIMESTAMP}} → current ISO 8601 timestamp (use `date -u +"%Y-%m-%dT%H:%M:%SZ"`)
+   {{PROJECT_DESCRIPTION}} → description
+   ```
+
+   c. Write files using Write tool:
+   ```
+   - .red64/specs/{feature-name}/spec.json
+   - .red64/specs/{feature-name}/requirements.md
+   ```
+
+5. **Update TodoWrite**: Mark task 1 as `completed`, task 2 as `in_progress`.
+
+6. **Output Progress**:
+   ```
+   ✅ Spec initialized at .red64/specs/{feature-name}/
+   ```
+
+**Automatic Mode**: IMMEDIATELY continue to Phase 2.
+
+**Interactive Mode**: Prompt "Continue to requirements generation? (yes/no)"
+- If "no": Stop, show current state
+- If "yes": Continue to Phase 2
+
+---
+
+#### Phase 2: Generate Requirements
+
+**Task 2 is already `in_progress` from Phase 1.**
+
+**Execute SlashCommand**:
+```
+/red64:spec-requirements {feature-name}
+```
+
+Wait for completion. Subagent will return with "次のステップ" message.
+
+**IMPORTANT**: In Automatic Mode, IGNORE the "次のステップ" message. It is for standalone usage.
+
+**Update TodoWrite**: Mark task 2 as `completed`, task 3 as `in_progress`.
+
+**Output Progress**:
+```
+✅ Requirements generated → Continuing to design...
+```
+
+**Automatic Mode**: Task list shows 2/4 complete. IMMEDIATELY continue to Phase 3.
+
+**Interactive Mode**: Prompt "Continue to design generation? (yes/no)"
+- If "no": Stop, show current state
+- If "yes": Continue to Phase 3
+
+---
+
+#### Phase 3: Generate Design
+
+**Task 3 is already `in_progress` from Phase 2.**
+
+**Execute SlashCommand**:
+```
+/red64:spec-design {feature-name} -y
+```
+
+Note: `-y` flag auto-approves requirements.
+
+Wait for completion. Subagent will return with "次のステップ" message.
+
+**IMPORTANT**: In Automatic Mode, IGNORE the "次のステップ" message.
+
+**Update TodoWrite**: Mark task 3 as `completed`, task 4 as `in_progress`.
+
+**Output Progress**:
+```
+✅ Design generated → Continuing to tasks...
+```
+
+**Automatic Mode**: Task list shows 3/4 complete. IMMEDIATELY continue to Phase 4.
+
+**Interactive Mode**: Prompt "Continue to tasks generation? (yes/no)"
+- If "no": Stop, show current state
+- If "yes": Continue to Phase 4
+
+---
+
+#### Phase 4: Generate Tasks
+
+**Task 4 is already `in_progress` from Phase 3.**
+
+**Execute SlashCommand**:
+```
+/red64:spec-tasks {feature-name} -y
+```
+
+Note: `-y` flag auto-approves design.
+
+Wait for completion.
+
+**Update TodoWrite**: Mark task 4 as `completed`.
+
+**All 4 tasks complete. Loop is DONE.**
+
+Output final completion summary (see Output Description section) and exit.
+
+---
+
+## Important Constraints
+
+### Phase 1 Implementation Notes
+- Feature name generation should be deterministic and readable
+- Always check for conflicts before creating directory
+- Validate templates exist before reading
+- Use ISO 8601 format for timestamp: `YYYY-MM-DDTHH:MM:SSZ`
+
+### Automatic Mode Behavior
+- Do NOT stop between phases
+- Do NOT wait for user input
+- Do NOT be influenced by "次のステップ" messages from Phases 2-4
+- Update TodoWrite after each phase to maintain progress visibility
+- Continue loop until all 4 phases complete
+
+### Interactive Mode Behavior
+- Prompt user after each phase
+- Wait for "yes/y" or "no/n" response
+- If "no": Stop gracefully, show completed phases
+- If "yes": Continue to next phase
+
+### Error Handling
+- Any phase failure stops the workflow
+- Display error and current state
+- Suggest manual recovery command
+
+</instructions>
+
+## Tool Guidance
+
+### Phase 1 Tools
+- **Glob**: Check `.red64/specs/*/` for existing feature names
+- **Bash**: Create directory with `mkdir -p`, generate timestamp with `date -u`
+- **Read**: Fetch templates from `.red64/settings/templates/specs/`
+- **Write**: Create `spec.json` and `requirements.md` in spec directory
+
+### Phase 2-4 Tools
+- **SlashCommand**: Execute `/red64:spec-requirements`, `/red64:spec-design`, `/red64:spec-tasks`
+
+### TodoWrite Usage
+- Initialize with 4 pending tasks
+- Update after each phase: current task `completed`, next task `in_progress`
+- Provides visual progress tracking in UI
+
+## Output Description
+
+### Mode Banners
+
+**Interactive Mode**:
+```
+🚀 Quick Spec Generation (Interactive Mode)
+
+You will be prompted at each phase.
+⚠️ Skips gap analysis and design validation.
+```
+
+**Automatic Mode**:
+```
+🚀 Quick Spec Generation (Automatic Mode)
+
+All phases execute automatically without prompts.
+⚠️ Skips all validations and reviews.
+```
+
+### Intermediate Output
+
+After each phase, show brief progress:
+```
+✅ Spec initialized at .red64/specs/{feature}/
+✅ Requirements generated → Continuing to design...
+✅ Design generated → Continuing to tasks...
+```
+
+### Final Completion Summary
+
+Provide output in the language specified in `spec.json`:
+
+```
+✅ Quick Spec Generation Complete!
+
+## Generated Files:
+- .red64/specs/{feature}/spec.json
+- .red64/specs/{feature}/requirements.md ({X} requirements)
+- .red64/specs/{feature}/design.md ({Y} components, {Z} endpoints)
+- .red64/specs/{feature}/tasks.md ({N} tasks)
+
+⚠️ Quick generation skipped:
+- `/red64:validate-gap` - Gap analysis (integration check)
+- `/red64:validate-design` - Design review (architecture validation)
+
+## Next Steps:
+1. Review generated specs (especially design.md)
+2. Optional validation:
+   - `/red64:validate-gap {feature}` - Check integration with existing codebase
+   - `/red64:validate-design {feature}` - Verify architecture quality
+3. Start implementation: `/red64:spec-impl {feature}`
+
+## Note:
+For complex features (integrations, security, APIs), use standard workflow:
+/red64:spec-init → /red64:spec-requirements → /red64:validate-gap
+→ /red64:spec-design → /red64:validate-design → /red64:spec-tasks
+```
+
+## Safety & Fallback
+
+### Argument Parsing
+- Use `$ARGUMENTS` to parse (NOT `$1`, `$2`)
+- Handle spaces in descriptions correctly
+- Example: `"Multi word description --auto"` → extract both parts correctly
+
+### Feature Name Generation
+- Convert to lowercase kebab-case
+- Remove special characters
+- If ambiguous, prefer descriptive over short
+- If conflict exists, append `-2`, `-3`, etc.
+
+### Error Scenarios
+
+**Template Missing**:
+- Check `.red64/settings/templates/specs/` exists
+- Report specific missing file
+- Exit with error
+
+**Directory Creation Failed**:
+- Check permissions
+- Report error with path
+- Exit with error
+
+**Phase Execution Failed** (Phase 2-4):
+- Stop workflow
+- Show current state and completed phases
+- Suggest: "Continue manually from `/red64:spec-{next-phase} {feature}`"
+
+**User Cancellation** (Interactive Mode):
+- Stop gracefully
+- Show completed phases
+- Suggest manual continuation
+
+### Usage Guidance
+
+**Use Automatic Mode** (`--auto`) when:
+- Simple feature (CRUD, basic UI)
+- Prototyping / proof-of-concept
+- Well-known feature pattern
+
+**Use Interactive Mode** (default) when:
+- First time using spec-quick
+- Want to review each phase
+- Moderately complex feature
+
+**Use Standard Workflow** (NOT spec-quick) when:
+- Complex integration with existing systems
+- Security-critical features
+- Production-ready quality required
+- Need gap analysis or design validation

package/framework/agents/claude/.claude/commands/red64/spec-requirements.md

@@ -0,0 +1,62 @@
+---
+description: Generate comprehensive requirements for a specification
+allowed-tools: Read, Task
+argument-hint: <feature-name>
+---
+
+# Requirements Generation
+
+## Parse Arguments
+- Feature name: `$1`
+
+## Validate
+Check that spec has been initialized:
+- Verify `.red64/specs/$1/` exists
+- Verify `.red64/specs/$1/spec.json` exists
+
+If validation fails, inform user to run `/red64:spec-init` first.
+
+## Invoke Subagent
+
+Delegate requirements generation to spec-requirements-agent:
+
+Use the Task tool to invoke the Subagent with file path patterns:
+
+```
+Task(
+  subagent_type="spec-requirements-agent",
+  description="Generate EARS requirements",
+  prompt="""
+Feature: $1
+Spec directory: .red64/specs/$1/
+
+File patterns to read:
+- .red64/specs/$1/spec.json
+- .red64/specs/$1/requirements.md
+- .red64/steering/*.md
+- .red64/settings/rules/ears-format.md
+- .red64/settings/templates/specs/requirements.md
+
+Mode: generate
+"""
+)
+```
+
+## Display Result
+
+Show Subagent summary to user, then provide next step guidance:
+
+### Next Phase: Design Generation
+
+**If Requirements Approved**:
+- Review generated requirements at `.red64/specs/$1/requirements.md`
+- **Optional Gap Analysis** (for existing codebases):
+  - Run `/red64:validate-gap $1` to analyze implementation gap with current code
+  - Identifies existing components, integration points, and implementation strategy
+  - Recommended for brownfield projects; skip for greenfield
+- Then `/red64:spec-design $1 [-y]` to proceed to design phase
+
+**If Modifications Needed**:
+- Provide feedback and re-run `/red64:spec-requirements $1`
+
+**Note**: Approval is mandatory before proceeding to design phase.

package/framework/agents/claude/.claude/commands/red64/spec-status.md

@@ -0,0 +1,87 @@
+---
+description: Show specification status and progress
+allowed-tools: Bash, Read, Glob, Write, Edit, MultiEdit, Update
+argument-hint: <feature-name>
+---
+
+# Specification Status
+
+<background_information>
+- **Mission**: Display comprehensive status and progress for a specification
+- **Success Criteria**:
+  - Show current phase and completion status
+  - Identify next actions and blockers
+  - Provide clear visibility into progress
+</background_information>
+
+<instructions>
+## Core Task
+Generate status report for feature **$1** showing progress across all phases.
+
+## Execution Steps
+
+### Step 1: Load Spec Context
+- Read `.red64/specs/$1/spec.json` for metadata and phase status
+- Read existing files: `requirements.md`, `design.md`, `tasks.md` (if they exist)
+- Check `.red64/specs/$1/` directory for available files
+
+### Step 2: Analyze Status
+
+**Parse each phase**:
+- **Requirements**: Count requirements and acceptance criteria
+- **Design**: Check for architecture, components, diagrams
+- **Tasks**: Count completed vs total tasks (parse `- [x]` vs `- [ ]`)
+- **Approvals**: Check approval status in spec.json
+
+### Step 3: Generate Report
+
+Create report in the language specified in spec.json covering:
+1. **Current Phase & Progress**: Where the spec is in the workflow
+2. **Completion Status**: Percentage complete for each phase
+3. **Task Breakdown**: If tasks exist, show completed/remaining counts
+4. **Next Actions**: What needs to be done next
+5. **Blockers**: Any issues preventing progress
+
+## Critical Constraints
+- Use language from spec.json
+- Calculate accurate completion percentages
+- Identify specific next action commands
+</instructions>
+
+## Tool Guidance
+- **Read**: Load spec.json first, then other spec files as needed
+- **Parse carefully**: Extract completion data from tasks.md checkboxes
+- Use **Glob** to check which spec files exist
+
+## Output Description
+
+Provide status report in the language specified in spec.json:
+
+**Report Structure**:
+1. **Feature Overview**: Name, phase, last updated
+2. **Phase Status**: Requirements, Design, Tasks with completion %
+3. **Task Progress**: If tasks exist, show X/Y completed
+4. **Next Action**: Specific command to run next
+5. **Issues**: Any blockers or missing elements
+
+**Format**: Clear, scannable format with emojis (✅/⏳/❌) for status
+
+## Safety & Fallback
+
+### Error Scenarios
+
+**Spec Not Found**:
+- **Message**: "No spec found for `$1`. Check available specs in `.red64/specs/`"
+- **Action**: List available spec directories
+
+**Incomplete Spec**:
+- **Warning**: Identify which files are missing
+- **Suggested Action**: Point to next phase command
+
+### List All Specs
+
+To see all available specs:
+- Run with no argument or use wildcard
+- Shows all specs in `.red64/specs/` with their status
+
+think

package/framework/agents/claude/.claude/commands/red64/spec-tasks.md

@@ -0,0 +1,75 @@
+---
+description: Generate implementation tasks for a specification
+allowed-tools: Read, Task
+argument-hint: <feature-name> [-y] [--sequential]
+---
+
+# Implementation Tasks Generator
+
+## Parse Arguments
+- Feature name: `$1`
+- Auto-approve flag: `$2` (optional, "-y")
+- Sequential mode flag: `$3` (optional, "--sequential")
+
+## Validate
+Check that design has been completed:
+- Verify `.red64/specs/$1/` exists
+- Verify `.red64/specs/$1/design.md` exists
+- Determine `sequential = ($3 == "--sequential")`
+
+If validation fails, inform user to complete design phase first.
+
+## Invoke Subagent
+
+Delegate task generation to spec-tasks-agent:
+
+Use the Task tool to invoke the Subagent with file path patterns:
+
+```
+Task(
+  subagent_type="spec-tasks-agent",
+  description="Generate implementation tasks",
+  prompt="""
+Feature: $1
+Spec directory: .red64/specs/$1/
+Auto-approve: {true if $2 == "-y", else false}
+Sequential mode: {true if sequential else false}
+
+File patterns to read:
+- .red64/specs/$1/*.{json,md}
+- .red64/steering/*.md
+- .red64/settings/rules/tasks-generation.md
+- .red64/settings/rules/tasks-parallel-analysis.md (include only when sequential mode is false)
+- .red64/settings/templates/specs/tasks.md
+
+Mode: {generate or merge based on tasks.md existence}
+Instruction highlights:
+- Map all requirements to tasks and list requirement IDs only (comma-separated) without extra narration
+- Promote single actionable sub-tasks to major tasks and keep container summaries concise
+- Apply `(P)` markers only when parallel criteria met (omit in sequential mode)
+- Mark optional acceptance-criteria-focused test coverage subtasks with `- [ ]*` only when deferrable post-MVP
+"""
+)
+```
+
+## Display Result
+
+Show Subagent summary to user, then provide next step guidance:
+
+### Next Phase: Implementation
+
+**Before Starting Implementation**:
+- **IMPORTANT**: Clear conversation history and free up context before running `/red64:spec-impl`
+- This applies when starting first task OR switching between tasks
+- Fresh context ensures clean state and proper task focus
+
+**If Tasks Approved**:
+- Execute specific task: `/red64:spec-impl $1 1.1` (recommended: clear context between each task)
+- Execute multiple tasks: `/red64:spec-impl $1 1.1,1.2` (use cautiously, clear context between tasks)
+- Without arguments: `/red64:spec-impl $1` (executes all pending tasks - NOT recommended due to context bloat)
+
+**If Modifications Needed**:
+- Provide feedback and re-run `/red64:spec-tasks $1`
+- Existing tasks used as reference (merge mode)
+
+**Note**: The implementation phase will guide you through executing tasks with appropriate context and validation.

package/framework/agents/claude/.claude/commands/red64/steering-custom.md

@@ -0,0 +1,59 @@
+---
+description: Create custom steering documents for specialized project contexts
+allowed-tools: Task
+---
+
+# Red64 Custom Steering Creation
+
+## Interactive Workflow
+
+This command starts an interactive process with the Subagent:
+1. Subagent asks user for domain/topic
+2. Subagent checks for available templates
+3. Subagent analyzes codebase for relevant patterns
+4. Subagent generates custom steering file
+
+## Invoke Subagent
+
+Delegate custom steering creation to steering-custom-agent:
+
+Use the Task tool to invoke the Subagent with file path patterns:
+
+```
+Task(
+  subagent_type="steering-custom-agent",
+  description="Create custom steering",
+  prompt="""
+Interactive Mode: Ask user for domain/topic
+
+File patterns to read:
+- .red64/settings/templates/steering-custom/*.md
+- .red64/settings/rules/steering-principles.md
+
+JIT Strategy: Analyze codebase for relevant patterns as needed
+"""
+)
+```
+
+## Display Result
+
+Show Subagent summary to user:
+- Custom steering file created
+- Template used (if any)
+- Codebase patterns analyzed
+- Content overview
+
+## Available Templates
+
+Available templates in `.red64/settings/templates/steering-custom/`:
+- api-standards.md, testing.md, security.md, database.md
+- error-handling.md, authentication.md, deployment.md
+
+## Notes
+
+- Subagent will interact with user to understand needs
+- Templates are starting points, customized for project
+- All steering files loaded as project memory
+- Avoid documenting agent-specific tooling directories (e.g. `.cursor/`, `.gemini/`, `.claude/`)
+- `.red64/settings/` content should NOT be documented (it's metadata, not project knowledge)
+- Light references to `.red64/specs/` and `.red64/steering/` are acceptable; avoid other `.red64/` directories

package/framework/agents/claude/.claude/commands/red64/steering.md

@@ -0,0 +1,62 @@
+---
+description: Manage .red64/steering/ as persistent project knowledge
+allowed-tools: Read, Task, Glob
+---
+
+# Red64 Steering Management
+
+## Mode Detection
+
+**Perform detection before invoking Subagent**:
+
+Check `.red64/steering/` status:
+- **Bootstrap Mode**: Empty OR missing core files (product.md, tech.md, structure.md)
+- **Sync Mode**: All core files exist
+
+Use Glob to check for existing steering files.
+
+## Invoke Subagent
+
+Delegate steering management to steering-agent:
+
+Use the Task tool to invoke the Subagent with file path patterns:
+
+```
+Task(
+  subagent_type="steering-agent",
+  description="Manage steering files",
+  prompt="""
+Mode: {bootstrap or sync based on detection}
+
+File patterns to read:
+- .red64/steering/*.md (if sync mode)
+- .red64/settings/templates/steering/*.md
+- .red64/settings/rules/steering-principles.md
+
+JIT Strategy: Fetch codebase files when needed, not upfront
+"""
+)
+```
+
+## Display Result
+
+Show Subagent summary to user:
+
+### Bootstrap:
+- Generated steering files: product.md, tech.md, structure.md
+- Review and approve as Source of Truth
+
+### Sync:
+- Updated steering files
+- Code drift warnings
+- Recommendations for custom steering
+
+## Notes
+
+- All `.red64/steering/*.md` loaded as project memory
+- Templates and principles are external for customization
+- Focus on patterns, not catalogs
+- "Golden Rule": New code following patterns shouldn't require steering updates
+- Avoid documenting agent-specific tooling directories (e.g. `.cursor/`, `.gemini/`, `.claude/`)
+- `.red64/settings/` content should NOT be documented in steering files (settings are metadata, not project knowledge)
+- Light references to `.red64/specs/` and `.red64/steering/` are acceptable; avoid other `.red64/` directories