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

moai_adk/templates/.claude/skills/moai-alfred-clone-pattern/README.md

@@ -0,0 +1,162 @@
+# Alfred Clone Pattern Skill
+
+## Overview
+
+The **Clone Pattern** skill enables Alfred to create autonomous clones of itself for handling complex multi-step tasks that benefit from full project context and parallel processing capabilities. This pattern is ideal for large-scale operations where domain-specific expertise isn't required but comprehensive project understanding is crucial.
+
+## When to Use Clone Pattern
+
+**Perfect for:**
+- Large-scale migrations (5+ steps OR 100+ files affected)
+- Parallel exploration/evaluation tasks
+- Complex architecture restructuring
+- High uncertainty tasks requiring autonomous decision-making
+- Tasks that benefit from accumulated learning across similar operations
+
+**Use Cases:**
+- Migrating project versions (v0.14.0 → v0.15.2)
+- Refactoring across many files (100+ import changes)
+- Simultaneous evaluation of multiple approaches
+- Complex dependency management across entire codebase
+
+## Key Benefits
+
+1. **Full Project Context**: Unlike domain specialists, clones maintain complete project understanding
+2. **Maximum Autonomy**: Goal-oriented execution with independent decision-making
+3. **Parallel Processing**: Multiple clones can work simultaneously on different aspects
+4. **Self-Learning**: Accumulated experience improves future similar tasks
+5. **Memory Preservation**: Learnings saved for future reference
+
+## Core Architecture
+
+### Master-Clone Pattern
+```
+Main Alfred Session
+    ↓
+Task Analysis & Classification
+    ↓
+Clone Creation (if conditions met)
+    ↓
+Autonomous Clone Instance
+    ├─ Full project context
+    ├─ All tool permissions
+    ├─ Complete skill access
+    └─ Independent execution
+```
+
+### Decision Matrix
+
+| Factor | Clone Pattern | Specialist Pattern |
+|--------|---------------|-------------------|
+| Domain Expertise | ❌ Not needed | ✅ Required |
+| Context Scope | Full project | Domain-specific |
+| Autonomy | Complete autonomy | Instruction-following |
+| Parallel Execution | ✅ Possible | ❌ Sequential only |
+| Learning | Self-memory storage | Feedback-based |
+
+## Quick Start
+
+### 1. Task Analysis
+Alfred automatically analyzes incoming requests to determine if Clone Pattern applies:
+
+```python
+# Clone Pattern Conditions
+- Task has 5+ steps OR affects 100+ files
+- No domain specialization needed (UI, Backend, DB, Security, ML)
+- High uncertainty OR parallelizable OR complex
+```
+
+### 2. Clone Creation
+If conditions are met, Alfred creates an autonomous clone:
+
+```python
+clone = create_clone(
+    task_description="Specific goal-oriented task",
+    context_scope="full",  # Complete project context
+    learning_enabled=True   # Save learnings
+)
+```
+
+### 3. Autonomous Execution
+Clone executes independently with full capabilities:
+- Plans approach autonomously
+- Documents decisions via @TAG
+- Creates PR if modifications needed
+- Saves learnings to memory
+
+## Real-World Examples
+
+### Large-Scale Migration
+**Task**: Migrate entire MoAI-ADK project from v0.14.0 to v0.15.2
+
+**Clone Execution**:
+1. Analyzes current structure (47 files affected)
+2. Creates 8-step migration plan
+3. Implements with automatic conflict resolution
+4. Generates PR for review
+5. Saves migration learnings
+
+### Parallel Architecture Evaluation
+**Task**: Evaluate 3 different architecture approaches simultaneously
+
+**Clone Execution**:
+- Creates 3 clones, one for each approach
+- Each clone researches and implements their approach
+- Provides comparative analysis
+- Recommends optimal solution
+
+## Integration with Alfred Workflow
+
+Clone Pattern integrates seamlessly with Alfred's 4-step workflow:
+
+1. **Intent Understanding**: Detects Clone Pattern suitability
+2. **Plan Creation**: Delegates to clone for complex planning
+3. **Task Execution**: Clone executes autonomously
+4. **Report & Commit**: Clone documents and creates PR
+
+## Learning System
+
+Clones automatically save learnings to improve future tasks:
+
+```json
+{
+  "migration_tasks": [
+    {
+      "timestamp": "2025-11-05T12:00:00Z",
+      "task_type": "version_migration",
+      "approach_used": "incremental_migration",
+      "pitfalls_discovered": ["config_conflicts", "hook_incompatibility"],
+      "optimization_tips": ["backup_first", "test_incrementally"]
+    }
+  ]
+}
+```
+
+## Files Structure
+
+- `SKILL.md` - Complete implementation guide
+- `README.md` - This overview and quick start
+- `examples.md` - Detailed real-world scenarios
+- `reference.md` - API documentation and technical specs
+
+## Related Skills
+
+- `Skill("moai-alfred-workflow")` - 4-step workflow integration
+- `Skill("moai-alfred-agent-guide")` - Team coordination details
+- `Skill("moai-alfred-personas")` - Communication style adaptation
+
+## Quality Assurance
+
+All clone operations maintain:
+- ✅ TRUST 5 principles
+- ✅ @TAG chain integrity  
+- ✅ All tests passing
+- ✅ PR ready for review
+- ✅ Complete documentation
+
+---
+
+**Version**: 1.0.0  
+**Last Updated**: 2025-11-05  
+**Tier**: Alfred  
+**Integration**: Seamless with existing MoAI-ADK workflow

moai_adk/templates/.claude/skills/moai-alfred-clone-pattern/SKILL.md

@@ -0,0 +1,227 @@
+---
+name: moai-alfred-clone-pattern
+version: 1.0.0
+created: 2025-11-05
+updated: 2025-11-05
+status: active
+description: Master-Clone pattern implementation guide for complex multi-step tasks with full project context
+keywords: ['clone-pattern', 'master-clone', 'delegation', 'multi-step', 'parallel-processing']
+allowed-tools:
+  - Read
+  - Bash
+  - Task
+---
+
+# Clone Pattern Skill
+
+## Skill Metadata
+
+| Field | Value |
+| ----- | ----- |
+| **Skill Name** | moai-alfred-clone-pattern |
+| **Version** | 1.0.0 (2025-11-05) |
+| **Allowed tools** | Read, Bash, Task |
+| **Auto-load** | On demand when complex tasks detected |
+| **Tier** | Alfred |
+
+---
+
+## What It Does
+
+Provides comprehensive guidance for Alfred's Master-Clone pattern - a delegation mechanism where Alfred creates autonomous clones to handle complex multi-step tasks that don't require domain-specific expertise but benefit from full project context and parallel processing capabilities.
+
+## When to Use
+
+**Use Clone Pattern when:**
+- Task requires 5+ steps OR affects 100+ files
+- No domain-specific expertise needed (UI, Backend, DB, Security, ML)
+- Task is complex with high uncertainty
+- Parallel processing would be beneficial
+- Full project context is required for optimal decisions
+
+**Examples:**
+- Large-scale migrations (v0.14.0 → v0.15.2)
+- Refactoring across many files (100+ imports changes)
+- Parallel exploration/evaluation tasks
+- Complex architecture restructuring
+
+## Key Concepts
+
+### Master-Clone Architecture
+```
+Main Alfred Session
+    │
+    ├─ Intent analysis
+    ├─ Task classification (domain/complexity)
+    │
+    └─ Clone creation (if applicable)
+        │
+        └─ Clone Instance
+            ├─ Full project context
+            ├─ All tool access permissions
+            ├─ All Skills loaded
+            ├─ Specific task description only
+            └─ Autonomous execution & learning
+```
+
+### Clone vs Specialist Selection
+
+| Decision Factor | Clone Pattern | Lead-Specialist Pattern |
+|-----------------|---------------|-------------------------|
+| Domain expertise needed | ❌ No | ✅ Yes |
+| Context scope | Full project | Domain only |
+| Autonomy level | Complete autonomous | Follows instructions |
+| Parallel execution | ✅ Possible | ❌ Sequential only |
+| Learning capability | Self-memory storage | Feedback-based |
+| Best for | Long multi-step tasks | Specialized tasks |
+
+## Implementation Rules
+
+### Rule 1: Clone Creation Conditions
+```python
+def should_create_clone(task) -> bool:
+    """Determine if Clone pattern should be applied"""
+    return (
+        # No domain specialization needed AND
+        task.domain not in ["ui", "backend", "db", "security", "ml"]
+        
+        # AND meets one of these criteria:
+        AND (
+            task.steps >= 5                    # 5+ steps
+            or task.files >= 100               # 100+ files
+            or task.parallelizable             # Can be parallelized
+            or task.uncertainty > 0.5          # High uncertainty
+        )
+    )
+```
+
+### Rule 2: Clone Creation Method
+```python
+def create_clone(
+    task_description: str,
+    context_scope: str = "full",
+    learning_enabled: bool = True
+) -> CloneInstance:
+    """Create Alfred Clone instance
+    
+    Args:
+        task_description: Specific task description (clear goals)
+        context_scope: Context range ("full" | "domain")
+        learning_enabled: Whether to save learning memory
+        
+    Returns:
+        Independent executable Clone instance
+    """
+    clone = Task(
+        subagent_type="general-purpose",
+        description=f"Clone: {task_description}",
+        prompt=f"""
+You are an Alfred Clone with full MoAI-ADK capabilities.
+
+TASK: {task_description}
+
+CONTEXT:
+- Full project context loaded
+- All .moai/ configuration available
+- All 55 Skills accessible
+- Same tools as Main Alfred
+- Same TRUST 5 principles enforced
+
+EXECUTION:
+1. Plan your approach
+2. Execute with transparency
+3. Document decisions via @TAG
+4. Create PR if modifications needed
+5. Log learnings to clone-memory
+
+SUCCESS CRITERIA:
+- TRUST 5 principles maintained
+- @TAG chain integrity preserved
+- All tests passing
+- PR ready for review
+
+You have full autonomy. Main Alfred will review your output only.
+"""
+    )
+    return clone
+```
+
+## Usage Examples
+
+### Example 1: Large-Scale Migration
+```python
+# Alfred's analysis
+task = UserRequest(
+    type="migration",
+    scope="large-scale",
+    steps=8,  # > 5 steps
+    domains=["config", "hooks", "permissions"],
+    uncertainty="high"  # New structure transition
+)
+
+# Apply Clone pattern
+if should_create_clone(task):
+    clone = create_clone(
+        "Migrate v0.14.0 config structure to v0.15.2"
+    )
+    clone.execute()
+```
+
+### Example 2: Parallel Processing Task
+```python
+# Alfred's analysis
+task = UserRequest(
+    type="exploration_evaluation",
+    items=["UI/UX redesign", "Backend optimization", "DB migration"],
+    independence="high"  # Each item independent
+)
+
+# Apply Clone pattern for parallel execution
+if task.independence > 0.7:
+    clones = [
+        create_clone(f"Evaluate: {item}")
+        for item in task.items
+    ]
+    results = parallel_execute(clones)
+```
+
+## Learning System
+
+Clones save learnings to improve future similar tasks:
+
+```python
+def save_learning(task_type: str, learnings: dict):
+    """Save Clone learning to memory"""
+    memory_file = Path(".moai/memory/clone-learnings.json")
+    
+    learnings_db = json.loads(memory_file.read_text())
+    learnings_db[task_type].append({
+        "timestamp": now(),
+        "success": True/False,
+        "approach_used": "...",
+        "pitfalls_discovered": [...],
+        "optimization_tips": [...]
+    })
+    
+    memory_file.write_text(json.dumps(learnings_db, indent=2))
+```
+
+## Benefits
+
+1. **Context Preservation**: Full project context vs domain-only
+2. **Maximum Autonomy**: Goal-oriented vs instruction-oriented
+3. **Parallel Scalability**: Multiple clones can run simultaneously
+4. **Self-Learning**: Accumulated experience for future tasks
+
+## Integration with Alfred Workflow
+
+- Activated during 4-Step Workflow Logic (Step 1: Intent Understanding)
+- Integrates with TRUST 5 principles
+- Maintains @TAG chain integrity
+- Works seamlessly with existing GitFlow
+
+## References
+
+- CLAUDE.md: Alfred's Hybrid Architecture
+- Skill("moai-alfred-workflow"): 4-Step Workflow Logic
+- Skill("moai-alfred-agent-guide"): 19 team members details