aiwf 0.3.7 → 0.3.12

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

@@ -1,160 +0,0 @@
-# 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

@@ -1,125 +0,0 @@
-# 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

@@ -1,198 +0,0 @@
-# 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

@@ -1,206 +0,0 @@
-# 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