moai-adk 0.32.8__py3-none-any.whl → 0.41.2__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-workflow-testing/reference.md

@@ -0,0 +1,440 @@
+# moai-workflow-testing Reference
+
+Progressive Disclosure Level 2: Extended documentation for testing, debugging, and quality workflows.
+
+---
+
+## API Reference
+
+### Core Classes
+
+DevelopmentWorkflow:
+- Purpose: Unified development lifecycle management
+- Initialization: `DevelopmentWorkflow(project_path, config)`
+- Primary Methods:
+  - `execute_complete_workflow()` - Run full development cycle
+  - `execute_complete_cycle()` - Async complete cycle execution
+  - `run_code_review()` - Execute code review stage
+  - `run_full_test_suite()` - Execute all tests
+  - `run_performance_tests()` - Execute performance tests
+  - `run_security_analysis()` - Execute security analysis
+
+AIDebugger:
+- Purpose: AI-powered intelligent debugging
+- Initialization: `AIDebugger(context7_client)`
+- Key Methods:
+  - `debug_with_context7_patterns(exception, context, project_path)` - Debug with AI assistance
+  - `classify_error(exception)` - Classify error type
+  - `suggest_solutions(analysis)` - Generate fix suggestions
+  - `apply_fix(solution)` - Apply recommended fix
+
+AIRefactorer:
+- Purpose: Intelligent code refactoring
+- Initialization: `AIRefactorer(context7_client)`
+- Key Methods:
+  - `refactor_with_intelligence(project_path)` - Analyze and suggest refactoring
+  - `analyze_technical_debt(project_path)` - Calculate debt score
+  - `generate_refactor_plan(opportunities)` - Create refactoring roadmap
+  - `apply_safe_refactor(plan)` - Apply safe refactoring operations
+
+PerformanceProfiler:
+- Purpose: Real-time performance analysis
+- Initialization: `PerformanceProfiler(context7_client)`
+- Key Methods:
+  - `start_profiling(profile_types)` - Begin profiling session
+  - `stop_profiling()` - End profiling and get results
+  - `detect_bottlenecks(results)` - Identify performance issues
+  - `suggest_optimizations(bottlenecks)` - Generate optimization suggestions
+
+TDDManager:
+- Purpose: Test-driven development cycle management
+- Initialization: `TDDManager(project_path, context7_client)`
+- Key Methods:
+  - `run_full_tdd_cycle(specification, target_function)` - Complete RED-GREEN-REFACTOR
+  - `generate_test(spec)` - Generate test from specification
+  - `run_tests()` - Execute test suite
+  - `calculate_coverage()` - Get test coverage metrics
+
+AutomatedCodeReviewer:
+- Purpose: AI-powered code review with TRUST 5
+- Initialization: `AutomatedCodeReviewer(context7_client)`
+- Key Methods:
+  - `review_codebase(project_path)` - Full codebase review
+  - `calculate_trust_score(review_data)` - Calculate TRUST 5 score
+  - `identify_critical_issues(review_data)` - Find critical problems
+  - `generate_review_report(review_data)` - Create detailed report
+
+---
+
+## Configuration Options
+
+### WorkflowConfig Schema
+
+```python
+@dataclass
+class WorkflowConfig:
+    # Module enablement
+    enable_debugging: bool = True
+    enable_refactoring: bool = True
+    enable_profiling: bool = True
+    enable_tdd: bool = True
+    enable_code_review: bool = True
+
+    # Context7 integration
+    context7_client: Optional[Context7Client] = None
+
+    # Quality thresholds
+    min_trust_score: float = 0.85
+    max_critical_issues: int = 0
+    required_coverage: float = 0.80
+
+    # Performance thresholds
+    max_response_time_ms: int = 100
+    max_memory_usage_mb: int = 512
+    min_throughput_rps: int = 1000
+
+    # Profiling options
+    profile_types: List[str] = field(default_factory=lambda: ['cpu', 'memory'])
+
+    # Output options
+    output_format: str = 'json'  # json, html, markdown
+    verbose: bool = False
+```
+
+### TestSpecification Schema
+
+```python
+@dataclass
+class TestSpecification:
+    name: str                           # Test name (test_*)
+    description: str                    # What is being tested
+    test_type: TestType                 # UNIT, INTEGRATION, E2E
+    requirements: List[str]             # Test requirements
+    acceptance_criteria: List[str]      # Pass/fail criteria
+    fixtures: Optional[List[str]] = None  # Required fixtures
+    mocks: Optional[List[str]] = None   # Required mocks
+    timeout_seconds: int = 30           # Test timeout
+```
+
+### Quality Gates Configuration
+
+```yaml
+quality_gates:
+  code_review:
+    min_trust_score: 0.85          # Minimum TRUST 5 score
+    max_critical_issues: 0         # Maximum critical issues
+    max_high_issues: 5             # Maximum high-severity issues
+    required_sections:
+      - security
+      - performance
+      - maintainability
+
+  testing:
+    required_coverage: 0.80        # Minimum test coverage
+    max_test_failures: 0           # Maximum allowed failures
+    timeout_multiplier: 2.0        # CI timeout multiplier
+
+  performance:
+    response_time_p99_ms: 200      # 99th percentile response time
+    memory_growth_threshold: 0.1   # Max memory growth percentage
+    cpu_threshold: 0.8             # Max CPU utilization
+
+  security:
+    max_vulnerabilities: 0         # Maximum security vulnerabilities
+    allowed_severity: ["low"]      # Allowed vulnerability severities
+```
+
+---
+
+## Integration Patterns
+
+### Pattern 1: CI/CD Pipeline Integration
+
+```python
+# Complete CI/CD integration with quality gates
+from moai_workflow_testing import DevelopmentWorkflow, WorkflowConfig
+
+async def ci_pipeline(commit_hash: str, project_path: str):
+    """Run full CI pipeline with all quality gates."""
+
+    config = WorkflowConfig(
+        enable_debugging=False,  # Skip debugging in CI
+        enable_refactoring=False,  # Skip refactoring suggestions
+        min_trust_score=0.85,
+        required_coverage=0.80
+    )
+
+    workflow = DevelopmentWorkflow(project_path, config)
+
+    # Stage 1: Code Review
+    review_result = await workflow.run_code_review()
+    if review_result.trust_score < config.min_trust_score:
+        return {"status": "failed", "stage": "code_review", "details": review_result}
+
+    # Stage 2: Testing
+    test_result = await workflow.run_full_test_suite()
+    if not test_result.all_passed:
+        return {"status": "failed", "stage": "testing", "details": test_result}
+
+    # Stage 3: Performance
+    perf_result = await workflow.run_performance_tests()
+    if not perf_result.meets_thresholds:
+        return {"status": "failed", "stage": "performance", "details": perf_result}
+
+    # Stage 4: Security
+    security_result = await workflow.run_security_analysis()
+    if security_result.has_critical:
+        return {"status": "failed", "stage": "security", "details": security_result}
+
+    return {"status": "passed", "commit": commit_hash}
+```
+
+### Pattern 2: TDD Workflow with Context7
+
+```python
+# Enhanced TDD with Context7 best practices
+from moai_workflow_testing import TDDManager, TestSpecification, TestType
+
+async def implement_feature_tdd(feature_spec: dict, context7_client):
+    """Implement feature using TDD with Context7 patterns."""
+
+    tdd = TDDManager("/project/src", context7_client=context7_client)
+
+    # Create test specification from feature
+    test_spec = TestSpecification(
+        name=f"test_{feature_spec['name']}",
+        description=feature_spec['description'],
+        test_type=TestType.UNIT,
+        requirements=feature_spec['requirements'],
+        acceptance_criteria=feature_spec['acceptance_criteria']
+    )
+
+    # RED: Generate failing test
+    failing_test = await tdd.generate_test(test_spec)
+    assert await tdd.run_tests() == False  # Should fail
+
+    # GREEN: Implement minimum code
+    implementation = await tdd.generate_implementation(test_spec)
+    assert await tdd.run_tests() == True  # Should pass
+
+    # REFACTOR: Optimize with Context7 patterns
+    refactored = await tdd.refactor_with_patterns(implementation)
+    assert await tdd.run_tests() == True  # Still passes
+
+    # Coverage check
+    coverage = await tdd.calculate_coverage()
+    assert coverage >= 0.85
+
+    return {
+        "test": failing_test,
+        "implementation": refactored,
+        "coverage": coverage
+    }
+```
+
+### Pattern 3: AI-Powered Debugging Session
+
+```python
+# Intelligent debugging with automatic fix application
+from moai_workflow_testing import AIDebugger
+
+async def debug_production_error(exception, context, context7_client):
+    """Debug production error with AI assistance."""
+
+    debugger = AIDebugger(context7_client=context7_client)
+
+    # Analyze error with Context7 patterns
+    analysis = await debugger.debug_with_context7_patterns(
+        exception=exception,
+        context=context,
+        project_path="/project/src"
+    )
+
+    print(f"Error Classification: {analysis.classification}")
+    print(f"Root Cause: {analysis.root_cause}")
+    print(f"Solutions Found: {len(analysis.solutions)}")
+
+    # Apply recommended fix
+    if analysis.solutions:
+        best_solution = analysis.solutions[0]
+        if best_solution.confidence > 0.9:
+            result = await debugger.apply_fix(best_solution)
+            print(f"Fix Applied: {result.success}")
+            return result
+
+    return analysis
+```
+
+### Pattern 4: Performance Optimization Workflow
+
+```python
+# Comprehensive performance optimization
+from moai_workflow_testing import PerformanceProfiler
+
+async def optimize_critical_path(function_name: str, context7_client):
+    """Profile and optimize critical code path."""
+
+    profiler = PerformanceProfiler(context7_client=context7_client)
+
+    # Multi-dimensional profiling
+    profiler.start_profiling(['cpu', 'memory', 'line', 'io'])
+
+    # Execute target function
+    result = await execute_function(function_name)
+
+    # Collect and analyze results
+    profile_results = profiler.stop_profiling()
+
+    # Detect bottlenecks
+    bottlenecks = await profiler.detect_bottlenecks(profile_results)
+
+    # Generate optimizations
+    optimizations = await profiler.suggest_optimizations(bottlenecks)
+
+    # Create optimization report
+    report = {
+        "function": function_name,
+        "original_metrics": profile_results.summary,
+        "bottlenecks": [b.to_dict() for b in bottlenecks],
+        "optimizations": [o.to_dict() for o in optimizations],
+        "estimated_improvement": calculate_improvement(optimizations)
+    }
+
+    return report
+```
+
+---
+
+## Troubleshooting
+
+### Common Issues
+
+Issue: Context7 connection timeout:
+- Cause: MCP server not responding or network issues
+- Solution: Check Context7 server status and restart if needed
+- Prevention: Implement retry logic with exponential backoff
+
+Issue: Test coverage below threshold:
+- Cause: Insufficient test cases or uncovered code paths
+- Solution: Use `tdd.identify_uncovered_paths()` to find gaps
+- Prevention: Run coverage check before commits
+
+Issue: Performance profiler high overhead:
+- Cause: Line profiler active on large files
+- Solution: Use targeted profiling on specific functions
+- Prevention: Configure `max_line_profile_lines` threshold
+
+Issue: Code review false positives:
+- Cause: Overly strict rule configuration
+- Solution: Adjust rule severity in `quality_gates` config
+- Prevention: Tune rules based on project context
+
+Issue: TDD cycle stuck in RED phase:
+- Cause: Specification too complex or ambiguous
+- Solution: Break down specification into smaller units
+- Prevention: Follow EARS format for clear specifications
+
+### Diagnostic Commands
+
+```bash
+# CLI diagnostics
+moai-workflow diagnose --full-check
+moai-workflow test --dry-run --verbose
+moai-workflow profile --list-available
+moai-workflow review --show-rules
+
+# Python diagnostics
+from moai_workflow_testing import diagnose
+
+# Component health check
+report = await diagnose.check_all_components()
+print(f"Debugger: {report.debugger_status}")
+print(f"Profiler: {report.profiler_status}")
+print(f"TDD Manager: {report.tdd_status}")
+print(f"Reviewer: {report.reviewer_status}")
+```
+
+### Log Locations
+
+- Workflow logs: `.moai/logs/workflow.log`
+- Test results: `.moai/test-results/`
+- Profile data: `.moai/profiles/`
+- Review reports: `.moai/reviews/`
+- Debug sessions: `.moai/debug-sessions/`
+
+---
+
+## External Resources
+
+### Official Documentation
+
+- pytest Documentation: https://docs.pytest.org/
+- Python Profiling Guide: https://docs.python.org/3/library/profile.html
+- Coverage.py: https://coverage.readthedocs.io/
+
+### Analysis Tool References
+
+- pylint: https://pylint.readthedocs.io/
+- flake8: https://flake8.pycqa.org/
+- bandit: https://bandit.readthedocs.io/
+- mypy: https://mypy.readthedocs.io/
+
+### Related Skills
+
+- moai-foundation-core - TRUST 5 framework and SPEC-First TDD
+- moai-domain-backend - Backend development workflows
+- moai-domain-frontend - Frontend development workflows
+- moai-platform-baas - Backend-as-a-Service integration
+
+### Module References
+
+- AI Debugging: `modules/ai-debugging.md`
+- Smart Refactoring: `modules/smart-refactoring.md`
+- Performance Optimization: `modules/performance-optimization.md`
+- TDD with Context7: `modules/tdd-context7.md`
+- Automated Code Review: `modules/automated-code-review.md`
+
+### Best Practices
+
+Testing:
+- Write tests before implementation (TDD)
+- Maintain 85%+ coverage
+- Use meaningful test names
+- Mock external dependencies
+- Run tests in isolation
+
+Debugging:
+- Capture full stack traces
+- Include reproduction steps
+- Document environment details
+- Use structured logging
+- Apply fixes incrementally
+
+Performance:
+- Profile before optimizing
+- Focus on bottlenecks
+- Measure improvement
+- Document baseline metrics
+- Test under realistic load
+
+Code Review:
+- Follow TRUST 5 guidelines
+- Address critical issues first
+- Document review decisions
+- Track technical debt
+- Share knowledge through reviews
+
+### Version History
+
+| Version | Date       | Changes                                           |
+|---------|------------|---------------------------------------------------|
+| 1.0.0   | 2025-11-30 | Initial unified workflow release                  |
+| 0.9.0   | 2025-11-25 | Added Context7 integration                        |
+| 0.8.0   | 2025-11-20 | Added performance optimization module             |
+| 0.7.0   | 2025-11-15 | Added automated code review                       |
+
+---
+
+Status: Reference Documentation Complete
+Last Updated: 2025-12-06
+Skill Version: 1.0.0

moai_adk/templates/.claude/skills/moai-workflow-worktree/SKILL.md

@@ -0,0 +1,228 @@
+---
+name: "moai-worktree"
+description: "Git worktree management for parallel SPEC development with isolated workspaces, automatic registration, and seamless MoAI-ADK integration"
+version: 1.1.0
+category: "workflow"
+modularized: true
+user-invocable: false
+tags: ['git', 'worktree', 'parallel', 'development', 'spec', 'isolation']
+updated: 2026-01-08
+status: "active"
+allowed-tools:
+  - Read
+  - Write
+  - Grep
+  - Glob
+  - mcp__context7__resolve-library-id
+  - mcp__context7__get-library-docs
+---
+
+# MoAI Worktree Management
+
+Git worktree management system for parallel SPEC development with isolated workspaces, automatic registration, and seamless MoAI-ADK integration.
+
+Core Philosophy: Each SPEC deserves its own isolated workspace to enable true parallel development without context switching overhead.
+
+## Quick Reference (30 seconds)
+
+What is MoAI Worktree Management?
+A specialized Git worktree system that creates isolated development environments for each SPEC, enabling parallel development without conflicts.
+
+Key Features:
+- Isolated Workspaces: Each SPEC gets its own worktree with independent Git state
+- Automatic Registration: Worktree registry tracks all active workspaces
+- Parallel Development: Multiple SPECs can be developed simultaneously
+- Seamless Integration: Works with /moai:1-plan, /moai:2-run, /moai:3-sync workflow
+- Smart Synchronization: Automatic sync with base branch when needed
+- Cleanup Automation: Automatic cleanup of merged worktrees
+
+Quick Access:
+- CLI commands: Refer to Worktree Commands Module at modules/worktree-commands.md
+- Management patterns: Refer to Worktree Management Module at modules/worktree-management.md
+- Parallel workflow: Refer to Parallel Development Module at modules/parallel-development.md
+- Integration guide: Refer to Integration Patterns Module at modules/integration-patterns.md
+- Troubleshooting: Refer to Troubleshooting Module at modules/troubleshooting.md
+
+Use Cases:
+- Multiple SPECs development in parallel
+- Isolated testing environments
+- Feature branch isolation
+- Code review workflows
+- Experimental feature development
+
+---
+
+## Implementation Guide (5 minutes)
+
+### 1. Core Architecture - Worktree Management System
+
+Purpose: Create isolated Git worktrees for parallel SPEC development.
+
+Key Components:
+
+1. Worktree Registry - Central registry tracking all worktrees
+2. Manager Layer - Core worktree operations including create, switch, remove, and sync
+3. CLI Interface - User-friendly command interface
+4. Models - Data structures for worktree metadata
+5. Integration Layer - MoAI-ADK workflow integration
+
+Registry Structure:
+
+The registry file stores worktree metadata in JSON format. Each worktree entry contains an identifier, file path, branch name, creation timestamp, last sync time, status (active or merged), and base branch reference. The config section defines the worktree root directory, auto-sync preference, and cleanup behavior for merged branches.
+
+File Structure:
+
+The worktree system creates a dedicated directory structure. At the worktree root (typically ~/worktrees/ProjectName/), you will find the central registry JSON file and individual directories for each SPEC. Each SPEC directory contains a .git file for worktree metadata and a complete copy of all project files.
+
+Detailed Reference: Refer to Worktree Management Module at modules/worktree-management.md
+
+---
+
+### 2. CLI Commands - Complete Command Interface
+
+Purpose: Provide intuitive CLI commands for worktree management.
+
+Core Commands:
+
+To create a new worktree for a SPEC, use the new command followed by the SPEC ID and description. To list all worktrees, use the list command. To switch to a specific worktree, use the switch command with the SPEC ID. To get the worktree path for shell integration, use the go command with eval. To sync a worktree with its base branch, use the sync command. To remove a worktree, use the remove command. To clean up merged worktrees, use the clean command. To show worktree status, use the status command. For configuration management, use the config command with get or set subcommands.
+
+Command Categories:
+
+1. Creation: The new command creates an isolated worktree
+2. Navigation: The list, switch, and go commands enable browsing and navigating
+3. Management: The sync, remove, and clean commands maintain worktrees
+4. Status: The status command checks worktree state
+5. Configuration: The config command manages settings
+
+Shell Integration:
+
+For switching to a worktree directory, two approaches work well. The switch command directly changes to the worktree directory. The go command outputs a cd command that can be evaluated by the shell, which is the recommended pattern for shell scripts and automation.
+
+Detailed Reference: Refer to Worktree Commands Module at modules/worktree-commands.md
+
+---
+
+### 3. Parallel Development Workflow - Isolated SPEC Development
+
+Purpose: Enable true parallel development without context switching.
+
+Workflow Integration:
+
+During the Plan Phase using /moai:1-plan, the SPEC is created and the worktree new command sets up automatic worktree isolation.
+
+During the Development Phase, the isolated worktree environment provides independent Git state with zero context switching overhead.
+
+During the Sync Phase using /moai:3-sync, the worktree sync command ensures clean integration with conflict resolution support.
+
+During the Cleanup Phase, the worktree clean command provides automatic cleanup with registry maintenance.
+
+Parallel Development Benefits:
+
+1. Context Isolation: Each SPEC has its own Git state, files, and environment
+2. Zero Switching Cost: Instant switching between worktrees
+3. Independent Development: Work on multiple SPECs simultaneously
+4. Safe Experimentation: Isolated environment for experimental features
+5. Clean Integration: Automatic sync and conflict resolution
+
+Example Workflow:
+
+First, create a worktree for SPEC-001 with a description like "User Authentication" and switch to that directory. Then run /moai:2-run SPEC-001 to develop in isolation. Next, navigate back to the main repository and create another worktree for SPEC-002 with description "Payment Integration". Switch to that worktree and run /moai:2-run SPEC-002 for parallel development. When needed, switch between worktrees and continue development. Finally, sync both worktrees when ready for integration.
+
+Detailed Reference: Refer to Parallel Development Module at modules/parallel-development.md
+
+---
+
+### 4. Integration Patterns - MoAI-ADK Workflow Integration
+
+Purpose: Seamless integration with MoAI-ADK Plan-Run-Sync workflow.
+
+Integration Points:
+
+During Plan Phase Integration with /moai:1-plan, after SPEC creation, create the worktree using the new command with the SPEC ID. The output provides guidance for switching to the worktree using either the switch command or the shell eval pattern with the go command.
+
+During Development Phase with /moai:2-run, worktree isolation provides a clean development environment with independent Git state preventing conflicts and automatic registry tracking.
+
+During Sync Phase with /moai:3-sync, before PR creation run the sync command for the SPEC. After PR merge, run the clean command with the merged-only flag to remove completed worktrees.
+
+Auto-Detection Patterns:
+
+The system detects worktree environments by checking for the registry file in the parent directory. When detected, the SPEC ID is extracted from the current directory name. The status command with sync-check option automatically identifies worktrees that need synchronization.
+
+Configuration Integration:
+
+The MoAI configuration supports worktree settings including auto_create for automatic worktree creation, auto_sync for automatic synchronization, cleanup_merged for automatic cleanup of merged branches, and worktree_root for specifying the worktree directory location with project name substitution.
+
+Detailed Reference: Refer to Integration Patterns Module at modules/integration-patterns.md
+
+---
+
+## Advanced Implementation (10+ minutes)
+
+### Multi-Developer Worktree Coordination
+
+Shared Worktree Registry:
+
+Configure team worktree settings by setting the registry type to team mode and specifying a shared registry path accessible to all team members. For developer-specific worktrees within the shared environment, use the developer flag when creating worktrees to prefix entries with the developer name. The list command with all-developers flag shows worktrees from all team members, and the status command with team-overview provides a consolidated team view.
+
+### Advanced Synchronization Strategies
+
+Selective Sync Patterns:
+
+The sync command supports selective synchronization with include and exclude patterns to sync only specific directories or files. For conflict resolution, choose between auto-resolve for simple conflicts, interactive resolution for manual conflict handling, or abort to cancel the sync operation.
+
+### Worktree Templates and Presets
+
+Custom Worktree Templates:
+
+Create worktrees with specific setups using the template flag. A frontend template might include npm install and eslint setup with pre-commit hooks. A backend template might include virtual environment creation, activation, and dependency installation. Configure custom templates through the config command by setting template-specific setup commands.
+
+### Performance Optimization
+
+Optimized Worktree Operations:
+
+For faster worktree creation, use the shallow flag with a depth value for shallow clones. The background flag enables background synchronization. The parallel flag with all option enables parallel operations across all worktrees. Enable caching through configuration with cache enable and cache TTL settings for faster repeated operations.
+
+---
+
+## Works Well With
+
+Commands:
+- moai:1-plan - SPEC creation with automatic worktree setup
+- moai:2-run - Development in isolated worktree environment
+- moai:3-sync - Integration with automatic worktree sync
+- moai:9-feedback - Worktree workflow improvements
+
+Skills:
+- moai-foundation-core - Parallel development patterns
+- moai-workflow-project - Project management integration
+- moai-workflow-spec - SPEC-driven development
+- moai-git-strategy - Git workflow optimization
+
+Tools:
+- Git worktree - Native Git worktree functionality
+- Rich CLI - Formatted terminal output
+- Click framework - Command-line interface framework
+
+---
+
+## Quick Decision Guide
+
+For new SPEC development, use the worktree isolation pattern with auto-setup. The primary approach is worktree isolation and the supporting pattern is integration with /moai:1-plan.
+
+For parallel development across multiple SPECs, use multiple worktrees with shell integration. The primary approach is maintaining multiple worktrees and the supporting pattern is fast switching between them.
+
+For team coordination in shared environments, use shared registry with developer prefixes. The primary approach is the shared registry pattern and the supporting pattern is conflict resolution.
+
+For code review workflows, use isolated review worktrees. The primary approach is worktree isolation for reviews and the supporting pattern is clean sync after review completion.
+
+For experimental features, use temporary worktrees with auto-cleanup. The primary approach is creating temporary worktrees and the supporting pattern is safe experimentation with automatic removal.
+
+Module Deep Dives:
+- Worktree Commands: Refer to modules/worktree-commands.md for complete CLI reference
+- Worktree Management: Refer to modules/worktree-management.md for core architecture
+- Parallel Development: Refer to modules/parallel-development.md for workflow patterns
+- Integration Patterns: Refer to modules/integration-patterns.md for MoAI-ADK integration
+- Troubleshooting: Refer to modules/troubleshooting.md for problem resolution
+
+Full Examples: Refer to examples.md
+External Resources: Refer to reference.md