aiwf 0.1.0 → 0.3.0

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

@@ -0,0 +1,210 @@
+# 전체 작업 지능형 실행
+
+Arguments: $ARGUMENTS
+
+프로젝트의 모든 작업(전체 task 또는 특정 작업의 하위 작업)을 지능적으로 분석하고 최적화된 순서로 실행합니다.
+
+## 지능형 분석 및 실행
+
+### 컨텍스트 분석
+
+실행 전 다음 요소들을 분석합니다:
+
+- **작업 의존성**: 작업 간 의존 관계 파악 (상위-하위, 작업-작업 간)
+- **작업 복잡도**: 각 작업의 난이도와 예상 소요 시간
+- **현재 상태**: 진행 중인 작업, 블록된 작업, 완료된 작업 식별
+- **사용자 패턴**: 이전 작업 수행 방식과 선호도
+- **프로젝트 우선순위**: 전체 프로젝트 관점에서의 중요도
+
+### 스마트 실행 전략
+
+상황에 따른 최적화된 실행 방식:
+
+**의존성 기반 실행**:
+
+- 의존 관계가 있는 작업들을 올바른 순서로 배치
+- 병렬 처리 가능한 작업들 식별
+- 차단된 작업의 의존성 해결 우선
+
+**복잡도 기반 실행**:
+
+- 간단한 작업 먼저 → 빠른 성취감과 모멘텀
+- 복잡한 작업 먼저 → 집중력이 높을 때 어려운 작업 처리
+
+**시간대별 최적화**:
+
+- 오전: 복잡한 작업 우선
+- 오후: 루틴한 작업이나 리뷰 작업
+- 저녁: 마무리 작업이나 문서화
+
+**우선순위 기반 실행**:
+
+- 프로젝트 전체 관점에서 중요한 작업 우선
+- 마일스톤 달성에 필요한 작업 우선
+
+## 워크플로우
+
+### 1. 전체 프로젝트 분석
+
+```bash
+# 모든 작업 조회
+task-master get-tasks --with-subtasks
+
+# 의존성 검증
+task-master validate-dependencies
+
+# 복잡도 분석
+task-master complexity-report
+```
+
+### 2. 실행 모드 결정
+
+**전체 프로젝트 실행**:
+
+- 모든 pending 상태의 작업을 대상
+- 전체 프로젝트 완료를 목표
+
+**특정 작업 및 하위 작업 실행**:
+
+- 특정 작업과 그 하위 작업들을 대상
+- 해당 작업 완료를 목표
+
+### 3. 지능형 실행 순서 결정
+
+```bash
+# 다음 실행 가능한 작업 찾기
+task-master next
+
+# 실행 가능한 모든 작업 나열 (차단되지 않은 작업들)
+task-master get-tasks --status=pending --with-subtasks
+```
+
+### 4. 최적화된 작업 실행
+
+**전체 작업 실행 루프**:
+
+```bash
+# 실행 가능한 작업이 있는 동안 반복
+while [ "$(task-master next)" != "No tasks available" ]; do
+  CURRENT_TASK=$(task-master next --format=id)
+
+  # 작업 정보 표시
+  echo "=== 실행 중: Task $CURRENT_TASK ==="
+  task-master show $CURRENT_TASK
+
+  # 하위 작업이 있는지 확인
+  if task-master show $CURRENT_TASK | grep -q "subtasks"; then
+    echo "하위 작업 실행 시작..."
+    # 하위 작업들을 순차적으로 실행
+    for subtask in $(task-master show $CURRENT_TASK --subtasks-only --format=ids); do
+      echo "--- 하위 작업 $subtask 실행 ---"
+      task-master show $subtask
+
+      # 실제 구현 로직 수행
+      echo "작업 구현 중..."
+
+      # 완료 표시
+      task-master set-status --id=$subtask --status=done
+      echo "하위 작업 $subtask 완료"
+    done
+  else
+    # 단일 작업 실행
+    echo "단일 작업 실행 중..."
+
+    # 실제 구현 로직 수행
+    echo "작업 구현 중..."
+  fi
+
+  # 작업 완료 표시
+  task-master set-status --id=$CURRENT_TASK --status=done
+  echo "Task $CURRENT_TASK 완료"
+  echo ""
+done
+
+echo "모든 실행 가능한 작업이 완료되었습니다!"
+```
+
+### 5. 진행 상황 추적 및 학습
+
+- 실행 패턴 기록
+- 예상 vs 실제 소요 시간 학습
+- 효율성 메트릭 수집
+- 차단된 작업들에 대한 해결 방안 제안
+
+### 6. 완료 후 상태 분석
+
+```bash
+# 전체 프로젝트 상태 확인
+task-master get-tasks --status=all
+
+# 차단된 작업들 확인
+task-master get-tasks --status=blocked,deferred
+
+# 다음 마일스톤까지의 진행률
+echo "프로젝트 진행률 분석..."
+```
+
+## 학습 모드
+
+이 명령어는 실행 패턴을 학습합니다:
+
+- **실행 순서 최적화**: 성공적인 패턴 기억
+- **시간 예측 개선**: 실제 소요 시간 데이터 축적
+- **개인 선호도 학습**: 사용자의 작업 스타일 적응
+- **효율성 향상**: 생산성 높은 워크플로우 식별
+- **프로젝트 패턴 학습**: 프로젝트 유형별 최적 실행 전략
+
+## 사용법
+
+```bash
+# 전체 프로젝트의 모든 작업 실행
+/tm run-all-tasks
+
+# 특정 작업과 그 하위 작업들 실행
+/tm run-all-tasks <task-id>
+
+# 실행 전략 지정
+/tm run-all-tasks --strategy=dependency   # 의존성 우선
+/tm run-all-tasks --strategy=complexity   # 복잡도 우선
+/tm run-all-tasks --strategy=priority     # 우선순위 우선
+/tm run-all-tasks --strategy=time         # 시간대 최적화
+
+# 특정 상태의 작업만 실행
+/tm run-all-tasks --status=pending        # pending 작업만
+/tm run-all-tasks --status=in-progress    # 진행 중인 작업만
+
+# 드라이런 모드 (실제 실행 없이 계획만 표시)
+/tm run-all-tasks --dry-run
+
+# 대화형 모드 (각 작업 실행 전 확인)
+/tm run-all-tasks --interactive
+```
+
+## 지능형 기능
+
+### 자동 중단점
+
+- 차단된 작업 발견 시 자동 일시 정지
+- 의존성 해결 제안
+- 대안 작업 경로 제시
+
+### 진행률 예측
+
+- 남은 작업량 기반 완료 시간 예측
+- 일일/주간 목표 달성 가능성 분석
+- 프로젝트 전체 완료 예상 시점
+
+### 컨텍스트 기반 제안
+
+실행 완료 후 상황별 다음 액션:
+
+- **모든 작업 완료** → 프로젝트 완료 축하 + 다음 프로젝트 제안
+- **일부 작업 차단됨** → 차단 해제 방법 제안 + 대체 작업 제안
+- **복잡한 작업 남음** → 휴식 제안 + 작업 분할 제안
+- **의존성 문제** → 의존 관계 재구성 제안
+
+### 스마트 배치
+
+- **에너지 수준 고려**: 오전에는 복잡한 작업, 오후에는 단순한 작업
+- **컨텍스트 스위칭 최소화**: 유사한 작업들을 그룹핑하여 연속 실행
+- **병렬 처리 기회**: 독립적인 작업들의 동시 진행 제안

package/claude-code/aiwf/ko/.claude/commands/aiwf/aiwf_ultrathink_code_advanced.md

@@ -0,0 +1,460 @@
+# Ultra Think - 코드 심층사고 엔진 (/ultrathink_code_advanced 이 5000줄 클래스를 어떻게 분해할까?)
+
+Activate Claude's maximum cognitive depth for code architecture decisions, complex implementation challenges, and discovering elegant solutions at the intersection of theory and practice.
+
+## 🧠 Code Intelligence Framework
+
+### Phase 0: Context Loading & Analysis
+
+```yaml
+Initialize:
+  - Check for $ARGUMENTS presence
+  - If empty: STOP and request clarification
+  - Load current codebase context
+  - Analyze existing patterns and conventions
+  - Map dependency graph
+  - Identify technical debt zones
+  - Establish performance baselines
+  - Scan for anti-patterns
+```
+
+### ⚠️ Argument Validation
+
+```python
+if not $ARGUMENTS or $ARGUMENTS.strip() == "":
+    return """
+    🛑 **Ultra Think requires a specific problem or question to analyze.**
+
+    Please provide details about what you'd like me to think deeply about:
+
+    Examples:
+    - /ultrathink How should I refactor this authentication service?
+    - /ultrathink What's the best way to handle rate limiting in our API?
+    - /ultrathink Should we migrate from REST to GraphQL?
+    - /ultrathink How to optimize this O(n²) algorithm?
+
+    What specific code challenge would you like me to analyze?
+    """
+```
+
+## 🌀 Deep Code Reasoning Protocol
+
+### 1. **Problem Decomposition in Code Context**
+
+```typescript
+interface ProblemSpace {
+  // Surface Layer
+  symptom: "What error/issue is manifesting?";
+
+  // Code Layer
+  implementation: "What code structures are involved?";
+
+  // Architecture Layer
+  design: "What architectural decisions led here?";
+
+  // Principle Layer
+  paradigm: "What programming paradigms are at play?";
+
+  // Meta Layer
+  evolution: "How will this code need to evolve?";
+}
+```
+
+**Analytical Questions:**
+
+- What does the code want to be?
+- What patterns is it trying to express?
+- What constraints are real vs. assumed?
+- What would the ideal solution look like if we had no legacy?
+- What can we learn from how others solved this?
+
+### 2. **Multi-Paradigm Code Analysis**
+
+#### 🔍 Static Analysis Thinking
+
+```python
+def analyze_code_health():
+    return {
+        'complexity': cyclomatic_complexity_analysis(),
+        'coupling': dependency_coupling_matrix(),
+        'cohesion': module_cohesion_score(),
+        'duplication': code_duplication_patterns(),
+        'test_coverage': coverage_gap_analysis(),
+        'performance': big_o_complexity_map(),
+        'security': vulnerability_surface_analysis()
+    }
+```
+
+#### 🏗️ Architectural Reasoning
+
+- **Layered Architecture**: How do layers communicate?
+- **Domain Boundaries**: Where are the natural seams?
+- **Data Flow**: How does information propagate?
+- **State Management**: Where does truth live?
+- **Error Propagation**: How do failures cascade?
+
+#### 🧬 Pattern Mining
+
+```yaml
+Identify Patterns:
+  Creational:
+    - Factory patterns needed?
+    - Builder complexity warranted?
+    - Singleton anti-patterns?
+
+  Structural:
+    - Adapter opportunities?
+    - Facade simplifications?
+    - Composite hierarchies?
+
+  Behavioral:
+    - Observer decoupling?
+    - Strategy flexibility?
+    - Command pattern undo/redo?
+
+  Concurrent:
+    - Actor model applicable?
+    - Producer-consumer queues?
+    - Lock-free algorithms possible?
+```
+
+### 3. **Solution Space Exploration**
+
+#### 🎯 Implementation Strategies
+
+**Strategy 1: Incremental Refactoring**
+
+```javascript
+// Preserve existing behavior while improving structure
+const refactoringPath = [
+  "Extract method for clarity",
+  "Introduce parameter object",
+  "Replace conditional with polymorphism",
+  "Extract interface",
+  "Dependency injection",
+];
+```
+
+**Strategy 2: Parallel Implementation**
+
+```python
+# Build new alongside old
+class LegacyImplementation:
+    """Current working code"""
+    pass
+
+class NextGenImplementation:
+    """Clean reimplementation"""
+    pass
+
+class FeatureToggle:
+    """Gradual migration control"""
+    pass
+```
+
+**Strategy 3: Abstraction Layer**
+
+```rust
+// Introduce abstraction to hide complexity
+trait UnifiedInterface {
+    fn execute(&self) -> Result<Output, Error>;
+}
+
+impl UnifiedInterface for ComplexSystemA { }
+impl UnifiedInterface for ComplexSystemB { }
+```
+
+### 4. **Deep Technical Analysis**
+
+#### ⚡ Performance Optimization Paths
+
+```yaml
+CPU Bound:
+  - Algorithm complexity reduction
+  - Parallelization opportunities
+  - SIMD vectorization potential
+  - Cache-friendly data structures
+
+Memory Bound:
+  - Memory pooling strategies
+  - Lazy evaluation patterns
+  - Streaming processing
+  - Memory-mapped approaches
+
+I/O Bound:
+  - Async/await patterns
+  - Connection pooling
+  - Batch processing
+  - Caching strategies
+```
+
+#### 🔐 Security Reasoning
+
+```python
+security_analysis = {
+    'input_validation': boundary_check_completeness(),
+    'authentication': auth_flow_vulnerabilities(),
+    'authorization': permission_model_gaps(),
+    'data_protection': encryption_coverage(),
+    'injection_risks': sanitization_audit(),
+    'timing_attacks': constant_time_operations()
+}
+```
+
+#### 🧪 Testing Strategy Evolution
+
+```typescript
+interface TestingDimensions {
+  unit: "Pure function isolation";
+  integration: "Component interaction";
+  contract: "API boundary verification";
+  property: "Invariant maintenance";
+  fuzzing: "Edge case discovery";
+  mutation: "Test quality verification";
+  performance: "Regression prevention";
+}
+```
+
+### 5. **Code Quality Transcendence**
+
+#### 📐 Elegance Metrics
+
+- **Simplicity**: Can we remove code while adding functionality?
+- **Orthogonality**: Are concerns properly separated?
+- **Composability**: Do pieces combine naturally?
+- **Readability**: Would a new developer understand immediately?
+- **Extensibility**: How easy is adding new features?
+
+#### 🌊 Flow State Code
+
+```python
+# Code that feels natural to write and modify
+class FlowStateExample:
+    """
+    - Clear intent
+    - Natural naming
+    - Obvious structure
+    - Minimal cognitive load
+    - Self-documenting
+    """
+    def process(self, data: Data) -> Result:
+        validated = self.validate(data)
+        transformed = self.transform(validated)
+        return self.persist(transformed)
+```
+
+### 6. **Advanced Code Patterns**
+
+#### 🔄 Functional Composition
+
+```haskell
+-- Pure functions that compose naturally
+processData = validate >=> transform >=> persist
+  where
+    validate = ...
+    transform = ...
+    persist = ...
+```
+
+#### 🎭 Type-Level Programming
+
+```typescript
+// Encode business rules in type system
+type ValidatedUser<T> = T & { __validated: true };
+type AuthorizedUser<T> = T & { __authorized: true };
+
+function process<T>(user: ValidatedUser<AuthorizedUser<T>>) {
+  // Compiler ensures user is validated AND authorized
+}
+```
+
+#### 🌀 Reactive Patterns
+
+```javascript
+// Event-driven, responsive architecture
+const userEvents$ = new Subject();
+
+const processedUsers$ = userEvents$.pipe(
+  filter(isValid),
+  debounceTime(300),
+  switchMap(fetchUserDetails),
+  retry(3),
+  shareReplay(1)
+);
+```
+
+### 7. **Meta-Code Reasoning**
+
+#### 🤔 Code Philosophy Questions
+
+- Is this code expressing the domain naturally?
+- Are we fighting the language or flowing with it?
+- What would this look like in 10 lines? 100 lines? 1000 lines?
+- How would we explain this to a junior? To a senior? To a non-programmer?
+- What parts will definitely change? What parts are eternal?
+
+#### 🧩 Cross-Pollination
+
+```yaml
+Borrow From:
+  Gaming: "Entity-Component-System for flexibility"
+  Databases: "Query optimization techniques"
+  Compilers: "AST transformation patterns"
+  OS Design: "Scheduling algorithms"
+  Biology: "Self-healing systems"
+  Physics: "Conservation laws in state management"
+```
+
+### 8. **Implementation Roadmap**
+
+#### Phase 1: Immediate Wins
+
+```bash
+# Quick improvements with high impact
+- Extract constants
+- Add type hints
+- Improve naming
+- Add critical tests
+- Document intent
+```
+
+#### Phase 2: Structural Improvements
+
+```python
+# Refactoring for better architecture
+- Introduce interfaces
+- Separate concerns
+- Reduce coupling
+- Increase cohesion
+- Establish boundaries
+```
+
+#### Phase 3: Paradigm Shifts
+
+```rust
+// Fundamental reimagining
+- New architecture
+- Different paradigm
+- Modern patterns
+- Performance overhaul
+- Future-proofing
+```
+
+### 9. **Output Format**
+
+````markdown
+# Ultra Think Analysis: [Code Challenge]
+
+## 📊 Current State Assessment
+
+- Code health metrics
+- Technical debt quantification
+- Performance bottlenecks
+- Security vulnerabilities
+
+## 🎯 Core Problem Identification
+
+- Root cause (not symptoms)
+- Systemic issues
+- Architectural constraints
+
+## 💡 Solution Strategies
+
+### Option 1: [Minimal Refactor]
+
+```[language]
+// Code example
+```
+````
+
+- Effort: Low
+- Risk: Low
+- Impact: Medium
+
+### Option 2: [Architectural Shift]
+
+```[language]
+// Code example
+```
+
+- Effort: High
+- Risk: Medium
+- Impact: High
+
+### Option 3: [Innovation Path]
+
+```[language]
+// Code example
+```
+
+- Effort: Medium
+- Risk: High
+- Impact: Transformative
+
+## 🗺️ Implementation Plan
+
+1. Week 1: [Specific tasks]
+2. Week 2: [Specific tasks]
+3. Week 3: [Specific tasks]
+
+## ⚠️ Risk Mitigation
+
+- Rollback strategy
+- Feature flags
+- Monitoring plan
+- Performance benchmarks
+
+## 📈 Success Metrics
+
+- Performance improvement: X%
+- Code complexity reduction: Y%
+- Test coverage increase: Z%
+- Developer velocity impact
+
+## 🔮 Future Considerations
+
+- Scalability path
+- Maintenance strategy
+- Evolution roadmap
+
+````
+
+### 10. **Activation Examples**
+
+```bash
+# Architecture decision
+/ultrathink Should we use microservices or modular monolith for our e-commerce platform?
+
+# Performance optimization
+/ultrathink Our API response time is 800ms. How do we get it under 100ms?
+
+# Refactoring strategy
+/ultrathink This 5000-line class is unmaintainable. What's the best decomposition approach?
+
+# Technology choice
+/ultrathink React vs Vue vs Svelte for our new dashboard - considering our team's background?
+
+# Design pattern application
+/ultrathink How to implement undo/redo in our collaborative editor efficiently?
+
+# Debugging complex issues
+/ultrathink Random crashes in production but not in staging - systematic debugging approach?
+````
+
+## 🚀 Pro Tips
+
+1. **Provide Context**: Include relevant code snippets, architecture diagrams, or performance metrics
+2. **Specify Constraints**: Mention tech stack, team size, deadlines, backwards compatibility needs
+3. **Share History**: What has been tried before? What failed? Why?
+4. **Define Success**: What does "better" mean? Performance? Maintainability? Features?
+
+## 🎓 Learning Integration
+
+Ultra Think doesn't just solve - it teaches:
+
+- Why certain patterns emerge
+- When to apply specific solutions
+- How to think about similar problems
+- What to watch out for in the future
+
+Remember: The best code often comes from deeply understanding the problem space, not just applying patterns. Ultra Think helps you see the forest AND the trees, finding elegant solutions that feel inevitable in hindsight.