aiwf 0.1.0 → 0.3.1

package/claude-code/aiwf/en/.claude/commands/aiwf/aiwf_do_task.md

@@ -0,0 +1,109 @@
+# $Argument-Based AIWF Task Processing
+
+**IMPORTANT:** Follow from Top to Bottom - don't skip anything!
+
+**CREATE A TODO LIST** with exactly these 8 items
+
+1. Analyse scope from argument
+2. Identify task file
+3. Analyse the task
+4. Set status to in_progress
+5. Execute task work
+6. Placeholder
+7. Execute Code review
+8. Finalize Task status
+
+## 1 · Analyse scope from argument
+
+<$ARGUMENTS> ⇒ Task ID, Sprint ID, or empty (select next open task in current sprint).
+
+## 2 · Identify task file
+
+Search .aiwf/03_SPRINTS/ and .aiwf/04_GENERAL_TASKS/.
+If no open task matches, pause and ask the user how to proceed.
+
+## 3 · Analyse the task
+
+Read the task description. If anything is unclear, ask clarifying questions before continuing.
+
+**CRITICAL CONTEXT VALIDATION:** Before executing any task spin up Parallel Subagents for these tasks:
+
+1. **Sprint Context:** Confirm task belongs to current sprint scope
+2. **Dependencies:** Check if any dependent tasks need to be completed first
+3. **Requirements:** Read relevant requirements docs in `.aiwf/02_REQUIREMENTS/`
+4. **Scope Verification:** Ensure task aligns with current sprint objectives
+5. **GitHub Issue Check:** Check if task file has a `github_issue` field
+
+**IMPORTANT:** If task references functionality from future sprints or has unmet dependencies, pause and ask for clarification.
+
+**GitHub Issue Creation (Optional):**
+
+- If task doesn't have a GitHub issue and user wants issue tracking
+- Suggest using `/project:aiwf:issue_create {task_id}` command
+
+## 4 · Set status to in_progress
+
+- Find out the current local timestamp (YYYY-MM-DD HH:MM).
+- Update front-matter to **status: in_progress** and set Updated time
+- Update ./aiwf/00_PROJECT_MANIFEST.md to set task in progress, updated time and current Sprint Status.
+- **GitHub Issue Update (if exists):**
+  ```bash
+  gh issue comment {issue_number} --body "🚀 Task work has started."
+  gh issue edit {issue_number} --add-label "in-progress"
+  ```
+
+## 5 · Execute task work
+
+- Follow Description, Goal and Acceptance Criteria.
+- Consult supporting docs in .aiwf/01_PROJECT_DOCS/ and .aiwf/02_REQUIREMENTS/.
+- Iterate over subtasks:
+  1. Pick the next incomplete subtask.
+  2. Implement the required changes, consulting docs as needed.
+  3. Mark the subtask done.
+  4. Append a log entry to **## Output Log** using the format `[YYYY-MM-DD HH:MM]: <message>`.
+  5. Repeat until all subtasks are complete.
+
+## 6 · Placeholder
+
+Placeholder - just move on to the next step
+
+## 7 · Execute Code Review
+
+Follow these steps for a Code Review (in order)
+
+- include @.claude/commands/aiwf/aiwf_code_review.md and use the Task ID as Scope.
+- Follow the instructions in the file to run a code review in **PARALLEL SUBAGENTS**
+- When done continue acting on the results accordingly
+- Understand and think about the results
+- on **FAIL**
+  - thoroughly understand the problem
+  - extend the Current Task with the Subtasks identified by the review
+  - go back to "5 · Execute task work"
+- on **PASS**
+  - move on to next step
+
+## 8 · Finalize task status
+
+- set the Task status to **completed**
+- Rename the Task file accordingly to enable proper Completed recognition from the filename (TX[TASK_ID]...)
+- Update .aiwf/00_PROJECT_MANIFEST.md to reflect the new status
+- **GitHub Issue Update (if exists):**
+  ```bash
+  gh issue comment {issue_number} --body "✅ Task has been completed."
+  gh issue edit {issue_number} --remove-label "in-progress" --add-label "completed"
+  ```
+- **Report** the result to the user
+
+  ✅ **Result**: Quick statement of success
+
+  🔎 **Scope**: Identified task or reason none was processed
+
+  💬 **Summary**: One-paragraph recap of what was done or why blocked
+
+  ⏭️ **Next steps**: Recommended follow-up actions
+
+- **Suggestions** for the User:
+
+  - 🛠️ Use /project:aiwf:commit `TASK_ID` to commit the changes to git
+  - 🔀 Use /project:aiwf:pr_create `TASK_ID` to create a Pull Request
+  - 🧹 Use /clear to clear the context before starting the next Task

package/claude-code/aiwf/en/.claude/commands/aiwf/aiwf_docs.md

@@ -0,0 +1,225 @@
+# Update Documentation
+
+Analyze current project documentation and update it to reflect implementation progress and recent changes.
+
+## Create a TODO with EXACTLY these 10 Items
+
+1. Analyze documentation update scope
+2. Review project manifest and milestones
+3. Assess sprint documentation status
+4. Update ARCHITECTURE.md if needed
+5. Update milestone requirements documentation
+6. Update sprint documentation
+7. Review and update PROJECT_MANIFEST.md
+8. Update README.md and project documentation
+9. Update additional documentation folders
+10. Generate documentation update summary
+
+Follow step by step and adhere closely to the following instructions for each step.
+
+## DETAILS on every TODO item
+
+### 1. Analyze documentation update scope
+
+Check: <$ARGUMENTS>
+
+If empty, perform full documentation review. Otherwise interpret <$ARGUMENTS> to identify specific focus areas (milestone, sprint, architecture component, etc.).
+
+**CRITICAL:** Read `.aiwf/00_PROJECT_MANIFEST.md` FIRST to understand:
+- Current milestone and sprint status
+- What work is complete vs in-progress vs planned
+- Recent changes that need documentation
+
+### 2. Review project manifest and milestones
+
+**USE PARALLEL AGENTS** to:
+- READ `.aiwf/00_PROJECT_MANIFEST.md` for current status
+- READ all milestone requirements in `.aiwf/02_REQUIREMENTS/`
+- IDENTIFY what has changed since last documentation update
+- CHECK for any milestones marked as completed that need status updates
+
+### 3. Assess sprint documentation status
+
+**USE PARALLEL AGENTS** to:
+- NAVIGATE to `.aiwf/03_SPRINTS/` to find current and completed sprints
+- READ sprint meta files to understand deliverables
+- CHECK task completion status within each sprint
+- IDENTIFY sprints that need status updates or completion markers
+
+### 4. Update ARCHITECTURE.md if needed
+
+- READ `.aiwf/01_PROJECT_DOCS/ARCHITECTURE.md`
+- REVIEW implementation to see if architecture has evolved
+- UPDATE diagrams if structure has changed
+- ADD new components or modules discovered during implementation
+- DOCUMENT any architectural decisions made during recent sprints
+
+**IMPORTANT:** Only update if architecture has actually changed. Don't modify for minor details.
+
+### 5. Update milestone requirements documentation
+
+For each active or recently completed milestone:
+- NAVIGATE to `.aiwf/02_REQUIREMENTS/M{N}_*/`
+- UPDATE `requirements.md` with:
+  - ✅ Completed requirements
+  - 🚧 In-progress items with % complete
+  - 📋 Planned items not yet started
+  - ❌ Deferred or removed requirements with justification
+- ADD implementation notes for complex features
+- DOCUMENT any requirement changes or clarifications
+
+### 6. Update sprint documentation
+
+For current and recently completed sprints:
+- NAVIGATE to `.aiwf/03_SPRINTS/S{N}_*/`
+- UPDATE sprint meta file with:
+  - Current status (PLANNED/IN_PROGRESS/COMPLETED)
+  - Completion percentage
+  - Actual vs planned deliverables
+- UPDATE individual task files:
+  - Mark completed tasks with ✅
+  - Add implementation notes
+  - Document any blockers or challenges
+  - Link to relevant code files
+
+### 7. Review and update PROJECT_MANIFEST.md
+
+Update the manifest with:
+- **Current Status**: Update milestone and sprint progress
+- **Sprint Tracking**: Mark completed sprints, update current sprint
+- **Deliverables**: Update completion status for each deliverable
+- **Recent Achievements**: Add notable completions
+- **Known Issues**: Document any blockers or technical debt
+- **Next Steps**: Update based on completed work
+
+**Format Example:**
+```markdown
+## Current Status
+- **Active Milestone**: M01 - [Name] (75% complete)
+- **Current Sprint**: S03 - [Focus] (IN PROGRESS - 40% complete)
+- **Last Updated**: YYYY-MM-DD HH:MM
+
+## Sprint Progress
+
+### Current Sprint (S03)
+**Status**: IN PROGRESS (40% complete)
+**Deliverables**:
+- ✅ [Completed feature] - Done
+- 🚧 [In-progress feature] - 60% complete
+- 📋 [Planned feature] - Not started
+```
+
+### 8. Update README.md and project documentation
+
+**Review and update the project's main README.md:**
+- CHECK if README.md exists in project root
+- UPDATE project description if scope has evolved
+- REFRESH installation/setup instructions based on recent changes
+- UPDATE usage examples with new features
+- ADD/UPDATE badges (build status, test coverage, version)
+- DOCUMENT new dependencies or requirements
+- UPDATE contributing guidelines if process changed
+- REFRESH API documentation if endpoints changed
+
+**Key sections to review:**
+- Project overview and purpose
+- Features list (mark completed/in-progress/planned)
+- Installation and setup instructions
+- Usage examples and code snippets
+- Configuration options
+- API reference (if applicable)
+- Contributing guidelines
+- License information
+
+### 9. Update additional documentation folders
+
+**Search and update all documentation across the project:**
+
+**Common documentation locations to check:**
+- `docs/` - Main documentation folder
+- `documentation/` - Alternative documentation folder
+- `doc/` - Short form documentation folder
+- `api-docs/` - API-specific documentation
+- `*.md` files in project root (CONTRIBUTING.md, CHANGELOG.md, etc.)
+
+**For each documentation folder found:**
+- REVIEW all markdown files for outdated information
+- UPDATE technical specifications with implementation details
+- REFRESH user guides with new features
+- UPDATE API documentation with new endpoints/changes
+- ADD migration guides if breaking changes introduced
+- UPDATE troubleshooting sections with known issues/solutions
+
+**Specific files to check:**
+- `CHANGELOG.md` - Add recent changes and version updates
+- `CONTRIBUTING.md` - Update development workflow if changed
+- `docs/setup.md` - Refresh installation/configuration steps
+- `docs/api.md` - Update API endpoints and examples
+- `docs/deployment.md` - Update deployment procedures
+- `docs/testing.md` - Document new test procedures
+
+**Documentation consistency checks:**
+- Ensure version numbers are consistent across all docs
+- Verify code examples still work with current implementation
+- Update screenshots/diagrams if UI/architecture changed
+- Check that all links (internal and external) are valid
+- Ensure terminology is consistent throughout
+
+### 10. Generate documentation update summary
+
+Create a summary report of all documentation updates:
+
+```markdown
+# Documentation Update Summary - [YYYY-MM-DD]
+
+## Files Updated
+
+### AIWF Documentation
+- `.aiwf/00_PROJECT_MANIFEST.md` - [brief description of changes]
+- `.aiwf/01_PROJECT_DOCS/ARCHITECTURE.md` - [if updated]
+- `.aiwf/02_REQUIREMENTS/M01_*/requirements.md` - [status updates]
+- `.aiwf/03_SPRINTS/S0N_*/meta.md` - [sprint status changes]
+
+### Project Documentation
+- `README.md` - [main project documentation updates]
+- `CHANGELOG.md` - [version and change history updates]
+- `CONTRIBUTING.md` - [contribution guideline updates]
+- `docs/*.md` - [specific documentation file updates]
+- Other documentation folders - [list any additional updates]
+
+## Key Changes
+1. [Major documentation change or update]
+2. [New sections added]
+3. [Status updates applied]
+
+## Project Status After Update
+- **Milestone Progress**: M01 at X% (was Y%)
+- **Sprint Progress**: S0N at X% (was Y%)
+- **Documentation Coverage**: [assessment of documentation completeness]
+
+## Recommendations
+- [Any documentation gaps identified]
+- [Suggested documentation improvements]
+- [Areas needing clarification]
+```
+
+## Guidelines
+
+- PRESERVE original requirements and plans (use strikethrough or status markers)
+- MAINTAIN consistent status indicators (✅, 🚧, 📋, ❌)
+- UPDATE percentages based on actual implementation
+- DOCUMENT deviations from original plan with justification
+- KEEP documentation concise but comprehensive
+- ENSURE all dates and timestamps are current
+- CROSS-REFERENCE related documentation sections
+- SEARCH for all .md files across the project, not just in expected locations
+- CHECK root directory for standalone documentation files
+- VERIFY all code examples in documentation still work
+- ENSURE documentation is accessible to new team members
+
+**IMPORTANT:** Documentation should reflect reality. Update based on actual implementation status, not aspirational goals.
+
+**CRITICAL:** Don't assume documentation locations. Always search the entire project for:
+- `*.md` files in any directory
+- Common names: README, CHANGELOG, CONTRIBUTING, LICENSE, INSTALL, USAGE
+- Documentation in unexpected places (e.g., inside src/, lib/, or other code directories)

package/claude-code/aiwf/en/.claude/commands/aiwf/aiwf_infinite.md

@@ -0,0 +1,202 @@
+# INFINITE AGENTIC LOOP COMMAND
+
+Think deeply about this infinite generation task. You are about to embark on a sophisticated iterative creation process.
+
+**Variables:**
+
+spec_file: $ARGUMENTS
+output_dir: $ARGUMENTS
+count: $ARGUMENTS
+
+**ARGUMENTS PARSING:**
+Parse the following arguments from "$ARGUMENTS":
+
+1. `spec_file` - Path to the markdown specification file
+2. `output_dir` - Directory where iterations will be saved
+3. `count` - Number of iterations (1-N or "infinite")
+
+**PHASE 1: SPECIFICATION ANALYSIS**
+Read and deeply understand the specification file at `spec_file`. This file defines:
+
+- What type of content to generate
+- The format and structure requirements
+- Any specific parameters or constraints
+- The intended evolution pattern between iterations
+
+Think carefully about the spec's intent and how each iteration should build upon previous work.
+
+**PHASE 2: OUTPUT DIRECTORY RECONNAISSANCE**
+Thoroughly analyze the `output_dir` to understand the current state:
+
+- List all existing files and their naming patterns
+- Identify the highest iteration number currently present
+- Analyze the content evolution across existing iterations
+- Understand the trajectory of previous generations
+- Determine what gaps or opportunities exist for new iterations
+
+**PHASE 3: ITERATION STRATEGY**
+Based on the spec analysis and existing iterations:
+
+- Determine the starting iteration number (highest existing + 1)
+- Plan how each new iteration will be unique and evolutionary
+- Consider how to build upon previous iterations while maintaining novelty
+- If count is "infinite", prepare for continuous generation until context limits
+
+**PHASE 4: PARALLEL AGENT COORDINATION**
+Deploy multiple Sub Agents to generate iterations in parallel for maximum efficiency and creative diversity:
+
+**Sub-Agent Distribution Strategy:**
+
+- For count 1-5: Launch all agents simultaneously
+- For count 6-20: Launch in batches of 5 agents to manage coordination
+- For "infinite": Launch waves of 3-5 agents, monitoring context and spawning new waves
+
+**Agent Assignment Protocol:**
+Each Sub Agent receives:
+
+1. **Spec Context**: Complete specification file analysis
+2. **Directory Snapshot**: Current state of output_dir at launch time
+3. **Iteration Assignment**: Specific iteration number (starting_number + agent_index)
+4. **Uniqueness Directive**: Explicit instruction to avoid duplicating concepts from existing iterations
+5. **Quality Standards**: Detailed requirements from the specification
+
+**Agent Task Specification:**
+
+```
+TASK: Generate iteration [NUMBER] for [SPEC_FILE] in [OUTPUT_DIR]
+
+You are Sub Agent [X] generating iteration [NUMBER].
+
+CONTEXT:
+- Specification: [Full spec analysis]
+- Existing iterations: [Summary of current output_dir contents]
+- Your iteration number: [NUMBER]
+- Assigned creative direction: [Specific innovation dimension to explore]
+
+REQUIREMENTS:
+1. Read and understand the specification completely
+2. Analyze existing iterations to ensure your output is unique
+3. Generate content following the spec format exactly
+4. Focus on [assigned innovation dimension] while maintaining spec compliance
+5. Create file with exact name pattern specified
+6. Ensure your iteration adds genuine value and novelty
+
+DELIVERABLE: Single file as specified, with unique innovative content
+```
+
+**Parallel Execution Management:**
+
+- Launch all assigned Sub Agents simultaneously using Task tool
+- Monitor agent progress and completion
+- Handle any agent failures by reassigning iteration numbers
+- Ensure no duplicate iteration numbers are generated
+- Collect and validate all completed iterations
+
+**PHASE 5: INFINITE MODE ORCHESTRATION**
+For infinite generation mode, orchestrate continuous parallel waves:
+
+**Wave-Based Generation:**
+
+1. **Wave Planning**: Determine next wave size (3-5 agents) based on context capacity
+2. **Agent Preparation**: Prepare fresh context snapshots for each new wave
+3. **Progressive Sophistication**: Each wave should explore more advanced innovation dimensions
+4. **Context Monitoring**: Track total context usage across all agents and main orchestrator
+5. **Graceful Conclusion**: When approaching context limits, complete current wave and summarize
+
+**Infinite Execution Cycle:**
+
+```
+WHILE context_capacity > threshold:
+    1. Assess current output_dir state
+    2. Plan next wave of agents (size based on remaining context)
+    3. Assign increasingly sophisticated creative directions
+    4. Launch parallel Sub Agent wave
+    5. Monitor wave completion
+    6. Update directory state snapshot
+    7. Evaluate context capacity remaining
+    8. If sufficient capacity: Continue to next wave
+    9. If approaching limits: Complete final wave and summarize
+```
+
+**Progressive Sophistication Strategy:**
+
+- **Wave 1**: Basic functional replacements with single innovation dimension
+- **Wave 2**: Multi-dimensional innovations with enhanced interactions
+- **Wave 3**: Complex paradigm combinations with adaptive behaviors
+- **Wave N**: Revolutionary concepts pushing the boundaries of the specification
+
+**Context Optimization:**
+
+- Each wave uses fresh agent instances to avoid context accumulation
+- Main orchestrator maintains lightweight state tracking
+- Progressive summarization of completed iterations to manage context
+- Strategic pruning of less essential details in later waves
+
+**EXECUTION PRINCIPLES:**
+
+**Quality & Uniqueness:**
+
+- Each iteration must be genuinely unique and valuable
+- Build upon previous work while introducing novel elements
+- Maintain consistency with the original specification
+- Ensure proper file organization and naming
+
+**Parallel Coordination:**
+
+- Deploy Sub Agents strategically to maximize creative diversity
+- Assign distinct innovation dimensions to each agent to avoid overlap
+- Coordinate timing to prevent file naming conflicts
+- Monitor all agents for successful completion and quality
+
+**Scalability & Efficiency:**
+
+- Think deeply about the evolution trajectory across parallel streams
+- For infinite mode, optimize for maximum valuable output before context exhaustion
+- Use wave-based generation to manage context limits intelligently
+- Balance parallel speed with quality and coordination overhead
+
+**Agent Management:**
+
+- Provide each Sub Agent with complete context and clear assignments
+- Handle agent failures gracefully with iteration reassignment
+- Ensure all parallel outputs integrate cohesively with the overall progression
+
+**ULTRA-THINKING DIRECTIVE:**
+Before beginning generation, engage in extended thinking about:
+
+**Specification & Evolution:**
+
+- The deeper implications of the specification
+- How to create meaningful progression across iterations
+- What makes each iteration valuable and unique
+- How to balance consistency with innovation
+
+**Parallel Strategy:**
+
+- Optimal Sub Agent distribution for the requested count
+- How to assign distinct creative directions to maximize diversity
+- Wave sizing and timing for infinite mode
+- Context management across multiple parallel agents
+
+**Coordination Challenges:**
+
+- How to prevent duplicate concepts across parallel streams
+- Strategies for ensuring each agent produces genuinely unique output
+- Managing file naming and directory organization with concurrent writes
+- Quality control mechanisms for parallel outputs
+
+**Infinite Mode Optimization:**
+
+- Wave-based generation patterns for sustained output
+- Progressive sophistication strategies across multiple waves
+- Context capacity monitoring and graceful conclusion planning
+- Balancing speed of parallel generation with depth of innovation
+
+**Risk Mitigation:**
+
+- Handling agent failures and iteration reassignment
+- Ensuring coherent overall progression despite parallel execution
+- Managing context window limits across the entire system
+- Maintaining specification compliance across all parallel outputs
+
+Begin execution with deep analysis of these parallel coordination challenges and proceed systematically through each phase, leveraging Sub Agents for maximum creative output and efficiency.

package/claude-code/aiwf/en/.claude/commands/aiwf/aiwf_initialize.md

@@ -0,0 +1,134 @@
+# AIWF Framework Initialization
+
+Initialize the AIWF project management framework through an adaptive, interactive process.
+
+## Create a TODO with EXACTLY these items
+
+1. Scan and analyze the project
+2. Interactive confirmation with user
+3. Check for existing AIWF documents
+4. Guide document creation process
+5. Create first milestone for AIWF
+6. Generate project manifest
+7. Provide next steps
+
+## DETAILS on every TODO item
+
+### 1. Scan and analyze the project
+
+**Detect project characteristics:**
+
+- Check for package.json, requirements.txt, composer.json, etc.
+- Identify project type (Node.js, Python, PHP, etc.)
+- Scan overall project structure
+- Check if this is a new or existing project
+- Look for existing documentation (README, docs/, etc.)
+
+**Keep findings brief** - Just identify the essentials
+
+### 2. Interactive confirmation with user
+
+**Present findings conversationally:**
+
+```
+I found this to be a [project type] project named [detected name].
+Is this correct? Should I proceed with AIWF setup?
+```
+
+**Get user confirmation before continuing**
+
+### 3. Check for existing AIWF documents
+
+**Scan .aiwf/ directory for:**
+
+- Any documents in 01_PROJECT_DOCS/
+- Any milestones in 02_REQUIREMENTS/
+- Any existing sprints or tasks
+- Current manifest status
+
+**Interactive decision:**
+
+- If documents found: "I found existing documents: [list]. Should we work with these or extend them?"
+- If no documents: "No AIWF documents found yet. Do you have any existing project documentation you'd like to copy in before we continue?"
+
+**Allow user to:**
+
+- Use existing documents
+- Add new documents
+- Start fresh
+- Cancel to add documents manually first
+
+### 4. Guide document creation process
+
+**Based on user's choice:**
+
+**If starting fresh or extending:**
+
+- Perform deep analysis of the codebase
+- Identify key components and architecture patterns
+- Create draft ARCHITECTURE.md based on analysis
+- Use Q&A style to refine and complete:
+  - "What's the main purpose of this project?"
+  - "What are the key technical decisions?"
+  - "Any important constraints or requirements?"
+
+**If using existing docs:**
+
+- Import and adapt existing documentation
+- Fill in any AIWF-specific sections
+- Ensure compatibility with framework structure
+
+**Keep it conversational and adaptive**
+
+### 5. Create first milestone for AIWF
+
+**Determine appropriate first milestone:**
+
+- If new project: Start with setup/foundation milestone
+- If existing project: Identify current phase and create appropriate milestone
+
+**Interactive milestone creation:**
+
+- "Based on the project state, I suggest creating milestone: [name]"
+- "What would you like to focus on in this milestone?"
+- Create milestone structure with initial requirements
+- Keep scope realistic and focused
+
+### 6. Generate project manifest
+
+**Automatically generate manifest using:**
+
+- Information gathered during setup
+- Created/imported documentation
+- Current milestone details
+- Project metadata
+
+**No user interaction needed** - Just inform when complete
+
+### 7. Provide next steps
+
+**Customized guidance based on setup:**
+
+```
+✅ AIWF initialized for [project name]!
+
+Current setup:
+- Project type: [type]
+- Current milestone: [milestone]
+- Documents: [created/imported]
+
+Next steps:
+- Review your architecture: 01_PROJECT_DOCS/ARCHITECTURE.md
+- Check milestone requirements: 02_REQUIREMENTS/[milestone]/
+- Start first task: /project:aiwf:create_general_task
+
+Ready to begin development!
+```
+
+## ADAPTIVE PROCESS NOTES
+
+- **Stay conversational** - Ask questions naturally, not like a form
+- **Be smart** - Use AI to understand context and make intelligent suggestions
+- **Allow flexibility** - User can skip, cancel, or modify at any point
+- **Focus on value** - Only create what's useful for the specific project
+- **Keep it simple** - Don't overwhelm with options or details