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

moai_adk/templates/.claude/skills/moai-integration-mcp/modules/security-authentication.md

@@ -0,0 +1,256 @@
+# Security and Authentication
+
+## Overview
+Comprehensive security framework for MCP integrations covering multi-provider authentication, API key management, OAuth flows, and secure credential handling.
+
+## Quick Implementation
+
+### Multi-Provider Authentication
+
+```python
+class AuthManager:
+ def __init__(self):
+ self.providers = {
+ 'figma': FigmaAuthProvider(),
+ 'notion': NotionAuthProvider(),
+ 'nano_banana': NanoBananaAuthProvider()
+ }
+
+ async def authenticate_service(self, service: str, credentials: dict) -> bool:
+ """Authenticate with specific service provider."""
+ if service not in self.providers:
+ raise ValueError(f"Unknown service: {service}")
+
+ provider = self.providers[service]
+ return await provider.authenticate(credentials)
+
+ async def get_auth_url(self, service: str, redirect_uri: str) -> str:
+ """Get OAuth URL for service authentication."""
+ provider = self.providers[service]
+ return provider.get_auth_url(redirect_uri)
+
+ async def exchange_code_for_token(self, service: str, code: str, redirect_uri: str) -> dict:
+ """Exchange OAuth code for access token."""
+ provider = self.providers[service]
+ return await provider.exchange_code_for_token(code, redirect_uri)
+
+class FigmaAuthProvider:
+ def __init__(self):
+ self.client_id = os.getenv('FIGMA_CLIENT_ID')
+ self.client_secret = os.getenv('FIGMA_CLIENT_SECRET')
+ self.redirect_uri = os.getenv('FIGMA_REDIRECT_URI')
+
+ async def authenticate(self, credentials: dict) -> bool:
+ """Validate Figma API credentials."""
+ try:
+ client = FigmaClient(credentials['access_token'])
+ # Test with a simple API call
+ await client.get_user_info()
+ return True
+ except Exception:
+ return False
+
+ def get_auth_url(self, redirect_uri: str) -> str:
+ """Generate Figma OAuth URL."""
+ params = {
+ 'client_id': self.client_id,
+ 'redirect_uri': redirect_uri,
+ 'scope': 'file_read',
+ 'response_type': 'code',
+ 'state': self.generate_state()
+ }
+ return f"https://www.figma.com/oauth?{urlencode(params)}"
+
+ async def exchange_code_for_token(self, code: str, redirect_uri: str) -> dict:
+ """Exchange OAuth code for access token."""
+ # Implementation for token exchange
+ pass
+
+class NotionAuthProvider:
+ def __init__(self):
+ self.client_id = os.getenv('NOTION_CLIENT_ID')
+ self.client_secret = os.getenv('NOTION_CLIENT_SECRET')
+ self.redirect_uri = os.getenv('NOTION_REDIRECT_URI')
+
+ async def authenticate(self, credentials: dict) -> bool:
+ """Validate Notion API credentials."""
+ try:
+ client = Client(auth=credentials['access_token'])
+ # Test with a simple API call
+ await self.search_pages("", client)
+ return True
+ except Exception:
+ return False
+
+ def get_auth_url(self, redirect_uri: str) -> str:
+ """Generate Notion OAuth URL."""
+ params = {
+ 'client_id': self.client_id,
+ 'redirect_uri': redirect_uri,
+ 'response_type': 'code',
+ 'owner': 'user',
+ 'state': self.generate_state()
+ }
+ return f"https://api.notion.com/v1/oauth/authorize?{urlencode(params)}"
+```
+
+### Secure Credential Storage
+
+```python
+class CredentialManager:
+ def __init__(self, storage_backend='encrypted_file'):
+ self.storage = self._init_storage(storage_backend)
+ self.encryption_key = self._get_encryption_key()
+
+ def _init_storage(self, backend):
+ """Initialize secure storage backend."""
+ if backend == 'encrypted_file':
+ return EncryptedFileStorage()
+ elif backend == 'vault':
+ return VaultStorage()
+ else:
+ raise ValueError(f"Unknown storage backend: {backend}")
+
+ async def store_credentials(self, service: str, credentials: dict) -> str:
+ """Securely store encrypted credentials."""
+ credential_id = str(uuid.uuid4())
+ encrypted_data = self._encrypt_credentials(credentials)
+
+ await self.storage.store(
+ key=f"{service}:{credential_id}",
+ data=encrypted_data
+ )
+
+ return credential_id
+
+ async def retrieve_credentials(self, service: str, credential_id: str) -> dict:
+ """Retrieve and decrypt credentials."""
+ encrypted_data = await self.storage.retrieve(f"{service}:{credential_id}")
+ return self._decrypt_credentials(encrypted_data)
+
+ def _encrypt_credentials(self, credentials: dict) -> bytes:
+ """Encrypt credentials using Fernet symmetric encryption."""
+ from cryptography.fernet import Fernet
+ fernet = Fernet(self.encryption_key)
+ return fernet.encrypt(json.dumps(credentials).encode())
+
+ def _decrypt_credentials(self, encrypted_data: bytes) -> dict:
+ """Decrypt credentials."""
+ from cryptography.fernet import Fernet
+ fernet = Fernet(self.encryption_key)
+ decrypted = fernet.decrypt(encrypted_data)
+ return json.loads(decrypted.decode())
+```
+
+## Key Features
+
+### 1. OAuth 2.0 Support
+- Authorization code flow
+- Client credentials flow
+- PKCE support
+- Token refresh handling
+
+### 2. Security Best Practices
+- Encrypted credential storage
+- Secure token management
+- Rate limiting protection
+- Request signing
+
+### 3. Multi-Provider Support
+- Standardized authentication interface
+- Provider-specific configurations
+- Token synchronization
+- Session management
+
+### 4. Audit and Monitoring
+- Authentication logging
+- Access tracking
+- Security event monitoring
+- Compliance reporting
+
+## Security Patterns
+
+### 1. OAuth Flow Security
+```python
+class OAuthFlowManager:
+ async def secure_oauth_flow(self, service: str, redirect_uri: str):
+ # Generate cryptographically secure state
+ state = secrets.token_urlsafe(32)
+
+ # Store state securely with expiration
+ await self.store_state(state, expires_in=300) # 5 minutes
+
+ # Get auth URL with security parameters
+ auth_url = await self.auth_manager.get_auth_url(
+ service=service,
+ redirect_uri=redirect_uri,
+ state=state
+ )
+
+ return auth_url
+```
+
+### 2. Token Validation
+```python
+class TokenValidator:
+ async def validate_token(self, service: str, token: str) -> bool:
+ """Validate token format and expiration."""
+ try:
+ # Check token format
+ if not self.validate_token_format(token):
+ return False
+
+ # Check token expiration
+ if self.is_token_expired(token):
+ return False
+
+ # Validate with service provider
+ return await self.validate_with_provider(service, token)
+
+ except Exception:
+ return False
+```
+
+### 3. Access Control
+```python
+class AccessControlManager:
+ async def check_permissions(self, user_id: str, service: str, action: str) -> bool:
+ """Check if user has permission for specific action."""
+ permissions = await self.get_user_permissions(user_id)
+ required_permission = f"{service}:{action}"
+
+ return required_permission in permissions
+```
+
+## Best Practices
+
+### 1. Credential Management
+- Never store credentials in plain text
+- Use environment variables for sensitive data
+- Implement secure credential rotation
+- Monitor for credential compromise
+
+### 2. Token Security
+- Use short-lived access tokens
+- Implement secure token refresh
+- Store tokens securely
+- Validate tokens on each use
+
+### 3. API Security
+- Implement rate limiting
+- Use HTTPS for all communications
+- Validate all inputs
+- Implement request signing
+
+### 4. Monitoring and Logging
+- Log authentication events
+- Monitor for suspicious activity
+- Implement security alerts
+- Regular security audits
+
+## Integration Points
+- OAuth 2.0 providers
+- Encryption libraries (cryptography)
+- Secret management systems
+- Security monitoring tools
+- Compliance frameworks

moai_adk/templates/.claude/skills/moai-integration-mcp/modules/server-architecture.md

@@ -0,0 +1,253 @@
+# Universal MCP Server Architecture
+
+## Overview
+Comprehensive MCP server architecture supporting multiple connectors including Figma, Notion, Nano-Banana, and custom integrations with modular tool registration and unified API management.
+
+## Quick Implementation
+
+### Base MCP Server with Multiple Connectors
+
+```python
+from fastmcp import FastMCP
+from typing import Dict, List, Optional
+import asyncio
+
+class UniversalMCPServer:
+ def __init__(self, server_name: str):
+ self.server = FastMCP(server_name)
+ self.connectors = {}
+ self.setup_connectors()
+ self.register_tools()
+
+ def setup_connectors(self):
+ """Initialize all available connectors."""
+ self.connectors = {
+ 'figma': FigmaConnector(),
+ 'notion': NotionConnector(),
+ 'nano_banana': NanoBananaConnector(),
+ 'custom': CustomConnector()
+ }
+
+ def register_tools(self):
+ """Register all tools from connectors."""
+ for connector_name, connector in self.connectors.items():
+ connector.register_tools(self.server)
+
+# Figma Connector
+class FigmaConnector:
+ def __init__(self, api_key: str = None):
+ self.api_key = api_key
+ self.figma_client = None
+
+ async def initialize(self):
+ if self.api_key:
+ self.figma_client = FigmaClient(self.api_key)
+
+ def register_tools(self, server):
+ @server.tool()
+ async def extract_figma_components(
+ file_id: str,
+ component_names: Optional[List[str]] = None
+ ) -> dict:
+ """Extract React components from Figma design."""
+ if not self.figma_client:
+ raise ValueError("Figma API key not configured")
+
+ file_data = await self.figma_client.get_file(file_id)
+ components = self.parse_components(file_data, component_names)
+
+ return {
+ "components": components,
+ "design_tokens": self.extract_design_tokens(file_data),
+ "metadata": self.extract_metadata(file_data)
+ }
+
+ @server.tool()
+ async def sync_figma_tokens(
+ file_id: str,
+ output_path: str = "src/styles/tokens.json"
+ ) -> dict:
+ """Sync design tokens from Figma to code."""
+ file_data = await self.figma_client.get_file(file_id)
+ tokens = self.extract_design_tokens(file_data)
+
+ # Convert to W3C DTCG 2.0 format
+ formatted_tokens = self.format_design_tokens(tokens)
+
+ return {
+ "tokens": formatted_tokens,
+ "file_path": output_path,
+ "sync_status": "success"
+ }
+
+# Notion Connector
+class NotionConnector:
+ def __init__(self, api_key: str = None):
+ self.api_key = api_key
+ self.notion_client = None
+
+ async def initialize(self):
+ if self.api_key:
+ self.notion_client = NotionClient(auth=self.api_key)
+
+ def register_tools(self, server):
+ @server.tool()
+ async def query_notion_database(
+ database_id: str,
+ query: Optional[Dict] = None
+ ) -> dict:
+ """Query Notion database with filtering."""
+ if not self.notion_client:
+ raise ValueError("Notion API key not configured")
+
+ database = self.notion_client.databases.retrieve(database_id)
+ results = self.notion_client.databases.query(
+ database_id=database_id,
+ query=query or {}
+ )
+
+ return {
+ "results": results.get("results", []),
+ "database_info": database,
+ "total_count": len(results.get("results", []))
+ }
+
+ @server.tool()
+ async def create_notion_page(
+ database_id: str,
+ properties: Dict,
+ content: Optional[List[Dict]] = None
+ ) -> dict:
+ """Create new page in Notion database."""
+ page_data = {
+ "parent": {"database_id": database_id},
+ "properties": properties
+ }
+
+ if content:
+ page_data["children"] = content
+
+ new_page = self.notion_client.pages.create(page_data)
+ return {"page": new_page, "status": "created"}
+
+# Nano-Banana Connector
+class NanoBananaConnector:
+ def __init__(self, api_key: str = None):
+ self.api_key = api_key
+ self.nb_client = None
+
+ async def initialize(self):
+ if self.api_key:
+ self.nb_client = NanoBananaClient(api_key=self.api_key)
+
+ def register_tools(self, server):
+ @server.tool()
+ async def generate_ai_content(
+ prompt: str,
+ model: str = "claude-3-5-sonnet-20241022",
+ max_tokens: int = 4000
+ ) -> dict:
+ """Generate content using Nano-Banana AI models."""
+ if not self.nb_client:
+ raise ValueError("Nano-Banana API key not configured")
+
+ response = await self.nb_client.chat.completions.create(
+ model=model,
+ messages=[{"role": "user", "content": prompt}],
+ max_tokens=max_tokens
+ )
+
+ return {
+ "content": response.choices[0].message.content,
+ "model": model,
+ "usage": response.usage
+ }
+
+ @server.tool()
+ async def analyze_with_ai(
+ content: str,
+ analysis_type: str = "summary"
+ ) -> dict:
+ """Analyze content using AI models."""
+ analysis_prompts = {
+ "summary": "Please provide a comprehensive summary of the following content:",
+ "sentiment": "Analyze the sentiment and emotional tone of this content:",
+ "key_points": "Extract the key points and main ideas from this content:",
+ "action_items": "Identify action items and next steps from this content:"
+ }
+
+ prompt = f"{analysis_prompts.get(analysis_type, analysis_prompts['summary'])}\n\n{content}"
+
+ response = await self.nb_client.chat.completions.create(
+ model="claude-3-5-sonnet-20241022",
+ messages=[{"role": "user", "content": prompt}],
+ max_tokens=2000
+ )
+
+ return {
+ "analysis": response.choices[0].message.content,
+ "type": analysis_type,
+ "content_length": len(content)
+ }
+```
+
+## Key Features
+
+### 1. Multi-Connector Architecture
+- Unified server interface
+- Modular connector registration
+- Dynamic tool discovery
+- Configuration management
+
+### 2. Service Integration
+- Figma design system integration
+- Notion knowledge base management
+- Nano-Banana AI content generation
+- Custom connector framework
+
+### 3. Tool Registration
+- Automatic tool discovery
+- Parameter validation
+- Error handling
+- Response standardization
+
+### 4. Configuration Management
+- Secure API key storage
+- Environment variable support
+- Runtime configuration
+- Service health checks
+
+## Connector Patterns
+
+### Standard Interface
+```python
+class BaseConnector:
+ def __init__(self, api_key: str = None):
+ self.api_key = api_key
+ self.client = None
+
+ async def initialize(self):
+ """Initialize connector with API client."""
+ pass
+
+ def register_tools(self, server):
+ """Register connector tools with MCP server."""
+ pass
+
+ async def health_check(self):
+ """Check connector health and connectivity."""
+ pass
+```
+
+### Tool Registration
+- Decorator-based registration
+- Automatic parameter validation
+- Standardized response format
+- Error handling and retry logic
+
+## Integration Points
+- FastMCP server framework
+- External API clients
+- Authentication systems
+- Configuration management
+- Monitoring and logging

moai_adk/templates/.claude/skills/moai-lang-unified/README.md

@@ -0,0 +1,133 @@
+# moai-lang-unified
+
+## Overview
+
+This unified programming language skill consolidates 25+ individual `moai-lang-*` skills into a single, comprehensive skill that maintains all the expertise and functionality while providing cross-language capabilities.
+
+## Replaced Skills
+
+This unified skill replaces the following 25 individual language skills:
+
+### Scripting & Dynamic Languages
+- `moai-lang-python` - Python 3.13 with FastAPI, Django, async patterns
+- `moai-lang-javascript` - JavaScript ES2025 with Node.js, Express
+- `moai-lang-typescript` - TypeScript 5.9 with React, Next.js, type safety
+- `moai-lang-php` - PHP 8.4 with Laravel, Symfony
+- `moai-lang-ruby` - Ruby 3.3 with Rails, Sinatra
+- `moai-lang-shell` - Shell/Bash scripting and DevOps
+
+### Systems & Performance Languages
+- `moai-lang-go` - Go 1.23 with concurrency, Fiber
+- `moai-lang-rust` - Rust 1.91 with memory safety, Tokio
+- `moai-lang-cpp` - C++23 with performance optimization
+- `moai-lang-c` - C17 with low-level programming
+
+### Enterprise & JVM Languages
+- `moai-lang-java` - Java 21 LTS with Spring Boot
+- `moai-lang-kotlin` - Kotlin 2.0 with coroutines
+- `moai-lang-scala` - Scala 3.4 with functional programming
+- `moai-lang-jvm` - JVM ecosystem patterns
+
+### Mobile & Platform Languages
+- `moai-lang-swift` - Swift 6.0 for iOS and server-side
+- `moai-lang-csharp` - C# 12 with .NET 8
+- `moai-lang-dart` - Dart 3.5 with Flutter
+
+### Data & Domain Languages
+- `moai-lang-r` - R 4.4 for statistical computing
+- `moai-lang-sql` - SQL:2023 across all RDBMS
+- `moai-lang-elixir` - Elixir 1.17 with Phoenix
+
+### Specialized Languages
+- `moai-lang-html-css` - HTML5 and CSS3 for web development
+- `moai-lang-mobile` - Cross-platform mobile development
+- `moai-lang-systems` - Systems programming patterns
+
+## Key Advantages
+
+### 1. Unified Experience
+- Single skill for all programming language expertise
+- Consistent documentation and examples across languages
+- Cross-language comparisons and migration guides
+
+### 2. Enhanced Functionality
+- Cross-language integration patterns
+- Polyglot system design guidance
+- Language selection recommendations
+
+### 3. Improved Performance
+- Automatic language detection and context switching
+- Reduced skill loading overhead
+- Optimized Context7 integration
+
+### 4. Maintenance Efficiency
+- Single point of maintenance for language expertise
+- Consistent updates across all languages
+- Simplified dependency management
+
+## Usage
+
+### Automatic Detection
+The skill automatically detects the programming language context based on:
+- File extensions (`.py`, `.ts`, `.go`, `.rs`, `.java`, etc.)
+- Language-specific keywords and patterns
+- Framework and library mentions
+
+### Manual Invocation
+```bash
+# Get Python expertise
+Skill("moai-lang-unified") # with .py files
+
+# Get Go expertise 
+Skill("moai-lang-unified") # with .go files
+
+# Cross-language comparison
+Skill("moai-lang-unified") # with multiple languages
+```
+
+### Progressive Disclosure
+- Quick Reference: Immediate language patterns and examples
+- Implementation Guide: In-depth language-specific guidance
+- Cross-Language: Comparisons, integration, and migration patterns
+
+## File Structure
+
+```
+moai-lang-unified/
+ SKILL.md # Main skill file (242 lines, under 500 limit)
+ reference.md # Comprehensive language reference and mappings
+ examples.md # Multi-language code examples and patterns
+ README.md # This file
+```
+
+## Migration Guide
+
+### For Users
+1. Replace `Skill("moai-lang-python")` with `Skill("moai-lang-unified")`
+2. The unified skill will automatically detect the language context
+3. All previous functionality is preserved and enhanced
+
+### For Developers
+- Individual language skills can be safely removed
+- This unified skill provides equivalent or superior functionality
+- Context7 integration is enhanced with comprehensive library mappings
+
+## Validation
+
+- SKILL.md complies with 500-line limit (242 lines)
+- All 25+ languages covered with latest versions
+- Context7 integration with comprehensive library mappings
+- Cross-language patterns and comparisons
+- Production-ready code examples
+- Progressive disclosure architecture
+- Official Claude Code standards compliance
+
+## Future Updates
+
+This unified skill will be maintained as the single source of truth for programming language expertise in the MoAI-ADK ecosystem. All language updates and new language support will be added here rather than creating separate skills.
+
+---
+
+Last Updated: 2025-11-25 
+Status: Production Ready (Enterprise v1.0.0) 
+Maintainer: MoAI-ADK Team