moai-adk 0.8.0__py3-none-any.whl → 0.34.0__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-ai-nano-banana/examples.md

@@ -0,0 +1,431 @@
+# Nano-Banana MCP Advanced Examples
+
+## AI Content Generation Workflows
+
+### Documentation Generation Pipeline
+
+Complete documentation generation from specification data:
+
+```python
+async def generate_documentation_workflow(
+    spec_data: dict,
+    output_format: str = "markdown"
+) -> dict:
+    """Complete documentation generation from specification."""
+
+    # Phase 1: Generate API reference
+    api_docs = await mcp_server.invoke_tool("generate_ai_content", {
+        "prompt": f"""Create comprehensive API documentation:
+
+        Endpoints:
+        {json.dumps(spec_data['api_endpoints'], indent=2)}
+
+        Requirements:
+        {json.dumps(spec_data['requirements'], indent=2)}
+        """,
+        "model": "claude-3-5-sonnet",
+        "max_tokens": 3000,
+        "temperature": 0.3
+    })
+
+    # Phase 2: Generate usage examples
+    examples = await mcp_server.invoke_tool("generate_ai_content", {
+        "prompt": f"""Create code examples for API:
+
+        {api_docs['content']}
+
+        Include: Python, TypeScript, curl examples
+        """,
+        "model": "claude-3-5-sonnet",
+        "max_tokens": 2000,
+        "temperature": 0.5
+    })
+
+    # Phase 3: Generate tutorials
+    tutorials = await mcp_server.invoke_tool("generate_ai_content", {
+        "prompt": f"""Create step-by-step tutorials:
+
+        API Documentation: {api_docs['content']}
+        Examples: {examples['content']}
+
+        Target audience: Developers (beginner to intermediate)
+        """,
+        "model": "claude-3-5-sonnet",
+        "max_tokens": 4000,
+        "temperature": 0.7
+    })
+
+    # Phase 4: Generate diagrams descriptions
+    diagrams = await mcp_server.invoke_tool("generate_ai_content", {
+        "prompt": f"""Create diagram descriptions for:
+
+        {spec_data['description']}
+
+        Include: Architecture, sequence, flow diagrams
+        Format: Mermaid diagram syntax
+        """,
+        "model": "claude-3-5-sonnet",
+        "max_tokens": 1500,
+        "temperature": 0.4
+    })
+
+    return {
+        "api_reference": api_docs['content'],
+        "code_examples": examples['content'],
+        "tutorials": tutorials['content'],
+        "diagrams": diagrams['content'],
+        "format": output_format,
+        "tokens_used": (
+            api_docs['usage']['total_tokens'] +
+            examples['usage']['total_tokens'] +
+            tutorials['usage']['total_tokens'] +
+            diagrams['usage']['total_tokens']
+        )
+    }
+```
+
+### Multi-Language Content Generation
+
+Generate content in multiple languages:
+
+```python
+async def multilingual_content_workflow(
+    base_content: str,
+    target_languages: list
+) -> dict:
+    """Generate content in multiple languages."""
+
+    translations = {}
+
+    for language in target_languages:
+        # Generate localized content
+        localized = await mcp_server.invoke_tool("generate_ai_content", {
+            "prompt": f"""Translate and culturally adapt content:
+
+            Source Content:
+            {base_content}
+
+            Target Language: {language}
+
+            Requirements:
+            - Preserve technical accuracy
+            - Adapt cultural references
+            - Maintain formatting
+            - Keep code examples in English
+            """,
+            "model": "claude-3-5-sonnet",
+            "max_tokens": len(base_content) * 2,
+            "temperature": 0.5
+        })
+
+        translations[language] = localized['content']
+
+    return {
+        "base_content": base_content,
+        "translations": translations,
+        "languages": target_languages,
+        "total_tokens": sum(t['usage']['total_tokens'] for t in translations.values())
+    }
+```
+
+## Image Generation Workflows
+
+### Design Asset Creation
+
+Generate complete set of design assets:
+
+```python
+async def generate_design_assets(
+    asset_specifications: list,
+    style_guide: dict
+) -> dict:
+    """Generate complete set of design assets."""
+
+    generated_assets = []
+
+    for spec in asset_specifications:
+        # Create base image
+        image = await mcp_server.invoke_tool("generate_image", {
+            "prompt": f"""Create {spec['type']} image:
+
+            Description: {spec['description']}
+            Style: {style_guide['visual_style']}
+            Colors: {', '.join(style_guide['color_palette'])}
+            Size: {spec['dimensions']}
+            """,
+            "size": spec['dimensions'],
+            "style": style_guide['visual_style'],
+            "quality": "high"
+        })
+
+        # Generate variations if requested
+        variations = []
+        if spec.get('create_variations', False):
+            for i in range(spec['variation_count']):
+                variant = await mcp_server.invoke_tool("generate_image_variation", {
+                    "source_image": image['url'],
+                    "variation_strength": 0.3 + (i * 0.2),
+                    "preserve_style": True
+                })
+                variations.append(variant)
+
+        generated_assets.append({
+            "type": spec['type'],
+            "base_image": image,
+            "variations": variations,
+            "metadata": {
+                "created_at": datetime.now().isoformat(),
+                "style_guide": style_guide['name'],
+                "specification": spec
+            }
+        })
+
+    return {
+        "assets": generated_assets,
+        "style_guide": style_guide,
+        "total_count": len(generated_assets),
+        "total_variations": sum(len(a['variations']) for a in generated_assets)
+    }
+```
+
+## Text Analysis Workflows
+
+### Content Quality Assessment
+
+Comprehensive content quality analysis:
+
+```python
+async def assess_content_quality(
+    content: str,
+    quality_criteria: dict
+) -> dict:
+    """Comprehensive content quality analysis."""
+
+    # Phase 1: Readability analysis
+    readability = await mcp_server.invoke_tool("analyze_with_ai", {
+        "content": content,
+        "analysis_type": "readability",
+        "include_metrics": True
+    })
+
+    # Phase 2: Technical accuracy
+    accuracy = await mcp_server.invoke_tool("analyze_with_ai", {
+        "content": content,
+        "analysis_type": "technical_accuracy",
+        "criteria": quality_criteria.get('technical_standards', {})
+    })
+
+    # Phase 3: Completeness check
+    completeness = await mcp_server.invoke_tool("analyze_with_ai", {
+        "content": content,
+        "analysis_type": "completeness",
+        "required_sections": quality_criteria.get('required_sections', [])
+    })
+
+    # Phase 4: Style consistency
+    style = await mcp_server.invoke_tool("analyze_with_ai", {
+        "content": content,
+        "analysis_type": "style_consistency",
+        "style_guide": quality_criteria.get('style_guide', {})
+    })
+
+    # Calculate overall quality score
+    quality_score = calculate_quality_score({
+        'readability': readability['score'],
+        'accuracy': accuracy['score'],
+        'completeness': completeness['score'],
+        'style': style['score']
+    })
+
+    return {
+        "quality_score": quality_score,
+        "readability": readability,
+        "technical_accuracy": accuracy,
+        "completeness": completeness,
+        "style_consistency": style,
+        "recommendations": generate_improvement_recommendations(
+            readability, accuracy, completeness, style
+        )
+    }
+```
+
+## Batch Processing
+
+### Automated Content Pipeline
+
+Process multiple content items in parallel:
+
+```python
+async def batch_content_generation(
+    input_items: list,
+    processing_config: dict
+) -> dict:
+    """Process multiple content items in parallel."""
+
+    # Configure batch processing
+    batch_size = processing_config.get('batch_size', 5)
+    max_retries = processing_config.get('max_retries', 3)
+
+    results = []
+    errors = []
+
+    # Process in batches
+    for i in range(0, len(input_items), batch_size):
+        batch = input_items[i:i + batch_size]
+
+        # Process batch items concurrently
+        batch_results = await asyncio.gather(
+            *[
+                process_single_item(item, processing_config, max_retries)
+                for item in batch
+            ],
+            return_exceptions=True
+        )
+
+        # Separate successful results from errors
+        for item, result in zip(batch, batch_results):
+            if isinstance(result, Exception):
+                errors.append({
+                    'item': item,
+                    'error': str(result),
+                    'timestamp': datetime.now().isoformat()
+                })
+            else:
+                results.append(result)
+
+        # Rate limiting between batches
+        if i + batch_size < len(input_items):
+            await asyncio.sleep(processing_config.get('batch_delay', 1.0))
+
+    return {
+        "total_items": len(input_items),
+        "successful": len(results),
+        "failed": len(errors),
+        "results": results,
+        "errors": errors,
+        "processing_time": calculate_processing_time()
+    }
+
+async def process_single_item(
+    item: dict,
+    config: dict,
+    max_retries: int
+) -> dict:
+    """Process single item with retry logic."""
+
+    for attempt in range(max_retries):
+        try:
+            result = await mcp_server.invoke_tool("generate_ai_content", {
+                "prompt": item['prompt'],
+                "model": config.get('model', 'claude-3-5-sonnet'),
+                "max_tokens": config.get('max_tokens', 2000),
+                "temperature": config.get('temperature', 0.7)
+            })
+
+            return {
+                'item_id': item['id'],
+                'content': result['content'],
+                'tokens_used': result['usage']['total_tokens'],
+                'attempt': attempt + 1
+            }
+
+        except Exception as e:
+            if attempt == max_retries - 1:
+                raise
+            await asyncio.sleep(2 ** attempt)  # Exponential backoff
+```
+
+## Usage Examples
+
+### Content Generation
+
+Generate API documentation:
+
+```python
+# API documentation
+api_docs = await mcp_server.invoke_tool("generate_ai_content", {
+    "prompt": """Create comprehensive REST API documentation:
+
+    Endpoints:
+    - POST /api/auth/login - User authentication
+    - GET /api/users/:id - Retrieve user profile
+    - PUT /api/users/:id - Update user profile
+
+    Include: Request/response examples, error codes, authentication
+    """,
+    "model": "claude-3-5-sonnet",
+    "max_tokens": 3000,
+    "temperature": 0.3
+})
+
+# Code examples
+code_examples = await mcp_server.invoke_tool("generate_ai_content", {
+    "prompt": """Create code examples for JWT authentication:
+
+    Languages: Python, TypeScript
+    Include: Token generation, validation, refresh flow
+    """,
+    "model": "claude-3-5-sonnet",
+    "max_tokens": 2000,
+    "temperature": 0.5
+})
+```
+
+### Image Generation
+
+Create visual assets:
+
+```python
+# Hero image
+hero_image = await mcp_server.invoke_tool("generate_image", {
+    "prompt": "Modern SaaS dashboard hero image, clean UI, gradient background",
+    "size": "1920x1080",
+    "style": "digital_art",
+    "quality": "high"
+})
+
+# Icon set
+icons = []
+icon_descriptions = [
+    "User profile icon, minimal line art",
+    "Settings gear icon, modern design",
+    "Notification bell icon, clean style"
+]
+
+for description in icon_descriptions:
+    icon = await mcp_server.invoke_tool("generate_image", {
+        "prompt": description,
+        "size": "256x256",
+        "style": "vector",
+        "background": "transparent"
+    })
+    icons.append(icon)
+```
+
+### Text Analysis
+
+Analyze content:
+
+```python
+# Sentiment analysis
+sentiment = await mcp_server.invoke_tool("analyze_with_ai", {
+    "content": user_feedback,
+    "analysis_type": "sentiment",
+    "include_scores": True
+})
+
+# Summarization
+summary = await mcp_server.invoke_tool("analyze_with_ai", {
+    "content": long_document,
+    "analysis_type": "summary",
+    "max_length": 200,
+    "include_key_points": True
+})
+
+# Entity extraction
+entities = await mcp_server.invoke_tool("analyze_with_ai", {
+    "content": technical_document,
+    "analysis_type": "entity_extraction",
+    "entity_types": ["technology", "framework", "tool", "concept"]
+})
+```

moai_adk/templates/.claude/skills/moai-docs-generation/SKILL.md

@@ -0,0 +1,249 @@
+---
+name: moai-docs-generation
+description: Automated documentation generation specialist for technical specs, API docs, user guides, and knowledge bases with multi-format output
+version: 1.0.0
+category: workflow
+allowed-tools: Read, Write, Edit, Grep, Glob
+tags:
+ - documentation
+ - generation
+ - automation
+ - markdown
+ - html
+ - api-docs
+updated: 2025-12-06
+status: active
+author: MoAI-ADK Team
+---
+
+# Documentation Generation Specialist
+
+## Quick Reference (30 seconds)
+
+Automated Documentation Generation - Comprehensive documentation automation covering technical specs, API documentation, user guides, and knowledge base creation with multi-format output capabilities.
+
+Core Capabilities:
+- Technical Documentation: API docs, architecture specs, code documentation
+- User Guides: Tutorials, getting started guides, best practices
+- API Documentation: OpenAPI/Swagger generation, endpoint documentation
+- Multi-Format Output: Markdown, HTML, PDF, static sites
+- AI-Powered Generation: Context-aware content creation and enhancement
+- Continuous Updates: Auto-sync documentation with code changes
+
+When to Use:
+- Generating API documentation from code
+- Creating technical specifications and architecture docs
+- Building user guides and tutorials
+- Automating knowledge base creation
+- Maintaining up-to-date project documentation
+
+---
+
+## Implementation Guide (5 minutes)
+
+### Quick Start Workflow
+
+Basic Documentation Generation:
+```python
+from moai_docs_generation import DocumentationGenerator
+
+# Initialize generator
+doc_gen = DocumentationGenerator()
+
+# Generate API documentation
+api_docs = doc_gen.generate_api_docs("path/to/your/app.py")
+
+# Create user guide
+user_guide = doc_gen.generate_user_guide(project_info)
+
+# Export to multiple formats
+doc_gen.export_to_formats(api_docs, formats=["html", "pdf", "markdown"])
+```
+
+Single Command Documentation:
+```bash
+# Generate complete documentation
+moai generate-docs --source ./src --output ./docs --formats html,pdf
+
+# Update API docs from code
+moai update-api-docs --app-file app.py --format openapi
+
+# Create tutorial from feature
+moai create-tutorial --feature authentication --output docs/tutorials/
+```
+
+### Core Components
+
+1. API Documentation (`modules/api-documentation.md`)
+- OpenAPI/Swagger specification generation
+- Interactive HTML documentation
+- Code example generation
+- Request/response documentation
+
+2. Code Documentation (`modules/code-documentation.md`)
+- AST-based code analysis
+- AI-powered docstring enhancement
+- Automatic documentation structure extraction
+- Multi-format documentation generation
+
+3. User Guides (`modules/user-guides.md`)
+- Getting started guides
+- Feature tutorials
+- Cookbook generation
+- Step-by-step instructions
+
+4. Multi-Format Output (`modules/multi-format-output.md`)
+- HTML site generation
+- PDF documentation
+- Static site export
+- Responsive design templates
+
+---
+
+## Advanced Patterns (10+ minutes)
+
+### Continuous Documentation Integration
+
+Git Hooks for Auto-Documentation:
+```python
+# .git/hooks/pre-commit
+#!/bin/bash
+# Auto-update documentation before commits
+
+python -c "
+from moai_docs_generation import DocumentationGenerator
+doc_gen = DocumentationGenerator()
+doc_gen.update_documentation_for_changed_files()
+"
+```
+
+CI/CD Pipeline Integration:
+```yaml
+# .github/workflows/docs.yml
+name: Generate Documentation
+on:
+ push:
+ branches: [main]
+
+jobs:
+ docs:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v2
+ - name: Generate Documentation
+ run: |
+ moai generate-docs --source ./src --output ./docs
+ moai deploy-docs --platform github-pages
+```
+
+### AI-Enhanced Documentation
+
+Smart Content Generation:
+```python
+# AI-powered example generation
+ai_enhanced_docs = doc_gen.generate_with_ai(
+ source_code="path/to/code",
+ enhancement_level="comprehensive",
+ include_examples=True,
+ include_troubleshooting=True
+)
+```
+
+### Documentation Quality Automation
+
+Automated Quality Checks:
+```python
+# Validate documentation quality
+quality_report = doc_gen.validate_documentation(
+ completeness_threshold=0.9,
+ include_example_validation=True,
+ check_link_integrity=True
+)
+```
+
+---
+
+## Works Well With
+
+Complementary Skills:
+- `moai-foundation-core` - SPEC-first documentation approach
+- `moai-workflow-project` - Project documentation integration
+- `moai-lang-python` - Python code documentation patterns
+- `moai-lang-typescript` - TypeScript code documentation patterns
+- `moai-mcp-notion` - Notion documentation sync and knowledge management
+
+Technology Integration:
+- FastAPI/Flask applications
+- Sphinx/MkDocs documentation
+- GitHub/GitLab wikis
+- Confluence knowledge bases
+- Static site generators (Hugo, Jekyll)
+
+---
+
+## Usage Examples
+
+### Command Line Interface
+```bash
+# Complete documentation suite
+moai docs:generate --project ./my-project --output ./docs
+
+# API documentation only
+moai docs:api --source ./app.py --format openapi,html
+
+# User guide creation
+moai docs:guide --features auth,user-management --template getting-started
+
+# Documentation updates
+moai docs:update --sync-with-code --validate-links
+```
+
+### Python API
+```python
+from moai_docs_generation import DocumentationGenerator
+
+# Complete workflow
+generator = DocumentationGenerator()
+docs = generator.generate_comprehensive_docs(
+ source_directory="./src",
+ include_api_docs=True,
+ include_user_guides=True,
+ output_formats=["html", "pdf", "markdown"]
+)
+
+# Individual components
+api_gen = API Documentation Generation()
+api_spec = api_gen.generate_openapi_spec(fastapi_app)
+
+code_gen = Code Documentation Enhancement()
+enhanced_docs = code_gen.analyze_and_enhance("./src/")
+```
+
+---
+
+## Technology Stack
+
+Core Technologies:
+- Python 3.8+ (main implementation)
+- FastAPI/Flask (API documentation)
+- Jinja2 (HTML templating)
+- Markdown (content formatting)
+- WeasyPrint (PDF generation)
+
+Optional Integrations:
+- AI services (content enhancement)
+- Git hooks (auto-updates)
+- CI/CD platforms (continuous deployment)
+- Static site generators (hosting)
+- Documentation platforms (confluence)
+
+Output Formats:
+- HTML (responsive sites)
+- PDF (print-ready documents)
+- Markdown (version control friendly)
+- OpenAPI/Swagger (API specifications)
+- Static sites (hosting platforms)
+
+---
+
+*For detailed implementation patterns and advanced configurations, see the `modules/` directory.*