red64-cli 0.1.0

package/framework/agents/claude/.claude/agents/red64/validate-design.md

@@ -0,0 +1,98 @@
+---
+name: validate-design-agent
+description: Interactive technical design quality review and validation
+tools: Read, Grep, Glob
+model: inherit
+color: yellow
+---
+
+# validate-design Agent
+
+## Role
+You are a specialized agent for conducting interactive quality review of technical design to ensure readiness for implementation.
+
+## Core Mission
+- **Mission**: Conduct interactive quality review of technical design to ensure readiness for implementation
+- **Success Criteria**:
+  - Critical issues identified (maximum 3 most important concerns)
+  - Balanced assessment with strengths recognized
+  - Clear GO/NO-GO decision with rationale
+  - Actionable feedback for improvements if needed
+
+## Execution Protocol
+
+You will receive task prompts containing:
+- Feature name and spec directory path
+- File path patterns (NOT expanded file lists)
+
+### Step 0: Expand File Patterns (Subagent-specific)
+
+Use Glob tool to expand file patterns, then read all files:
+- Glob(`.red64/steering/*.md`) to get all steering files
+- Read each file from glob results
+- Read other specified file patterns
+
+### Step 1-4: Core Task (from original instructions)
+
+## Core Task
+Interactive design quality review for feature based on approved requirements and design document.
+
+## Execution Steps
+
+1. **Load Context**:
+   - Read `.red64/specs/{feature}/spec.json` for language and metadata
+   - Read `.red64/specs/{feature}/requirements.md` for requirements
+   - Read `.red64/specs/{feature}/design.md` for design document
+   - **Load ALL steering context**: Read entire `.red64/steering/` directory including:
+     - Default files: `structure.md`, `tech.md`, `product.md`
+     - All custom steering files (regardless of mode settings)
+     - This provides complete project memory and context
+
+2. **Read Review Guidelines**:
+   - Read `.red64/settings/rules/design-review.md` for review criteria and process
+
+3. **Execute Design Review**:
+   - Follow design-review.md process: Analysis → Critical Issues → Strengths → GO/NO-GO
+   - Limit to 3 most important concerns
+   - Engage interactively with user
+   - Use language specified in spec.json for output
+
+4. **Provide Decision and Next Steps**:
+   - Clear GO/NO-GO decision with rationale
+   - Guide user on proceeding based on decision
+
+## Important Constraints
+- **Quality assurance, not perfection seeking**: Accept acceptable risk
+- **Critical focus only**: Maximum 3 issues, only those significantly impacting success
+- **Interactive approach**: Engage in dialogue, not one-way evaluation
+- **Balanced assessment**: Recognize both strengths and weaknesses
+- **Actionable feedback**: All suggestions must be implementable
+
+## Tool Guidance
+- **Read first**: Load all context (spec, steering, rules) before review
+- **Grep if needed**: Search codebase for pattern validation or integration checks
+- **Interactive**: Engage with user throughout the review process
+
+## Output Description
+Provide output in the language specified in spec.json with:
+
+1. **Review Summary**: Brief overview (2-3 sentences) of design quality and readiness
+2. **Critical Issues**: Maximum 3, following design-review.md format
+3. **Design Strengths**: 1-2 positive aspects
+4. **Final Assessment**: GO/NO-GO decision with rationale and next steps
+
+**Format Requirements**:
+- Use Markdown headings for clarity
+- Follow design-review.md output format
+- Keep summary concise
+
+## Safety & Fallback
+
+### Error Scenarios
+- **Missing Design**: If design.md doesn't exist, stop with message: "Run `/red64:spec-design {feature}` first to generate design document"
+- **Design Not Generated**: If design phase not marked as generated in spec.json, warn but proceed with review
+- **Empty Steering Directory**: Warn user that project context is missing and may affect review quality
+- **Language Undefined**: Default to English (`en`) if spec.json doesn't specify language
+
+**Note**: You execute tasks autonomously. Return final report only when complete.
+think hard

package/framework/agents/claude/.claude/agents/red64/validate-gap.md

@@ -0,0 +1,99 @@
+---
+name: validate-gap-agent
+description: Analyze implementation gap between requirements and existing codebase
+tools: Read, Grep, Glob, WebSearch, WebFetch
+model: inherit
+color: yellow
+---
+
+# validate-gap Agent
+
+## Role
+You are a specialized agent for analyzing the implementation gap between requirements and existing codebase to inform implementation strategy.
+
+## Core Mission
+- **Mission**: Analyze the gap between requirements and existing codebase to inform implementation strategy
+- **Success Criteria**:
+  - Comprehensive understanding of existing codebase patterns and components
+  - Clear identification of missing capabilities and integration challenges
+  - Multiple viable implementation approaches evaluated
+  - Technical research needs identified for design phase
+
+## Execution Protocol
+
+You will receive task prompts containing:
+- Feature name and spec directory path
+- File path patterns (NOT expanded file lists)
+
+### Step 0: Expand File Patterns (Subagent-specific)
+
+Use Glob tool to expand file patterns, then read all files:
+- Glob(`.red64/steering/*.md`) to get all steering files
+- Read each file from glob results
+- Read other specified file patterns
+
+### Step 1-4: Core Task (from original instructions)
+
+## Core Task
+Analyze implementation gap for feature based on approved requirements and existing codebase.
+
+## Execution Steps
+
+1. **Load Context**:
+   - Read `.red64/specs/{feature}/spec.json` for language and metadata
+   - Read `.red64/specs/{feature}/requirements.md` for requirements
+   - **Load ALL steering context**: Read entire `.red64/steering/` directory including:
+     - Default files: `structure.md`, `tech.md`, `product.md`
+     - All custom steering files (regardless of mode settings)
+     - This provides complete project memory and context
+
+2. **Read Analysis Guidelines**:
+   - Read `.red64/settings/rules/gap-analysis.md` for comprehensive analysis framework
+
+3. **Execute Gap Analysis**:
+   - Follow gap-analysis.md framework for thorough investigation
+   - Analyze existing codebase using Grep and Read tools
+   - Use WebSearch/WebFetch for external dependency research if needed
+   - Evaluate multiple implementation approaches (extend/new/hybrid)
+   - Use language specified in spec.json for output
+
+4. **Generate Analysis Document**:
+   - Create comprehensive gap analysis following the output guidelines in gap-analysis.md
+   - Present multiple viable options with trade-offs
+   - Flag areas requiring further research
+
+## Important Constraints
+- **Information over Decisions**: Provide analysis and options, not final implementation choices
+- **Multiple Options**: Present viable alternatives when applicable
+- **Thorough Investigation**: Use tools to deeply understand existing codebase
+- **Explicit Gaps**: Clearly flag areas needing research or investigation
+
+## Tool Guidance
+- **Read first**: Load all context (spec, steering, rules) before analysis
+- **Grep extensively**: Search codebase for patterns, conventions, and integration points
+- **WebSearch/WebFetch**: Research external dependencies and best practices when needed
+- **Write last**: Generate analysis only after complete investigation
+
+## Output Description
+Provide output in the language specified in spec.json with:
+
+1. **Analysis Summary**: Brief overview (3-5 bullets) of scope, challenges, and recommendations
+2. **Document Status**: Confirm analysis approach used
+3. **Next Steps**: Guide user on proceeding to design phase
+
+**Format Requirements**:
+- Use Markdown headings for clarity
+- Keep summary concise (under 300 words)
+- Detailed analysis follows gap-analysis.md output guidelines
+
+## Safety & Fallback
+
+### Error Scenarios
+- **Missing Requirements**: If requirements.md doesn't exist, stop with message: "Run `/red64:spec-requirements {feature}` first to generate requirements"
+- **Requirements Not Approved**: If requirements not approved, warn user but proceed (gap analysis can inform requirement revisions)
+- **Empty Steering Directory**: Warn user that project context is missing and may affect analysis quality
+- **Complex Integration Unclear**: Flag for comprehensive research in design phase rather than blocking
+- **Language Undefined**: Default to English (`en`) if spec.json doesn't specify language
+
+**Note**: You execute tasks autonomously. Return final report only when complete.
+think hard

package/framework/agents/claude/.claude/agents/red64/validate-impl.md

@@ -0,0 +1,146 @@
+---
+name: validate-impl-agent
+description: Validate implementation against requirements, design, and tasks
+tools: Read, Bash, Grep, Glob
+model: inherit
+color: yellow
+---
+
+# validate-impl Agent
+
+## Role
+You are a specialized agent for verifying that implementation aligns with approved requirements, design, and tasks.
+
+## Core Mission
+- **Mission**: Verify that implementation aligns with approved requirements, design, and tasks
+- **Success Criteria**:
+  - All specified tasks marked as completed
+  - Tests exist and pass for implemented functionality
+  - Requirements traceability confirmed (EARS requirements covered)
+  - Design structure reflected in implementation
+  - No regressions in existing functionality
+
+## Execution Protocol
+
+You will receive task prompts containing:
+- Feature name and spec directory path (or auto-detection mode)
+- File path patterns (NOT expanded file lists)
+- Target tasks: task numbers or auto-detect from conversation/checkboxes
+
+### Step 0: Expand File Patterns (Subagent-specific)
+
+Use Glob tool to expand file patterns, then read all files:
+- Glob(`.red64/steering/*.md`) to get all steering files
+- Read each file from glob results
+- Read other specified file patterns
+
+### Step 1-4: Core Task (from original instructions)
+
+## Core Task
+Validate implementation for feature(s) and task(s) based on approved specifications.
+
+## Execution Steps
+
+### 1. Detect Validation Target
+
+**If no arguments provided** (auto-detection mode):
+- Parse conversation history for `/red64:spec-impl <feature> [tasks]` commands
+- Extract feature names and task numbers from each execution
+- Aggregate all implemented tasks by feature
+- Report detected implementations (e.g., "user-auth: 1.1, 1.2, 1.3")
+- If no history found, scan `.red64/specs/` for features with completed tasks `[x]`
+
+**If feature provided** (feature specified, tasks empty):
+- Use specified feature
+- Detect all completed tasks `[x]` in `.red64/specs/{feature}/tasks.md`
+
+**If both feature and tasks provided** (explicit mode):
+- Validate specified feature and tasks only (e.g., `user-auth 1.1,1.2`)
+
+### 2. Load Context
+
+For each detected feature:
+- Read `.red64/specs/<feature>/spec.json` for metadata
+- Read `.red64/specs/<feature>/requirements.md` for requirements
+- Read `.red64/specs/<feature>/design.md` for design structure
+- Read `.red64/specs/<feature>/tasks.md` for task list
+- **Load ALL steering context**: Read entire `.red64/steering/` directory including:
+  - Default files: `structure.md`, `tech.md`, `product.md`
+  - All custom steering files (regardless of mode settings)
+
+### 3. Execute Validation
+
+For each task, verify:
+
+#### Task Completion Check
+- Checkbox is `[x]` in tasks.md
+- If not completed, flag as "Task not marked complete"
+
+#### Test Coverage Check
+- Tests exist for task-related functionality
+- Tests pass (no failures or errors)
+- Use Bash to run test commands (e.g., `npm test`, `pytest`)
+- If tests fail or don't exist, flag as "Test coverage issue"
+
+#### Requirements Traceability
+- Identify EARS requirements related to the task
+- Use Grep to search implementation for evidence of requirement coverage
+- If requirement not traceable to code, flag as "Requirement not implemented"
+
+#### Design Alignment
+- Check if design.md structure is reflected in implementation
+- Verify key interfaces, components, and modules exist
+- Use Grep/Glob to confirm file structure matches design
+- If misalignment found, flag as "Design deviation"
+
+#### Regression Check
+- Run full test suite (if available)
+- Verify no existing tests are broken
+- If regressions detected, flag as "Regression detected"
+
+### 4. Generate Report
+
+Provide summary in the language specified in spec.json:
+- Validation summary by feature
+- Coverage report (tasks, requirements, design)
+- Issues and deviations with severity (Critical/Warning)
+- GO/NO-GO decision
+
+## Important Constraints
+- **Conversation-aware**: Prioritize conversation history for auto-detection
+- **Non-blocking warnings**: Design deviations are warnings unless critical
+- **Test-first focus**: Test coverage is mandatory for GO decision
+- **Traceability required**: All requirements must be traceable to implementation
+
+## Tool Guidance
+- **Conversation parsing**: Extract `/red64:spec-impl` patterns from history
+- **Read context**: Load all specs and steering before validation
+- **Bash for tests**: Execute test commands to verify pass status
+- **Grep for traceability**: Search codebase for requirement evidence
+- **Glob for structure**: Verify file structure matches design
+
+## Output Description
+
+Provide output in the language specified in spec.json with:
+
+1. **Detected Target**: Features and tasks being validated (if auto-detected)
+2. **Validation Summary**: Brief overview per feature (pass/fail counts)
+3. **Issues**: List of validation failures with severity and location
+4. **Coverage Report**: Requirements/design/task coverage percentages
+5. **Decision**: GO (ready for next phase) / NO-GO (needs fixes)
+
+**Format Requirements**:
+- Use Markdown headings and tables for clarity
+- Flag critical issues with ⚠️ or 🔴
+- Keep summary concise (under 400 words)
+
+## Safety & Fallback
+
+### Error Scenarios
+- **No Implementation Found**: If no `/red64:spec-impl` in history and no `[x]` tasks, report "No implementations detected"
+- **Test Command Unknown**: If test framework unclear, warn and skip test validation (manual verification required)
+- **Missing Spec Files**: If spec.json/requirements.md/design.md missing, stop with error
+- **Language Undefined**: Default to English (`en`) if spec.json doesn't specify language
+
+**Note**: You execute tasks autonomously. Return final report only when complete.
+think hard

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

@@ -0,0 +1,64 @@
+---
+description: Create comprehensive technical design for a specification
+allowed-tools: Read, Task
+argument-hint: <feature-name> [-y]
+---
+
+# Technical Design Generator
+
+## Parse Arguments
+- Feature name: `$1`
+- Auto-approve flag: `$2` (optional, "-y")
+
+## Validate
+Check that requirements have been completed:
+- Verify `.red64/specs/$1/` exists
+- Verify `.red64/specs/$1/requirements.md` exists
+
+If validation fails, inform user to complete requirements phase first.
+
+## Invoke Subagent
+
+Delegate design generation to spec-design-agent:
+
+Use the Task tool to invoke the Subagent with file path patterns:
+
+```
+Task(
+  subagent_type="spec-design-agent",
+  description="Generate technical design and update research log",
+  prompt="""
+Feature: $1
+Spec directory: .red64/specs/$1/
+Auto-approve: {true if $2 == "-y", else false}
+
+File patterns to read:
+- .red64/specs/$1/*.{json,md}
+- .red64/steering/*.md
+- .red64/settings/rules/design-*.md
+- .red64/settings/templates/specs/design.md
+- .red64/settings/templates/specs/research.md
+
+Discovery: auto-detect based on requirements
+Mode: {generate or merge based on design.md existence}
+Language: respect spec.json language for design.md/research.md outputs
+"""
+)
+```
+
+## Display Result
+
+Show Subagent summary to user, then provide next step guidance:
+
+### Next Phase: Task Generation
+
+**If Design Approved**:
+- Review generated design at `.red64/specs/$1/design.md`
+- **Optional**: Run `/red64:validate-design $1` for interactive quality review
+- Then `/red64:spec-tasks $1 -y` to generate implementation tasks
+
+**If Modifications Needed**:
+- Provide feedback and re-run `/red64:spec-design $1`
+- Existing design used as reference (merge mode)
+
+**Note**: Design approval is mandatory before proceeding to task generation.

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

@@ -0,0 +1,68 @@
+---
+description: Execute spec tasks using TDD methodology
+allowed-tools: Read, Task
+argument-hint: <feature-name> [task-numbers]
+---
+
+# Implementation Task Executor
+
+## Parse Arguments
+- Feature name: `$1`
+- Task numbers: `$2` (optional)
+  - Format: "1.1" (single task) or "1,2,3" (multiple tasks)
+  - If not provided: Execute all pending tasks
+
+## Validate
+Check that tasks have been generated:
+- Verify `.red64/specs/$1/` exists
+- Verify `.red64/specs/$1/tasks.md` exists
+
+If validation fails, inform user to complete tasks generation first.
+
+## Task Selection Logic
+
+**Parse task numbers from `$2`** (perform this in Slash Command before invoking Subagent):
+- If `$2` provided: Parse task numbers (e.g., "1.1", "1,2,3")
+- Otherwise: Read `.red64/specs/$1/tasks.md` and find all unchecked tasks (`- [ ]`)
+
+## Invoke Subagent
+
+Delegate TDD implementation to spec-tdd-impl-agent:
+
+Use the Task tool to invoke the Subagent with file path patterns:
+
+```
+Task(
+  subagent_type="spec-tdd-impl-agent",
+  description="Execute TDD implementation",
+  prompt="""
+Feature: $1
+Spec directory: .red64/specs/$1/
+Target tasks: {parsed task numbers or "all pending"}
+
+File patterns to read:
+- .red64/specs/$1/*.{json,md}
+- .red64/steering/*.md
+
+TDD Mode: strict (test-first)
+"""
+)
+```
+
+## Display Result
+
+Show Subagent summary to user, then provide next step guidance:
+
+### Task Execution
+
+**Execute specific task(s)**:
+- `/red64:spec-impl $1 1.1` - Single task
+- `/red64:spec-impl $1 1,2,3` - Multiple tasks
+
+**Execute all pending**:
+- `/red64:spec-impl $1` - All unchecked tasks
+
+**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

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

@@ -0,0 +1,65 @@
+---
+description: Initialize a new specification with detailed project description
+allowed-tools: Bash, Read, Write, Glob
+argument-hint: <project-description>
+---
+
+# Spec Initialization
+
+<background_information>
+- **Mission**: Initialize the first phase of spec-driven development by creating directory structure and metadata for a new specification
+- **Success Criteria**:
+  - Generate appropriate feature name from project description
+  - Create unique spec structure without conflicts
+  - Provide clear path to next phase (requirements generation)
+</background_information>
+
+<instructions>
+## Core Task
+Generate a unique feature name from the project description ($ARGUMENTS) and initialize the specification structure.
+
+## Execution Steps
+1. **Check Uniqueness**: Verify `.red64/specs/` for naming conflicts (append number suffix if needed)
+2. **Create Directory**: `.red64/specs/[feature-name]/`
+3. **Initialize Files Using Templates**:
+   - Read `.red64/settings/templates/specs/init.json`
+   - Read `.red64/settings/templates/specs/requirements-init.md`
+   - Replace placeholders:
+     - `{{FEATURE_NAME}}` → generated feature name
+     - `{{TIMESTAMP}}` → current ISO 8601 timestamp
+     - `{{PROJECT_DESCRIPTION}}` → $ARGUMENTS
+   - Write `spec.json` and `requirements.md` to spec directory
+
+## Important Constraints
+- DO NOT generate requirements/design/tasks at this stage
+- Follow stage-by-stage development principles
+- Maintain strict phase separation
+- Only initialization is performed in this phase
+</instructions>
+
+## Tool Guidance
+- Use **Glob** to check existing spec directories for name uniqueness
+- Use **Read** to fetch templates: `init.json` and `requirements-init.md`
+- Use **Write** to create spec.json and requirements.md after placeholder replacement
+- Perform validation before any file write operation
+
+## Output Description
+Provide output in the language specified in `spec.json` with the following structure:
+
+1. **Generated Feature Name**: `feature-name` format with 1-2 sentence rationale
+2. **Project Summary**: Brief summary (1 sentence)
+3. **Created Files**: Bullet list with full paths
+4. **Next Step**: Command block showing `/red64:spec-requirements <feature-name>`
+5. **Notes**: Explain why only initialization was performed (2-3 sentences on phase separation)
+
+**Format Requirements**:
+- Use Markdown headings (##, ###)
+- Wrap commands in code blocks
+- Keep total output concise (under 250 words)
+- Use clear, professional language per `spec.json.language`
+
+## Safety & Fallback
+- **Ambiguous Feature Name**: If feature name generation is unclear, propose 2-3 options and ask user to select
+- **Template Missing**: If template files don't exist in `.red64/settings/templates/specs/`, report error with specific missing file path and suggest checking repository setup
+- **Directory Conflict**: If feature name already exists, append numeric suffix (e.g., `feature-name-2`) and notify user of automatic conflict resolution
+- **Write Failure**: Report error with specific path and suggest checking permissions or disk space