moai-adk 0.32.8__py3-none-any.whl → 0.41.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-ai-nano-banana/reference.md

@@ -0,0 +1,139 @@
+# Nano-Banana AI Service - Reference Documentation
+
+## Official Resources
+
+### Google AI Platform
+- **Google AI Studio**: https://aistudio.google.com/
+  - Interactive playground for Gemini models
+  - API key management
+  - Model comparison and testing
+
+- **Gemini API Documentation**: https://ai.google.dev/gemini-api/docs
+  - Complete API reference
+  - Quick start guides
+  - Code samples in multiple languages
+
+- **API Key Management**: https://aistudio.google.com/apikey
+  - Create and manage API keys
+  - Monitor usage and quotas
+  - Configure security settings
+
+### Model-Specific Resources
+
+#### Gemini 3 Pro (Nano Banana Pro)
+- **Model Card**: https://ai.google.dev/gemini-api/docs/models/gemini
+  - Model specifications
+  - Supported features
+  - Rate limits and quotas
+
+- **Image Generation Guide**: https://ai.google.dev/gemini-api/docs/image-generation
+  - Image generation parameters
+  - Resolution and aspect ratio options
+  - Style prefix guidelines
+
+- **Thinking Mode**: https://ai.google.dev/gemini-api/docs/thinking-mode
+  - Chain-of-thought reasoning
+  - Configuration options
+
+### API Reference
+
+#### Python SDK
+- **google-genai Package**: https://pypi.org/project/google-genai/
+  - Installation instructions
+  - Version history
+  - Dependencies
+
+- **Python API Reference**: https://ai.google.dev/gemini-api/docs/get-started/python
+  - Client initialization
+  - Method signatures
+  - Error handling
+
+#### REST API
+- **REST Endpoints**: https://ai.google.dev/gemini-api/docs/rest
+  - HTTP methods
+  - Request/response formats
+  - Authentication headers
+
+### Authentication & Security
+
+- **API Key Best Practices**: https://ai.google.dev/gemini-api/docs/api-keys
+  - Key rotation strategies
+  - Environment variable configuration
+  - Security considerations
+
+- **Quota Management**: https://ai.google.dev/gemini-api/docs/quotations
+  - Rate limits
+  - Usage monitoring
+  - Quota increase requests
+
+### Integration Resources
+
+#### Configuration Files
+- **python-dotenv**: https://pypi.org/project/python-dotenv/
+  - Environment variable management
+  - .env file configuration
+
+- **PyYAML**: https://pyyaml.org/
+  - YAML parsing for batch configs
+  - Schema reference
+
+#### Related Libraries
+- **requests**: https://docs.python-requests.org/
+  - HTTP client for REST API calls
+  - Retry strategies
+  - Timeout handling
+
+- **asyncio**: https://docs.python.org/3/library/asyncio.html
+  - Asynchronous batch processing
+  - Concurrent execution patterns
+
+### Community & Support
+
+- **Google AI Community**: https://ai.google.dev/community
+  - Forums and discussions
+  - Sample implementations
+  - Troubleshooting guides
+
+- **GitHub Issues**: https://github.com/google/generative-ai-python/issues
+  - Bug reports
+  - Feature requests
+  - Known issues
+
+### Learning Resources
+
+#### Tutorials
+- **Image Generation Tutorial**: https://ai.google.dev/gemini-api/docs/image-generation
+  - Basic image generation
+  - Style control
+  - Batch processing
+
+- **Grounding with Google Search**: https://ai.google.dev/gemini-api/docs/grounding
+  - Fact-checked generation
+  - Search integration
+  - Citation formats
+
+#### Examples
+- **Python Examples**: https://ai.google.dev/gemini-api/docs/samples
+  - Code snippets
+  - Common use cases
+  - Best practices
+
+### Skill Files
+
+- **SKILL.md**: Main skill documentation
+- **scripts/generate_image.py**: Single image generation CLI
+- **scripts/batch_generate.py**: Batch generation CLI
+- **examples.md**: Additional workflow examples
+
+### Related Skills
+
+- **moai-docs-generation**: Automated documentation with AI-generated images
+- **moai-domain-uiux**: UI/UX design asset generation
+- **moai-domain-frontend**: Frontend visual component generation
+- **moai-workflow-templates**: Template-based image generation workflows
+
+---
+
+**Last Updated**: 2025-12-23
+**Skill Version**: 1.1.0
+**Model**: gemini-3-pro-image-preview (Nano Banana Pro)