aiwf 0.1.0 → 0.3.1

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

@@ -0,0 +1,160 @@
+# AIWF Language Switch
+
+A command that allows users to change the language settings of the AIWF framework.
+
+## Usage
+
+This command is used in the following cases:
+- When you want to change the current language setting to another language
+- When you want to check the current language setting status
+- When you want to resolve language detection issues
+
+## Parameters
+
+- `<language_code>` (optional): Language to switch to (`ko` or `en`)
+- Running without parameters displays the current language status
+
+## Execution Steps
+
+### 1. Check Current Language Status
+
+First, check the current language configuration status:
+
+```bash
+node -e "
+import('./language-utils.js').then(async ({ getLanguageStatus }) => {
+  const status = await getLanguageStatus();
+  console.log('=== AIWF Language Settings Status ===');
+  console.log('Detected language:', status.detectedLanguage);
+  console.log('Configured language:', status.configuredLanguage || 'None');
+  console.log('Effective language:', status.effectiveLanguage);
+  console.log('Auto detection:', status.autoDetect ? 'Enabled' : 'Disabled');
+  console.log('Fallback language:', status.fallbackLanguage);
+  console.log('Config file path:', status.configPath);
+  if (status.error) console.log('Error:', status.error);
+});
+"
+```
+
+### 2. Argument Analysis
+
+Check the `<$ARGUMENTS>` value and perform one of the following:
+
+- **No arguments**: Display current status only and exit
+- **Valid language code (`ko` or `en`)**: Switch to that language
+- **Invalid argument**: Display error message and usage guide
+
+### 3. Execute Language Switch
+
+If a valid language code is provided, switch the language:
+
+```bash
+node -e "
+import('./language-utils.js').then(async ({ switchLanguage }) => {
+  const targetLanguage = process.argv[1];
+  const result = await switchLanguage(targetLanguage);
+  
+  if (result.success) {
+    console.log('✅ Language switch successful!');
+    console.log('Previous language:', result.previousLanguage);
+    console.log('New language:', result.newLanguage);
+    console.log('Message:', result.message);
+  } else {
+    console.error('❌ Language switch failed:', result.error);
+    console.log('Message:', result.message);
+  }
+});
+" -- $ARGUMENTS
+```
+
+### 4. Post-Switch Validation
+
+Verify that the settings are properly applied after the language switch:
+
+```bash
+node -e "
+import('./language-utils.js').then(async ({ getLanguageStatus }) => {
+  const status = await getLanguageStatus();
+  console.log('\n=== Post-Switch Language Settings Status ===');
+  console.log('Current language:', status.effectiveLanguage);
+  console.log('Config file:', status.configuredLanguage ? 'Saved' : 'None');
+});
+"
+```
+
+### 5. Command Path Testing
+
+Test if command paths are properly resolved with the new language:
+
+```bash
+node -e "
+import('./language-utils.js').then(async ({ resolveCommandPath, detectLanguage }) => {
+  const currentLang = await detectLanguage();
+  const testCommands = ['aiwf_do_task', 'aiwf_commit', 'aiwf_initialize'];
+  
+  console.log('\n=== Command Path Testing ===');
+  console.log('Current language:', currentLang);
+  
+  for (const cmd of testCommands) {
+    const result = await resolveCommandPath(cmd);
+    if (result.path) {
+      console.log('✅', cmd, '->', result.path, result.fallback ? '(fallback)' : '(direct)');
+    } else {
+      console.log('❌', cmd, '-> Not found:', result.error);
+    }
+  }
+});
+"
+```
+
+## Output Format
+
+### Successful Language Switch
+```
+✅ Language switch successful!
+Previous language: en
+New language: ko
+Message: Language changed successfully
+
+=== Post-Switch Language Settings Status ===
+Current language: ko
+Config file: Saved
+
+=== Command Path Testing ===
+Current language: ko
+✅ aiwf_do_task -> claude-code/aiwf/ko/.claude/commands/aiwf/aiwf_do_task.md (direct)
+✅ aiwf_commit -> claude-code/aiwf/ko/.claude/commands/aiwf/aiwf_commit.md (direct)
+✅ aiwf_initialize -> claude-code/aiwf/ko/.claude/commands/aiwf/aiwf_initialize.md (direct)
+```
+
+### Status Check Only
+```
+=== AIWF Language Settings Status ===
+Detected language: ko
+Configured language: ko
+Effective language: ko
+Auto detection: Enabled
+Fallback language: en
+Config file path: .aiwf/config/language.json
+```
+
+### Error Occurred
+```
+❌ Language switch failed: Language not supported
+Message: Failed to change language
+
+Usage: /project:aiwf:switch_language [ko|en]
+Supported languages: ko (Korean), en (English)
+```
+
+## Important Notes
+
+1. **Config File Permissions**: Write permissions are required for the `.aiwf/config/` directory
+2. **Command File Existence**: Command files for the target language must exist
+3. **Project Root**: Can only be used in projects where AIWF has been initialized
+
+## Related Commands
+
+- `/project:aiwf:initialize` - Initialize AIWF project
+- `/project:aiwf:update_docs` - Update documentation (language-specific)
+- `/project:aiwf:help` - Help (displayed in current language)

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

@@ -0,0 +1,125 @@
+# Test Execution and Common Issue Resolution
+
+Follow these instructions from top to bottom.
+
+## Create a TODO with EXACTLY these 4 items
+
+1. Execute test suite
+2. Analyze results and identify issues
+3. Fix common problems if found
+4. Provide test summary
+
+---
+
+## 1 · Execute test suite
+
+### First, detect the project's test runner:
+
+1. **Python projects:**
+
+   - If `pyproject.toml` exists with `[tool.poetry]`: Try `poetry run pytest`
+   - If `setup.py` or `requirements.txt`: Try `pytest` or `python -m pytest`
+   - If custom test script exists (e.g., `run_tests.py`, `run_dev.py`): Use that
+   - Add common flags: `--tb=short` for pytest
+
+2. **JavaScript/TypeScript projects:**
+
+   - If `package.json` exists: Check "scripts" section for "test" command
+   - Common: `npm test`, `npm run test`, `yarn test`, `pnpm test`
+   - Framework specific: `jest`, `vitest`, `mocha`
+
+3. **Other languages:**
+   - Rust: `cargo test`
+   - Go: `go test ./...`
+   - Java: `mvn test` or `gradle test`
+   - Ruby: `bundle exec rspec` or `rake test`
+   - PHP: `composer test` or `phpunit`
+
+### Execute the detected test command:
+
+- RUN the appropriate test command
+- CAPTURE full output including any errors
+- NOTE execution time and test counts
+
+**If no test runner is found:** Report this to the user and ask for the correct test command.
+
+## 2 · Analyze results and identify issues
+
+Check for common issues in this order:
+
+### Language-specific issues:
+
+**Python:**
+
+- Missing **init**.py files (import errors, tests not discovered)
+- Import path problems
+- Fixture issues (pytest)
+- Virtual environment problems
+
+**JavaScript/TypeScript:**
+
+- Module resolution errors
+- Missing dependencies in node_modules
+- Jest/Vitest configuration issues
+- TypeScript compilation errors
+
+**Common across languages:**
+
+- Environment variable issues (missing config)
+- Database/external service connection errors
+- File path problems (absolute vs relative)
+- Permission issues
+
+## 3 · Fix common problems if found
+
+**ONLY** fix these specific issues automatically:\*\*
+
+### Python-specific fixes:
+
+- CREATE empty `__init__.py` files where needed
+- FIX simple import path issues
+- ADD missing test directory to Python path if needed
+
+### JavaScript/TypeScript fixes:
+
+- RUN `npm install` if node_modules missing
+- FIX simple module resolution in jest.config.js
+- CREATE missing test setup files
+
+### General fixes:
+
+- CREATE missing test directories
+- FIX file permissions if possible
+- IDENTIFY missing env vars and inform user
+
+**DO NOT** fix:
+
+- Actual test logic failures
+- Business logic bugs
+- Complex configuration issues
+- Database schema problems
+- External service dependencies
+
+## 4 · Provide test summary
+
+Create a brief summary:
+
+```
+Test Results:
+- Total: X tests
+- Passed: Y (Z%)
+- Failed: A
+- Skipped: B
+- Time: C seconds
+
+Issues Fixed:
+- [List any fixes applied]
+
+Issues Found (requires manual fix):
+- [List problems that need attention]
+
+Status: PASSING | FAILING | BLOCKED
+```
+
+**IMPORTANT:** Keep it concise. This command should be quick and focused on running tests, not detailed analysis.
+EOF < /dev/null

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

@@ -0,0 +1,198 @@
+# Testing Review - Top-Down Execution
+
+Perform a comprehensive, top-down project-level review focused on architecture, progress, and technical decisions.
+
+## Prerequisites Check
+
+**FIRST**, check if a testing strategy document exists:
+
+- CHECK for `.aiwf/01_PROJECT_DOCS/TESTING_STRATEGY.md`
+- If NOT found, inform the user: "No testing strategy document found. Would you like me to help create one, or proceed with a general test quality review?"
+- If user wants to proceed without strategy, adapt the review to focus on general test quality principles
+
+## Create a TODO with EXACTLY these 7 Items
+
+1. Load testing strategy document (or define review criteria)
+2. Analyze test implementation structure
+3. Evaluate test-to-code alignment
+4. Identify misaligned or unnecessary tests
+5. Assess critical functionality coverage
+6. Generate modification recommendations
+7. Create alignment report
+
+Follow step by step and adhere closely to the following instructions for each step.
+
+## DETAILS on every TODO item
+
+### 1. Load testing strategy document (or define review criteria)
+
+**Option A - Strategy document exists:**
+
+- LOAD `.aiwf/01_PROJECT_DOCS/TESTING_STRATEGY.md`
+- EXTRACT key principles and priorities
+- IDENTIFY what should and shouldn't be tested
+- NOTE coverage expectations and quality gates
+- UNDERSTAND the testing philosophy
+
+**Option B - No strategy document:**
+Use general best practices as review criteria:
+
+- Tests should focus on behavior, not implementation
+- Critical paths must have coverage
+- Tests should be maintainable and clear
+- Avoid over-testing simple getters/setters
+- Balance between coverage and maintenance burden
+
+**DOCUMENT** which approach is being used for this review.
+
+### 2. Analyze test implementation structure
+
+**EXAMINE** the current test codebase:
+
+- USE test.md command to run tests (@.claude/commands/aiwf/aiwf_test.md)
+- EXPLORE test directory structure and organization
+- IDENTIFY test categories and their purposes
+- CHECK test naming conventions and patterns
+- NOTE any test infrastructure or utilities
+
+**Focus on understanding what exists, not counting.**
+
+### 3. Evaluate test-to-code alignment
+
+**COMPARE** tests against actual implementation:
+
+- For each major component, check if tests match functionality
+- IDENTIFY tests that test implementation details vs behavior
+- FIND tests with excessive setup or mocking
+- LOCATE tests that break frequently on refactoring
+- CHECK if test complexity matches code complexity
+
+**Key question:** Do the tests validate what users care about?
+
+### 4. Identify misaligned or unnecessary tests
+
+**SEARCH** for tests that don't provide value:
+
+**If using strategy document:**
+
+- Tests for areas marked as "skip" in strategy
+- Tests outside the defined scope
+- Over-specified tests per strategy guidelines
+
+**If using general principles:**
+
+- Over-engineered tests for simple functionality
+- Tests that break on every refactor
+- Edge case tests for non-critical features
+- Tests with excessive mocking/setup
+- Performance tests without performance requirements
+
+**Create a list of specific tests to modify or remove.**
+
+### 5. Assess critical functionality coverage
+
+**VERIFY** that essential functionality has appropriate tests:
+
+**If using strategy document:**
+
+- CHECK coverage of high-priority areas defined in strategy
+- VERIFY strategy-specific requirements are tested
+
+**For all reviews:**
+
+- IDENTIFY gaps in critical path testing
+- CHECK authentication/authorization if applicable
+- VERIFY error handling for important operations
+- ENSURE data integrity tests exist where needed
+- CONFIRM integration points are tested
+
+**Note specific gaps that need addressing.**
+
+### 6. Generate modification recommendations
+
+**CREATE** specific, actionable recommendations:
+
+For each finding:
+
+- SPECIFY the test file and function
+- EXPLAIN why it needs modification
+- SUGGEST the specific change (remove, simplify, add)
+- PROVIDE example of the improved approach if helpful
+
+**Format:**
+
+```
+File: tests/test_example.py::test_function_name
+Issue: [What's wrong]
+Action: [What to do]
+Reason: [Why this aligns with strategy]
+```
+
+### 7. Create alignment report
+
+**GENERATE** a focused report on test-strategy alignment:
+
+- Get current timestamp using system date command
+- Create report in `.aiwf/10_STATE_OF_PROJECT/YYYY-MM-DD-HH-MM-test-alignment.md`
+
+**Report structure:**
+
+```markdown
+# Test-Strategy Alignment Review - [YYYY-MM-DD HH:MM]
+
+## Alignment Summary
+
+Overall alignment with testing strategy: [EXCELLENT | GOOD | NEEDS WORK | POOR]
+
+Key findings:
+
+- [Major finding about test suite health]
+- [Major finding about coverage]
+- [Major finding about maintenance burden]
+
+## Tests Requiring Modification
+
+### Remove (Over-engineered/Out of scope)
+
+[List specific tests with reasons]
+
+### Simplify (Too complex for purpose)
+
+[List specific tests with simplification approach]
+
+### Add (Critical gaps)
+
+[List specific missing tests for critical paths]
+
+## Recommended Actions
+
+### Immediate (Blocking issues)
+
+- [ ] [Specific action with file/test reference]
+
+### Short-term (Quality improvements)
+
+- [ ] [Specific action with file/test reference]
+
+### Long-term (Technical debt)
+
+- [ ] [Specific action with file/test reference]
+
+## Test Health Indicators
+
+- Tests align with code purpose: [YES | PARTIALLY | NO]
+- Critical paths covered: [YES | PARTIALLY | NO]
+- Maintenance burden reasonable: [YES | PARTIALLY | NO]
+- Tests support development velocity: [YES | PARTIALLY | NO]
+
+## Implementation Examples
+
+[If needed, show before/after examples of test improvements]
+
+## Next Review
+
+Recommended review in: [X weeks/sprints]
+Focus areas for next review: [Specific areas to monitor]
+```
+
+**IMPORTANT:** Focus on alignment and balance, not metrics. The goal is tests that serve the project's actual needs.

package/claude-code/aiwf/en/.claude/commands/aiwf/aiwf_tm-run-all-subtask.md

@@ -0,0 +1,206 @@
+# Intelligent Execution of All Tasks
+
+Arguments: $ARGUMENTS
+
+Intelligently analyzes and executes all project tasks (complete tasks or subtasks of specific tasks) in an optimized order.
+
+## Intelligent Analysis and Execution
+
+### Context Analysis
+
+Before execution, analyze the following elements:
+
+- **Task Dependencies**: Identify dependency relationships between tasks (parent-child, task-to-task)
+- **Task Complexity**: Assess difficulty level and estimated time for each task
+- **Current Status**: Identify in-progress tasks, blocked tasks, completed tasks
+- **User Patterns**: Previous task execution methods and preferences
+- **Project Priorities**: Importance from overall project perspective
+
+### Smart Execution Strategy
+
+Optimized execution based on context:
+
+**Dependency-Based Execution**:
+
+- Arrange tasks with correct dependencies
+- Identify parallelizable tasks
+- Prioritize dependency resolution for blocked tasks
+
+**Complexity-Based Execution**:
+
+- Prioritize simple tasks → Quick wins and momentum
+- Prioritize complex tasks → Focus when complex tasks are easier to handle
+
+**Time-Based Optimization**:
+
+- Morning: Prioritize complex tasks
+- Afternoon: Routine tasks or review tasks
+- Evening: Finish tasks or documentation
+
+**Priority-Based Execution**:
+
+- Prioritize tasks from overall project perspective
+- Prioritize tasks for milestone completion
+
+## Workflow
+
+### 1. Analyze the entire project
+
+```bash
+# Get all tasks
+task-master get-tasks --with-subtasks
+
+# Validate dependencies
+task-master validate-dependencies
+
+# Analyze complexity
+task-master complexity-report
+```
+
+### 2. Determine execution mode
+
+**Run the entire project**:
+
+- Target all pending tasks
+- Goal: Complete the entire project
+
+**Run specific tasks and their subtasks**:
+
+- Target specific tasks and their subtasks
+- Goal: Complete the specific task
+
+### 3. Determine intelligent execution order
+
+```bash
+# Find the next executable task
+task-master next
+
+# List all executable tasks (unblocked tasks)
+task-master get-tasks --status=pending --with-subtasks
+```
+
+### 4. Optimized task execution
+
+**Run the entire project loop**:
+
+```bash
+# Loop while there are executable tasks
+while [ "$(task-master next)" != "No tasks available" ]; do
+  CURRENT_TASK=$(task-master next --format=id)
+
+  # Display task information
+  echo "=== Executing: Task $CURRENT_TASK ==="
+  task-master show $CURRENT_TASK
+
+  # Check if there are subtasks
+  if task-master show $CURRENT_TASK | grep -q "subtasks"; then
+    echo "Starting subtasks..."
+    # Execute subtasks sequentially
+    for subtask in $(task-master show $CURRENT_TASK --subtasks-only --format=ids); do
+      echo "--- Executing subtask $subtask ---"
+      task-master show $subtask
+
+      # Actual implementation logic
+      echo "Implementing task..."
+
+      # Mark as completed
+      task-master set-status --id=$subtask --status=done
+      echo "Subtask $subtask completed"
+    done
+  else
+    # Run single task
+    echo "Running single task..."
+
+    # Actual implementation logic
+    echo "Implementing task..."
+  fi
+
+  # Mark task as completed
+  task-master set-status --id=$CURRENT_TASK --status=done
+  echo "Task $CURRENT_TASK completed"
+  echo ""
+done
+
+echo "All executable tasks completed!"
+```
+
+### 5. Track progress and learn
+
+- Record execution patterns
+- Learn from expected vs actual execution time
+- Collect efficiency metrics
+- Propose solutions for blocked
+
+### 6. Analyze post-completion status
+
+```bash
+# Check overall project status
+task-master get-tasks --status=all
+
+# Check blocked tasks
+task-master get-tasks --status=blocked,deferred
+
+# Analyze project progress
+echo "Analyzing project progress..."
+```
+
+## Learning Mode
+
+This command learns execution patterns:
+
+- **Optimize execution order**: Remember successful patterns
+- **Improve time prediction**: Collect actual execution time data
+- **Learn personal preferences**: Adapt to user's task style
+- **Improve efficiency**: Identify high-efficiency workflows
+- **Learn project patterns**: Identify optimal execution strategies for project types
+
+## Usage
+
+```bash
+# Run all tasks in the entire project
+/tm run-all-tasks
+
+# Run specific tasks and their subtasks
+/tm run-all-tasks <task-id>
+
+# Specify execution strategy
+/tm run-all-tasks --strategy=dependency   # Dependency-based
+/tm run-all-tasks --strategy=complexity   # Complexity-based
+/tm run-all-tasks --strategy=priority     # Priority-based
+/tm run-all-tasks --strategy=time         # Time-based optimization
+
+# Run tasks with specific status
+/tm run-all-tasks --status=pending        # pending tasks only
+/tm run-all-tasks --status=in-progress    # in-progress tasks only
+
+# Dry run mode (show plan without actual execution)
+/tm run-all-tasks --dry-run
+
+# Interactive mode (confirm each task before execution)
+/tm run-all-tasks --interactive
+```
+
+## Intelligent Features
+
+### Automatic pause points
+
+- Automatic pause on blocked tasks
+- Suggest dependency resolution
+- Propose alternative task paths
+
+### Progress prediction
+
+- Predict completion time based on remaining tasks
+- Analyze daily/weekly goal achievement
+- Predict project completion time
+
+- **All tasks completed** → Congratulate project completion + Suggest next project
+- **Some tasks blocked** → Suggest dependency resolution + Propose alternative task paths
+- **Complex tasks remaining** → Suggest rest + Propose task splitting
+- **Dependency issues** → Suggest dependency reconstruction
+
+### Smart batching
+
+- **Consider energy level**: Morning for complex tasks, afternoon for simple tasks
+- **Minimize context switching**: Group similar tasks for continuous execution
+- **Parallel processing opportunities**: Suggest concurrent execution of independent tasks