moai-adk 0.4.5__py3-none-any.whl → 0.20.1__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-lang-typescript/examples.md

@@ -0,0 +1,29 @@
+# moai-lang-typescript - Working Examples
+
+_Last updated: 2025-10-22_
+
+## Example 1: Basic Setup
+
+```bash
+# Setup commands
+# ...
+```
+
+## Example 2: TDD Workflow
+
+```bash
+# RED: Write failing test
+# GREEN: Implement feature
+# REFACTOR: Improve code
+```
+
+## Example 3: Quality Gate
+
+```bash
+# Run quality checks
+# Verify coverage ≥85%
+```
+
+---
+
+_For more examples, see SKILL.md reference section_

moai_adk/templates/.claude/skills/moai-lang-typescript/reference.md

@@ -0,0 +1,34 @@
+# moai-lang-typescript - CLI Reference
+
+_Last updated: 2025-10-22_
+
+## Quick Reference
+
+### Installation
+
+```bash
+# Installation commands
+```
+
+### Common Commands
+
+```bash
+# Test
+# Lint
+# Format
+# Build
+```
+
+## Tool Versions (2025-10-22)
+
+- **TypeScript**: 5.7.2
+- **Vitest**: 2.1.0
+- **Biome**: 1.9.4
+- **Bun**: 1.1.0
+- **pnpm**: 9.14.2
+- **React**: 19.0.0
+- **Next.js**: 15.1.0
+
+---
+
+_For detailed usage, see SKILL.md_

moai_adk/templates/.claude/skills/moai-learning-optimizer/SKILL.md

@@ -0,0 +1,575 @@
+---
+name: moai-learning-optimizer
+version: 1.0.0
+created: 2025-11-05
+updated: 2025-11-05
+status: active
+description: Intelligent learning system optimizer that analyzes session patterns, identifies improvement opportunities, and continuously enhances Alfred's performance through adaptive learning and knowledge optimization. Use when optimizing Alfred's behavior, analyzing session patterns, improving system performance, or when implementing adaptive learning capabilities.
+keywords: [learning-system, session-analysis, performance-optimization, adaptive-learning, pattern-recognition, knowledge-optimization]
+allowed-tools:
+  - Read
+  - Glob
+  - Grep
+  - Bash
+  - Write
+---
+
+# Learning System Optimizer
+
+## Skill Metadata
+
+| Field | Value |
+| ----- | ----- |
+| Version | 1.0.0 |
+| Tier | Alfred (Learning System) |
+| Auto-load | During session analysis or on demand |
+| Purpose | Optimize Alfred performance through adaptive learning |
+
+---
+
+## What It Does
+
+Intelligent learning system optimizer that analyzes Alfred's session patterns, identifies improvement opportunities, and continuously enhances performance through adaptive learning and knowledge optimization. Learns from user interactions to provide increasingly relevant and efficient assistance.
+
+**Core capabilities**:
+- ✅ Session pattern analysis and behavior learning
+- ✅ Performance optimization based on usage patterns
+- ✅ Adaptive skill selection and invocation timing
+- ✅ Knowledge gap identification and filling
+- ✅ User preference learning and personalization
+- ✅ System performance monitoring and tuning
+- ✅ Predictive assistance and proactive recommendations
+- ✅ Continuous improvement through feedback integration
+
+---
+
+## When to Use
+
+- ✅ When optimizing Alfred's performance and behavior
+- ✅ During session analysis and pattern discovery
+- ✅ When implementing adaptive learning capabilities
+- ✅ For system performance monitoring and tuning
+- ✅ When personalizing Alfred's responses and recommendations
+- ✅ During troubleshooting and performance issues
+- ✅ For continuous system improvement and optimization
+
+---
+
+## Learning Analytics Engine
+
+### 1. Session Pattern Analysis
+```python
+def analyze_session_patterns():
+    """Analyze Alfred session patterns for optimization opportunities"""
+    session_metrics = {
+        "session_duration": measure_session_duration(),
+        "tool_usage_patterns": analyze_tool_usage(),
+        "skill_invocation_patterns": analyze_skill_usage(),
+        "user_interaction_patterns": analyze_user_interactions(),
+        "success_rates": calculate_success_rates(),
+        "performance_bottlenecks": identify_bottlenecks(),
+        "user_satisfaction": measure_user_satisfaction()
+    }
+
+    # Pattern recognition
+    patterns = {
+        "peak_usage_times": identify_peak_usage_times(session_metrics),
+        "preferred_tools": identify_preferred_tools(session_metrics),
+        "skill_effectiveness": measure_skill_effectiveness(session_metrics),
+        "workflow_optimization": identify_workflow_optimizations(session_metrics)
+    }
+
+    return {
+        "metrics": session_metrics,
+        "patterns": patterns,
+        "recommendations": generate_learning_recommendations(patterns)
+    }
+```
+
+### 2. Adaptive Learning System
+```python
+class AdaptiveLearningSystem:
+    """Adaptive learning system for continuous improvement"""
+
+    def __init__(self):
+        self.knowledge_base = load_knowledge_base()
+        self.user_preferences = load_user_preferences()
+        self.performance_history = load_performance_history()
+        self.learning_rate = 0.1
+
+    def learn_from_session(self, session_data):
+        """Learn from completed session"""
+        # Extract learning signals
+        signals = extract_learning_signals(session_data)
+
+        # Update knowledge base
+        self.update_knowledge(signals)
+
+        # Adjust user preferences
+        self.adjust_preferences(signals)
+
+        # Optimize performance parameters
+        self.optimize_parameters(signals)
+
+        # Save learning updates
+        self.save_learning_state()
+
+    def predict_needs(self, context):
+        """Predict user needs based on learned patterns"""
+        predictions = {
+            "likely_tools": predict_tool_usage(context),
+            "optimal_skills": predict_skill_selection(context),
+            "potential_issues": anticipate_problems(context),
+            "recommended_actions": suggest_actions(context)
+        }
+
+        return predictions
+
+    def adapt_responses(self, user_feedback):
+        """Adapt response patterns based on user feedback"""
+        # Analyze feedback patterns
+        feedback_analysis = analyze_user_feedback(user_feedback)
+
+        # Adjust response strategies
+        self.adjust_response_strategies(feedback_analysis)
+
+        # Update communication preferences
+        self.update_communication_preferences(feedback_analysis)
+
+        # Refine assistance approach
+        self.refine_assistance_approach(feedback_analysis)
+```
+
+### 3. Performance Optimization Engine
+```python
+def optimize_alfred_performance():
+    """Optimize Alfred's performance based on learning data"""
+    optimization_areas = {
+        "skill_loading": optimize_skill_loading(),
+        "response_time": optimize_response_time(),
+        "context_utilization": optimize_context_usage(),
+        "knowledge_retrieval": optimize_knowledge_retrieval(),
+        "tool_selection": optimize_tool_selection(),
+        "workflow_efficiency": optimize_workflow_efficiency()
+    }
+
+    # Generate optimization plan
+    optimization_plan = {
+        "current_performance": measure_current_performance(),
+        "target_performance": set_performance_targets(),
+        "optimization_strategies": identify_optimization_strategies(),
+        "implementation_priority": prioritize_optimizations(),
+        "expected_improvements": estimate_improvements()
+    }
+
+    return optimization_plan
+```
+
+---
+
+## Knowledge Management
+
+### 1. Knowledge Gap Analysis
+```python
+def analyze_knowledge_gaps():
+    """Identify gaps in Alfred's knowledge and capabilities"""
+    gap_analysis = {
+        "missing_knowledge": identify_missing_knowledge(),
+        "outdated_information": identify_outdated_info(),
+        "user_unmet_needs": identify_unmet_needs(),
+        "skill_deficiencies": identify_skill_deficiencies(),
+        "context_limitations": identify_context_limitations()
+    }
+
+    # Prioritize gaps for learning
+    prioritized_gaps = prioritize_knowledge_gaps(gap_analysis)
+
+    # Generate learning plan
+    learning_plan = {
+        "immediate_needs": prioritized_gaps["high_priority"],
+        "medium_term": prioritized_gaps["medium_priority"],
+        "long_term": prioritized_gaps["low_priority"],
+        "learning_resources": identify_learning_resources(),
+        "implementation_strategy": create_learning_strategy()
+    }
+
+    return learning_plan
+```
+
+### 2. Knowledge Integration
+```python
+def integrate_new_knowledge(knowledge_items):
+    """Integrate new knowledge into Alfred's system"""
+    integration_process = {
+        "validation": validate_knowledge(knowledge_items),
+        "categorization": categorize_knowledge(knowledge_items),
+        "indexing": index_knowledge(knowledge_items),
+        "linking": link_knowledge_to_existing(knowledge_items),
+        "testing": test_knowledge_integration(knowledge_items),
+        "deployment": deploy_knowledge_updates(knowledge_items)
+    }
+
+    for step, process in integration_process.items():
+        result = execute_integration_step(step, process)
+        if not result.success:
+            handle_integration_failure(step, result.error)
+            return False
+
+    return True
+```
+
+### 3. Knowledge Quality Management
+```python
+def maintain_knowledge_quality():
+    """Maintain and improve knowledge quality"""
+    quality_metrics = {
+        "accuracy": measure_knowledge_accuracy(),
+        "relevance": measure_knowledge_relevance(),
+        "completeness": measure_knowledge_completeness(),
+        "consistency": measure_knowledge_consistency(),
+        "freshness": measure_knowledge_freshness()
+    }
+
+    quality_issues = identify_quality_issues(quality_metrics)
+
+    if quality_issues:
+        quality_improvement_plan = create_quality_improvement_plan(quality_issues)
+        execute_quality_improvements(quality_improvement_plan)
+
+    return quality_metrics
+```
+
+---
+
+## User Personalization
+
+### 1. Preference Learning
+```python
+def learn_user_preferences():
+    """Learn and adapt to user preferences"""
+    preference_data = {
+        "communication_style": analyze_communication_preferences(),
+        "detail_level_preference": analyze_detail_preferences(),
+        "tool_preferences": analyze_tool_preferences(),
+        "workflow_patterns": analyze_workflow_patterns(),
+        "response_timing": analyze_response_timing_preferences(),
+        "error_handling": analyze_error_handling_preferences()
+    }
+
+    # Build user profile
+    user_profile = build_user_profile(preference_data)
+
+    # Personalize Alfred behavior
+    personalize_alfred_behavior(user_profile)
+
+    return user_profile
+```
+
+### 2. Adaptive Assistance
+```python
+class AdaptiveAssistance:
+    """Adaptive assistance system based on user patterns"""
+
+    def __init__(self):
+        self.user_profile = load_user_profile()
+        self.assistance_strategies = load_assistance_strategies()
+
+    def adapt_assistance_level(self, context):
+        """Adapt assistance level based on context and user profile"""
+        assistance_level = {
+            "proactive_suggestions": should_be_proactive(context),
+            "detail_provided": determine_detail_level(context),
+            "intervention_points": identify_intervention_points(context),
+            "explanation_style": choose_explanation_style(context)
+        }
+
+        return assistance_level
+
+    def personalize_responses(self, base_response, context):
+        """Personalize responses based on user preferences"""
+        personalized_response = {
+            "content": adapt_content(base_response, self.user_profile),
+            "tone": adapt_tone(base_response, self.user_profile),
+            "format": adapt_format(base_response, self.user_profile),
+            "timing": adapt_timing(base_response, context, self.user_profile)
+        }
+
+        return personalized_response
+```
+
+### 3. Experience Optimization
+```python
+def optimize_user_experience():
+    """Optimize overall user experience based on learning data"""
+    experience_metrics = {
+        "response_satisfaction": measure_response_satisfaction(),
+        "task_completion_efficiency": measure_task_efficiency(),
+        "learning_curve_progress": measure_learning_progress(),
+        "error_recovery_time": measure_error_recovery(),
+        "engagement_level": measure_engagement_level()
+    }
+
+    # Identify improvement opportunities
+    improvements = identify_experience_improvements(experience_metrics)
+
+    # Create optimization plan
+    optimization_plan = {
+        "current_state": experience_metrics,
+        "target_state": set_experience_targets(),
+        "improvements": improvements,
+        "implementation_timeline": create_implementation_timeline(),
+        "success_metrics": define_success_metrics()
+    }
+
+    return optimization_plan
+```
+
+---
+
+## Predictive Analytics
+
+### 1. Behavior Prediction
+```python
+def predict_user_behavior(context):
+    """Predict user behavior and needs"""
+    behavioral_patterns = load_behavioral_patterns()
+    current_context = extract_context_features(context)
+
+    predictions = {
+        "likely_next_actions": predict_next_actions(current_context, behavioral_patterns),
+        "potential_issues": anticipate_issues(current_context, behavioral_patterns),
+        "optimal_interventions": suggest_interventions(current_context, behavioral_patterns),
+        "resource_needs": predict_resource_needs(current_context, behavioral_patterns)
+    }
+
+    return predictions
+```
+
+### 2. Performance Prediction
+```python
+def predict_system_performance(task_context):
+    """Predict system performance for given task"""
+    performance_history = load_performance_history()
+    task_features = extract_task_features(task_context)
+
+    predictions = {
+        "expected_duration": predict_task_duration(task_features, performance_history),
+        "likely_bottlenecks": predict_bottlenecks(task_features, performance_history),
+        "resource_requirements": predict_resource_needs(task_features, performance_history),
+        "success_probability": predict_success_probability(task_features, performance_history)
+    }
+
+    return predictions
+```
+
+### 3. Optimization Opportunities
+```python
+def identify_optimization_opportunities():
+    """Identify opportunities for system optimization"""
+    system_data = collect_system_data()
+    performance_data = collect_performance_data()
+    user_data = collect_user_data()
+
+    opportunities = {
+        "skill_optimization": identify_skill_optimizations(system_data),
+        "workflow_improvements": identify_workflow_improvements(user_data),
+        "performance_tuning": identify_performance_tunings(performance_data),
+        "knowledge_enhancement": identify_knowledge_opportunities(system_data, user_data)
+    }
+
+    # Prioritize opportunities
+    prioritized_opportunities = prioritize_optimization_opportunities(opportunities)
+
+    return prioritized_opportunities
+```
+
+---
+
+## Continuous Improvement
+
+### 1. Feedback Integration
+```python
+def integrate_user_feedback(feedback_data):
+    """Integrate user feedback for continuous improvement"""
+    feedback_analysis = {
+        "satisfaction_trends": analyze_satisfaction_trends(feedback_data),
+        "common_issues": identify_common_issues(feedback_data),
+        "improvement_suggestions": extract_improvement_suggestions(feedback_data),
+        "success_patterns": identify_success_patterns(feedback_data)
+    }
+
+    # Update system based on feedback
+    system_updates = {
+        "response_improvements": improve_responses(feedback_analysis),
+        "workflow_optimizations": optimize_workflows(feedback_analysis),
+        "knowledge_updates": update_knowledge(feedback_analysis),
+        "performance_tuning": tune_performance(feedback_analysis)
+    }
+
+    return system_updates
+```
+
+### 2. Learning Loop Management
+```python
+class LearningLoop:
+    """Manage continuous learning loop"""
+
+    def __init__(self):
+        self.learning_cycle = 0
+        self.performance_history = []
+        self.improvement_tracker = ImprovementTracker()
+
+    def execute_learning_cycle(self):
+        """Execute one complete learning cycle"""
+        # 1. Collect data
+        cycle_data = collect_cycle_data()
+
+        # 2. Analyze patterns
+        patterns = analyze_patterns(cycle_data)
+
+        # 3. Generate insights
+        insights = generate_insights(patterns)
+
+        # 4. Implement improvements
+        improvements = implement_improvements(insights)
+
+        # 5. Validate results
+        validation = validate_improvements(improvements)
+
+        # 6. Update learning state
+        self.update_learning_state(cycle_data, insights, improvements, validation)
+
+        self.learning_cycle += 1
+
+        return {
+            "cycle": self.learning_cycle,
+            "data": cycle_data,
+            "insights": insights,
+            "improvements": improvements,
+            "validation": validation
+        }
+```
+
+### 3. System Evolution
+```python
+def evolve_system_capabilities():
+    """Evolve system capabilities based on learning"""
+    evolution_plan = {
+        "current_capabilities": assess_current_capabilities(),
+        "future_requirements": anticipate_future_requirements(),
+        "capability_gaps": identify_capability_gaps(),
+        "evolution_roadmap": create_evolution_roadmap(),
+        "resource_needs": assess_resource_needs()
+    }
+
+    # Implement evolution steps
+    for evolution_step in evolution_plan["evolution_roadmap"]:
+        implement_evolution_step(evolution_step)
+        validate_evolution_result(evolution_step)
+
+    return evolution_plan
+```
+
+---
+
+## Integration Examples
+
+### Example 1: Session-Based Learning
+```python
+def learn_from_current_session():
+    """Learn from the current Alfred session"""
+    Skill("moai-learning-optimizer")
+
+    session_data = collect_current_session_data()
+    learning_analysis = analyze_session_patterns()
+
+    # Update user preferences
+    update_preferences(learning_analysis)
+
+    # Optimize performance
+    optimize_performance(learning_analysis)
+
+    # Identify improvement opportunities
+    improvements = identify_improvement_opportunities()
+
+    display_learning_summary(learning_analysis, improvements)
+```
+
+### Example 2: Predictive Assistance
+```python
+def provide_predictive_assistance():
+    """Provide predictive assistance based on learned patterns"""
+    Skill("moai-learning-optimizer")
+
+    current_context = get_current_context()
+    predictions = predict_user_behavior(current_context)
+
+    # Offer proactive assistance
+    if predictions["likely_next_actions"]:
+        suggest_next_steps(predictions["likely_next_actions"])
+
+    # Prevent potential issues
+    if predictions["potential_issues"]:
+        provide_preventive_guidance(predictions["potential_issues"])
+```
+
+### Example 3: Performance Optimization
+```python
+def optimize_system_performance():
+    """Optimize Alfred's performance based on learning data"""
+    Skill("moai-learning-optimizer")
+
+    optimization_plan = optimize_alfred_performance()
+
+    # Implement high-priority optimizations
+    for optimization in optimization_plan["high_priority"]:
+        implement_optimization(optimization)
+
+    # Measure improvements
+    improvements = measure_performance_improvements()
+
+    display_optimization_results(optimizations, improvements)
+```
+
+---
+
+## Usage Examples
+
+### Example 1: Learning Analysis
+```python
+# User wants to understand Alfred's learning progress
+Skill("moai-learning-optimizer")
+
+learning_report = generate_learning_report()
+display_learning_dashboard(learning_report)
+
+if learning_report["improvement_opportunities"]:
+    suggest_improvements(learning_report["improvement_opportunities"])
+```
+
+### Example 2: Personalization Setup
+```python
+# User wants to personalize Alfred's behavior
+Skill("moai-learning-optimizer")
+
+preferences = learn_user_preferences()
+personalization_plan = create_personalization_plan(preferences)
+
+apply_personalization(personalization_plan)
+```
+
+### Example 3: System Evolution
+```python
+# User wants to evolve Alfred's capabilities
+Skill("moai-learning-optimizer")
+
+evolution_plan = evolve_system_capabilities()
+display_evolution_roadmap(evolution_plan)
+
+if confirm_evolution(evolution_plan):
+    execute_evolution(evolution_plan)
+```
+
+---
+
+**End of Skill** | Intelligent learning system for continuous Alfred optimization and adaptation

moai_adk/templates/.claude/skills/moai-project-batch-questions/README.md

@@ -0,0 +1,50 @@
+# moai-project-batch-questions
+
+A skill for standardizing AskUserQuestion patterns and providing reusable question templates with batch optimization for the MoAI-ADK project.
+
+## Files
+
+- **SKILL.md** - Main skill documentation (304 lines)
+- **examples.md** - Real-world usage examples (417 lines)  
+- **reference.md** - Complete API reference (704 lines)
+- **README.md** - This file
+
+## Key Features
+
+- **60% interaction reduction** through strategic question batching
+- **Multi-language support** (Korean, English, Japanese, Chinese)
+- **Reusable templates** for common scenarios
+- **Built-in validation** and error handling
+- **Token-efficient** question design
+
+## Quick Start
+
+```typescript
+// Use language selection batch
+const result = await executeBatchTemplate(LANGUAGE_BATCH_TEMPLATE);
+
+// Use team mode batch (conditional)
+if (isTeamMode()) {
+  const teamResult = await executeBatchTemplate(TEAM_MODE_BATCH_TEMPLATE);
+}
+```
+
+## Integration
+
+- **Alfred Commands**: Use in `/alfred:0-project` and other commands
+- **Sub-agents**: Integrate with project-manager, spec-builder, etc.
+- **Configuration**: Save responses to `.moai/config.json`
+
+## Performance
+
+| Template | Traditional | Batch | Reduction |
+|----------|-------------|-------|-----------|
+| Language Selection | 3 interactions | 1 interaction | 66% |
+| Team Mode Settings | 2 interactions | 1 interaction | 50% |
+| Domain Selection | 5+ questions | 1 interaction | 80%+ |
+
+---
+
+**Created**: 2025-11-05  
+**Version**: 1.0.0  
+**Total Lines**: 1,425 across all files