aiwf 0.3.0 → 0.3.2

package/docs/AI-WORKFLOW.ko.md

@@ -18,14 +18,15 @@ AIWF은 Claude Code, Gemini-CLI 와 더 효과적으로 작업하기 위해 만
 npx aiwf
 ```
 
-**다국어 지원**: 설치 시 영어와 한국어 중 선택할 수 있습니다. 선택한 언어에 따라 해당 언어의 명령어와 문서가 설치됩니다.
+**다국어 지원**: AIWF는 지능형 감지 및 선호도 저장 기능을 갖춘 포괄적인 언어 관리 시스템을 제공합니다. 설치 시 영어와 한국어 중 선택할 수 있으며, 나중에 내장된 언어 관리 명령어를 사용하여 언어를 전환할 수 있습니다.
 
 이것은 폴더 구조를 설정하고 프로젝트에 명령 파일을 설치/업데이트합니다. 기존 설치를 업데이트하는 데도 사용할 수 있으며, 명령 파일은 자동으로 백업됩니다.
 
 **설치 옵션**:
 
 - 대화형 설치: 언어 선택 후 설치
-- 강제 설치: `npx aiwf --force` (기본값: 영어)
+- 강제 설치: `npx aiwf --force` (자동 감지된 언어 사용)
+- 언어 관리: 설치 후 언어 전환을 위한 `aiwf-lang` 명령어 사용
 
 ### 2. 프로젝트 초기화하기
 
@@ -223,8 +224,14 @@ AIWF 워크플로를 구동하는 맞춤형 Claude Code 명령어:
   - 모든 마일스톤 실행: `yolo milestone-all`
   - Worktree 지원: `yolo sprint-all worktree`
   - 연속 실행과 상세 진행률 리포트 제공
+- `language_manager` - 포괄적 언어 관리 시스템:
+  - 현재 언어 설정 및 상태 확인
+  - 대화형 언어 전환
+  - 시스템 언어 선호도 자동 감지
 - 그 외 테스트, 리뷰, 프로젝트 관리용 명령어 다수
 
+**언어 지원**: 모든 명령어는 완전한 기능적 동등성과 표준화된 품질을 갖춘 영어 및 한국어 버전으로 제공됩니다.
+
 ## 디렉토리 구조
 
 ```plaintext

package/docs/AI-WORKFLOW.md

@@ -18,14 +18,15 @@ AIWF is a directory-based project management system I created to work more effec
 npx aiwf
 ```
 
-**Multi-language Support**: During installation, you can choose between English and Korean. The selected language determines which commands and documentation are installed.
+**Multi-language Support**: AIWF features a comprehensive language management system with intelligent detection and preference storage. During installation, you can choose between English and Korean, and later switch languages using the built-in language management commands.
 
 This sets up the folder structure and installs/updates command files in your project. You can also use it to update existing installations - command files are automatically backed up.
 
 **Installation Options**:
 
 - Interactive installation: Select language then install
-- Force installation: `npx aiwf --force` (defaults to English)
+- Force installation: `npx aiwf --force` (uses auto-detected language)
+- Language management: Use `aiwf-lang` commands for post-installation language switching
 
 ### 2. Initialize Your Project
 
@@ -223,8 +224,14 @@ Custom Claude Code commands that drive the AIWF workflow:
   - Execute all milestones: `yolo milestone-all`
   - Worktree support: `yolo sprint-all worktree`
   - Provides continuous execution and detailed progress reports
+- `language_manager` - Comprehensive language management system:
+  - Check current language settings and status
+  - Switch between languages interactively
+  - Auto-detect system language preferences
 - Many more commands for testing, review, and project management
 
+**Language Support**: All commands are available in both English and Korean versions with complete functional equivalence and standardized quality.
+
 ## Directory Structure
 
 ```plaintext

package/docs/AI_PERSONA_SYSTEM_DESIGN.md

@@ -0,0 +1,516 @@
+# AI Persona System Design Document
+
+## Overview
+
+The AI Persona System is designed to optimize Claude Code's behavior for different development tasks through specialized personas. This document outlines the architecture, implementation strategy, and integration approach.
+
+## Design Principles
+
+1. **Hybrid Activation**: Automatic detection with manual override capability
+2. **Context Preservation**: Maintain existing context while adding persona-specific rules
+3. **Predefined Personas**: Start with 5 core personas, extensible in future versions
+4. **Prompt Injection**: Integrate with Claude via system prompt modification
+5. **Tool Recommendations**: Suggest optimal tools without hard restrictions
+6. **Dynamic Token Management**: Adjust token allocation based on task complexity
+7. **Metrics-Driven**: Collect completion time and quality metrics for continuous improvement
+
+## Architecture
+
+### System Components
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│                        Claude Code                           │
+├─────────────────────────────────────────────────────────────┤
+│                    AI Persona System                         │
+├─────────────────┬───────────────────┬───────────────────────┤
+│  Persona Manager │  Context Engine   │  Metrics Collector   │
+├─────────────────┼───────────────────┼───────────────────────┤
+│ Auto Detector   │  Rule Processor   │  Quality Analyzer    │
+│ Manual Switch   │  Token Optimizer  │  Time Tracker        │
+│ State Manager   │  Prompt Builder   │  Report Generator    │
+└─────────────────┴───────────────────┴───────────────────────┘
+```
+
+### Core Personas
+
+| Persona | Primary Focus | Key Behaviors | Recommended Tools |
+|---------|---------------|---------------|-------------------|
+| **Architect** | System design | Big picture thinking, scalability focus | Glob, LS, MarkdownProcessor |
+| **Debugger** | Problem solving | Detailed analysis, systematic approach | Grep, Read, MemoryProfiler |
+| **Reviewer** | Code quality | Standards compliance, security awareness | Git commands, FileUtils |
+| **Documenter** | Documentation | Clear explanations, examples | MarkdownProcessor, TemplateEngine |
+| **Optimizer** | Performance | Efficiency focus, benchmarking | PerformanceBenchmark, TokenTracker |
+
+## Implementation Strategy
+
+### Phase 1: Core Infrastructure
+
+#### 1.1 Persona Manager Class
+
+```javascript
+class PersonaManager {
+  constructor(options = {}) {
+    this.currentPersona = null;
+    this.personaHistory = [];
+    this.autoDetectionEnabled = true;
+    this.metricsCollector = new MetricsCollector();
+    this.contextEngine = new ContextEngine();
+  }
+
+  async switchPersona(personaName, options = {}) {
+    // Validate persona
+    if (!this.isValidPersona(personaName)) {
+      throw new Error(`Invalid persona: ${personaName}`);
+    }
+
+    // Save current state
+    if (this.currentPersona) {
+      this.personaHistory.push({
+        persona: this.currentPersona,
+        timestamp: new Date(),
+        metrics: await this.collectMetrics()
+      });
+    }
+
+    // Load new persona
+    const persona = await this.loadPersona(personaName);
+    
+    // Apply context rules
+    await this.contextEngine.applyPersonaRules(persona);
+    
+    // Update state
+    this.currentPersona = persona;
+    
+    // Track switch event
+    this.metricsCollector.trackEvent('persona_switch', {
+      from: this.personaHistory[this.personaHistory.length - 1]?.persona?.name,
+      to: personaName,
+      trigger: options.manual ? 'manual' : 'auto'
+    });
+
+    return persona;
+  }
+
+  async detectOptimalPersona(taskContext) {
+    // Analyze task characteristics
+    const analysis = await this.analyzeTask(taskContext);
+    
+    // Score each persona
+    const scores = {};
+    for (const personaName of this.getAvailablePersonas()) {
+      scores[personaName] = await this.scorePersonaFit(personaName, analysis);
+    }
+    
+    // Return best match
+    return Object.entries(scores)
+      .sort(([,a], [,b]) => b - a)[0][0];
+  }
+}
+```
+
+#### 1.2 Context Engine
+
+```javascript
+class ContextEngine {
+  constructor() {
+    this.baseContext = null;
+    this.personaOverlay = null;
+    this.tokenOptimizer = new TokenOptimizer();
+  }
+
+  async applyPersonaRules(persona) {
+    // Preserve base context
+    if (!this.baseContext) {
+      this.baseContext = await this.captureCurrentContext();
+    }
+
+    // Build persona-specific overlay
+    this.personaOverlay = {
+      systemPrompt: this.buildSystemPrompt(persona),
+      priorityPatterns: persona.contextRules.priority,
+      exclusionPatterns: persona.contextRules.exclude,
+      focusAreas: persona.contextRules.focus,
+      keywords: persona.contextRules.keywords
+    };
+
+    // Optimize token usage
+    const optimizedContext = await this.tokenOptimizer.optimize(
+      this.baseContext,
+      this.personaOverlay,
+      persona.tokenAllocation
+    );
+
+    // Inject into Claude
+    await this.injectContext(optimizedContext);
+  }
+
+  buildSystemPrompt(persona) {
+    return `You are currently operating in ${persona.name} mode.
+
+Key behaviors:
+${persona.behaviors.map(b => `- ${b}`).join('\n')}
+
+Focus areas:
+${persona.focusAreas.map(f => `- ${f}`).join('\n')}
+
+Communication style: ${persona.communicationStyle}
+
+Recommended tools: ${persona.recommendedTools.join(', ')}`;
+  }
+}
+```
+
+### Phase 2: Auto-Detection System
+
+#### 2.1 Task Analyzer
+
+```javascript
+class TaskAnalyzer {
+  constructor() {
+    this.patterns = {
+      architecture: [
+        /design|architect|structure|system|scalab/i,
+        /interface|api|contract|schema/i
+      ],
+      debugging: [
+        /bug|error|fix|issue|problem|debug/i,
+        /trace|stack|exception|fail/i
+      ],
+      review: [
+        /review|audit|check|quality|standard/i,
+        /security|vulnerability|code.*smell/i
+      ],
+      documentation: [
+        /document|docs|readme|guide|tutorial/i,
+        /explain|describe|comment/i
+      ],
+      optimization: [
+        /optimiz|performance|speed|efficient/i,
+        /benchmark|profile|memory|token/i
+      ]
+    };
+  }
+
+  async analyzeTask(context) {
+    const analysis = {
+      command: context.command,
+      recentFiles: await this.getRecentFiles(),
+      keywords: this.extractKeywords(context),
+      gitContext: await this.getGitContext(),
+      errorState: await this.checkErrorState()
+    };
+
+    // Score each persona category
+    analysis.scores = {};
+    for (const [persona, patterns] of Object.entries(this.patterns)) {
+      analysis.scores[persona] = this.calculatePatternScore(
+        analysis,
+        patterns
+      );
+    }
+
+    return analysis;
+  }
+
+  calculatePatternScore(analysis, patterns) {
+    let score = 0;
+    
+    // Check command
+    patterns.forEach(pattern => {
+      if (pattern.test(analysis.command)) score += 10;
+    });
+
+    // Check keywords
+    analysis.keywords.forEach(keyword => {
+      patterns.forEach(pattern => {
+        if (pattern.test(keyword)) score += 5;
+      });
+    });
+
+    // Context bonuses
+    if (analysis.errorState.hasErrors && patterns.some(p => p.test('debug'))) {
+      score += 20;
+    }
+
+    return score;
+  }
+}
+```
+
+### Phase 3: Metrics Collection
+
+#### 3.1 Metrics Collector
+
+```javascript
+class MetricsCollector {
+  constructor() {
+    this.metrics = {
+      sessions: [],
+      personaPerformance: {},
+      taskOutcomes: []
+    };
+    this.currentSession = null;
+  }
+
+  startSession(persona, task) {
+    this.currentSession = {
+      id: generateId(),
+      persona: persona.name,
+      task: task,
+      startTime: Date.now(),
+      events: [],
+      tokenUsage: {
+        start: this.getCurrentTokenCount(),
+        contextSwitches: 0
+      }
+    };
+  }
+
+  trackEvent(eventType, data) {
+    if (!this.currentSession) return;
+    
+    this.currentSession.events.push({
+      type: eventType,
+      timestamp: Date.now(),
+      data
+    });
+
+    // Special handling for quality events
+    if (eventType === 'task_completed') {
+      this.calculateQualityMetrics(data);
+    }
+  }
+
+  async calculateQualityMetrics(completionData) {
+    const metrics = {
+      completionTime: Date.now() - this.currentSession.startTime,
+      tokenEfficiency: this.calculateTokenEfficiency(),
+      errorRate: await this.calculateErrorRate(),
+      codeQuality: await this.assessCodeQuality(completionData),
+      userSatisfaction: null // To be collected via feedback
+    };
+
+    this.currentSession.qualityMetrics = metrics;
+    this.updatePersonaPerformance(this.currentSession.persona, metrics);
+  }
+
+  calculateTokenEfficiency() {
+    const totalTokens = this.getCurrentTokenCount() - 
+                       this.currentSession.tokenUsage.start;
+    const taskComplexity = this.estimateTaskComplexity();
+    
+    return {
+      totalUsed: totalTokens,
+      efficiency: taskComplexity / totalTokens,
+      contextSwitches: this.currentSession.tokenUsage.contextSwitches
+    };
+  }
+
+  async generateReport(timeRange = 'week') {
+    const report = {
+      summary: {
+        totalSessions: this.metrics.sessions.length,
+        averageCompletionTime: this.calculateAverageTime(),
+        personaUsage: this.getPersonaUsageStats(),
+        qualityTrend: this.calculateQualityTrend()
+      },
+      personaAnalysis: this.analyzePersonaEffectiveness(),
+      recommendations: this.generateRecommendations()
+    };
+
+    return report;
+  }
+
+  analyzePersonaEffectiveness() {
+    const analysis = {};
+    
+    for (const [persona, data] of Object.entries(this.metrics.personaPerformance)) {
+      analysis[persona] = {
+        averageCompletionTime: average(data.completionTimes),
+        averageQualityScore: average(data.qualityScores),
+        tokenEfficiency: average(data.tokenEfficiencies),
+        bestUseCases: this.identifyBestUseCases(persona),
+        improvementAreas: this.identifyImprovementAreas(persona)
+      };
+    }
+
+    return analysis;
+  }
+}
+```
+
+### Phase 4: Integration Points
+
+#### 4.1 Claude Command Integration
+
+```javascript
+// In .claude/commands/aiwf/persona-commands.js
+
+export const personaCommands = {
+  '/project:aiwf:ai_persona:switch': async (personaName) => {
+    const manager = getPersonaManager();
+    await manager.switchPersona(personaName, { manual: true });
+    return `Switched to ${personaName} persona`;
+  },
+
+  '/project:aiwf:ai_persona:auto': async (enabled) => {
+    const manager = getPersonaManager();
+    manager.autoDetectionEnabled = enabled;
+    return `Auto-detection ${enabled ? 'enabled' : 'disabled'}`;
+  },
+
+  '/project:aiwf:ai_persona:status': async () => {
+    const manager = getPersonaManager();
+    const current = manager.currentPersona;
+    const metrics = await manager.metricsCollector.getCurrentSessionMetrics();
+    
+    return formatPersonaStatus(current, metrics);
+  },
+
+  '/project:aiwf:ai_persona:report': async (timeRange) => {
+    const manager = getPersonaManager();
+    const report = await manager.metricsCollector.generateReport(timeRange);
+    
+    return formatPersonaReport(report);
+  }
+};
+```
+
+#### 4.2 Git Hook Integration
+
+```bash
+#!/bin/bash
+# .git/hooks/post-commit
+
+# Detect if this was a bug fix
+if git log -1 --pretty=%B | grep -qiE "fix|bug|error"; then
+  # Suggest debugger persona for follow-up
+  echo "💡 Tip: Switch to debugger persona for thorough testing"
+  echo "   /project:aiwf:ai_persona:debugger"
+fi
+
+# Track commit patterns for persona optimization
+aiwf-persona track-commit
+```
+
+## Performance Optimization
+
+### Token Management Strategy
+
+1. **Base Allocation**: Each persona has a suggested token budget
+   - Architect: 30% context, 70% response
+   - Debugger: 50% context, 50% response  
+   - Reviewer: 40% context, 60% response
+   - Documenter: 20% context, 80% response
+   - Optimizer: 60% context, 40% response
+
+2. **Dynamic Adjustment**: Based on task complexity
+   - Simple tasks: -20% tokens
+   - Complex tasks: +30% tokens
+   - Multi-file tasks: +50% tokens
+
+3. **Context Pruning**: Remove irrelevant information
+   - Architect: Prune implementation details
+   - Debugger: Prune documentation
+   - Reviewer: Prune test files
+   - Documenter: Prune internal logic
+   - Optimizer: Prune comments
+
+## Testing Strategy
+
+### Unit Tests
+
+```javascript
+describe('PersonaManager', () => {
+  test('switches personas correctly', async () => {
+    const manager = new PersonaManager();
+    await manager.switchPersona('architect');
+    
+    expect(manager.currentPersona.name).toBe('architect');
+    expect(manager.personaHistory).toHaveLength(0);
+  });
+
+  test('detects optimal persona', async () => {
+    const manager = new PersonaManager();
+    const taskContext = {
+      command: 'debug the login error',
+      recentFiles: ['auth.js', 'login.test.js']
+    };
+    
+    const optimal = await manager.detectOptimalPersona(taskContext);
+    expect(optimal).toBe('debugger');
+  });
+});
+```
+
+### Integration Tests
+
+```javascript
+describe('Persona System Integration', () => {
+  test('full workflow with auto-detection', async () => {
+    // Initialize system
+    const system = await initializePersonaSystem();
+    
+    // Simulate task
+    const task = {
+      type: 'bug_fix',
+      description: 'Fix authentication timeout'
+    };
+    
+    // Start task
+    await system.startTask(task);
+    
+    // Verify persona selection
+    expect(system.currentPersona.name).toBe('debugger');
+    
+    // Complete task
+    const result = await system.completeTask({
+      success: true,
+      filesModified: ['auth.js']
+    });
+    
+    // Verify metrics collected
+    expect(result.metrics).toHaveProperty('completionTime');
+    expect(result.metrics).toHaveProperty('tokenEfficiency');
+  });
+});
+```
+
+## Rollout Plan
+
+### Phase 1: Beta (Week 1-2)
+- Core PersonaManager implementation
+- Manual switching only
+- Basic metrics collection
+
+### Phase 2: Auto-Detection (Week 3-4)
+- Task analyzer implementation
+- Auto-detection with manual override
+- Enhanced context engine
+
+### Phase 3: Metrics & Optimization (Week 5-6)
+- Full metrics collection
+- Performance reports
+- Token optimization
+
+### Phase 4: Production (Week 7+)
+- Public release
+- User feedback collection
+- Continuous improvement
+
+## Success Metrics
+
+1. **Adoption Rate**: >70% of users actively using personas
+2. **Task Completion Time**: 20% reduction on average
+3. **Token Efficiency**: 30% improvement
+4. **User Satisfaction**: >4.5/5 rating
+5. **Auto-Detection Accuracy**: >85% correct persona selection
+
+## Future Enhancements
+
+1. **Custom Personas**: User-defined personas
+2. **Team Personas**: Shared team configurations
+3. **Learning System**: ML-based persona optimization
+4. **IDE Integration**: Direct VS Code/Cursor integration
+5. **Persona Marketplace**: Community-shared personas