PyPI - moai-adk - Versions diffs - 0.25.4__py3-none-any.whl → 0.32.8__py3-none-any.whl - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of moai-adk might be problematic. Click here for more details.

Files changed (378) hide show

moai_adk/templates/.claude/skills/moai-docs-generation/modules/multi-format-output.md ADDED Viewed

@@ -0,0 +1,178 @@
+# Multi-Format Output Generation
+## Overview
+Comprehensive documentation generation supporting HTML sites, PDF documents, static sites, and various output formats with responsive design and professional styling.
+## Quick Implementation
+```python
+from jinja2 import Template
+import markdown
+class HTMLDocGenerator:
+ def __init__(self):
+ self.templates = self.load_templates()
+ def generate_html_site(self, documentation: Dict, output_dir: str):
+ """Generate a complete HTML documentation site."""
+ # Generate index page
+ index_html = self.generate_index_page(documentation)
+ self.write_file(output_dir, "index.html", index_html)
+ # Generate API reference pages
+ self.generate_api_pages(documentation, output_dir)
+ # Generate tutorial pages
+ self.generate_tutorial_pages(documentation, output_dir)
+ # Generate CSS and assets
+ self.generate_assets(output_dir)
+ def generate_index_page(self, documentation: Dict) -> str:
+ """Generate the main index page."""
+ template = Template("""
+<!DOCTYPE html>
+<html lang="en">
+<head>
+ <meta charset="UTF-8">
+ <meta name="viewport" content="width=device-width, initial-scale=1.0">
+ <title>{{ title }}</title>
+ <link rel="stylesheet" href="assets/style.css">
+</head>
+<body>
+ <nav class="sidebar">
+ <div class="logo">
+ <h2>{{ title }}</h2>
+ </div>
+ <ul class="nav-menu">
+ <li><a href="index.html" class="active">Home</a></li>
+ <li><a href="api/index.html">API Reference</a></li>
+ <li><a href="tutorials/index.html">Tutorials</a></li>
+ <li><a href="cookbook.html">Cookbook</a></li>
+ </ul>
+ </nav>
+ <main class="content">
+ <section class="hero">
+ <h1>{{ title }}</h1>
+ <p>{{ description }}</p>
+ <div class="cta-buttons">
+ <a href="tutorials/getting-started.html" class="btn primary">Get Started</a>
+ <a href="api/index.html" class="btn secondary">API Docs</a>
+ </div>
+ </section>
+ <section class="features">
+ <h2>Key Features</h2>
+ <div class="feature-grid">
+ {% for feature in features %}
+ <div class="feature-card">
+ <h3>{{ feature.name }}</h3>
+ <p>{{ feature.description }}</p>
+ </div>
+ {% endfor %}
+ </div>
+ </section>
+ <section class="quick-start">
+ <h2>Quick Start</h2>
+ <pre><code>{{ quick_start_example }}</code></pre>
+ </section>
+ </main>
+ <script src="assets/script.js"></script>
+</body>
+</html>
+ """)
+ return template.render(
+ title=documentation.get("title", "API Documentation"),
+ description=documentation.get("description", ""),
+ features=documentation.get("features", []),
+ quick_start_example=documentation.get("quick_start", "")
+ )
+ def generate_pdf_documentation(self, markdown_content: str, output_path: str):
+ """Generate PDF from Markdown content."""
+ try:
+ import weasyprint
+ # Convert Markdown to HTML
+ html_content = markdown.markdown(
+ markdown_content,
+ extensions=['tables', 'fenced_code', 'toc']
+ )
+ # Add CSS styling
+ styled_html = f"""
+ <!DOCTYPE html>
+ <html>
+ <head>
+ <style>
+ body {{ font-family: Arial, sans-serif; line-height: 1.6; margin: 40px; }}
+ h1 {{ color: #333; border-bottom: 2px solid #333; }}
+ h2 {{ color: #666; }}
+ code {{ background: #f4f4f4; padding: 2px 4px; border-radius: 3px; }}
+ pre {{ background: #f4f4f4; padding: 10px; border-radius: 5px; overflow-x: auto; }}
+ table {{ border-collapse: collapse; width: 100%; }}
+ th, td {{ border: 1px solid #ddd; padding: 8px; text-align: left; }}
+ </style>
+ </head>
+ <body>
+ {html_content}
+ </body>
+ </html>
+ """
+ # Generate PDF
+ weasyprint.HTML(string=styled_html).write_pdf(output_path)
+ except ImportError:
+ raise ImportError("weasyprint is required for PDF generation. Install with: pip install weasyprint")
+```
+## Output Formats
+### 1. HTML Documentation Sites
+- Responsive design with sidebar navigation
+- Interactive code examples
+- Search functionality
+- Dark/light theme support
+- Mobile-optimized layouts
+### 2. PDF Documentation
+- Professional print-ready formatting
+- Table of contents generation
+- Code syntax highlighting
+- Header/footer customization
+- Page numbering and bookmarks
+### 3. Static Site Generation
+- Jekyll/Hugo compatible output
+- SEO optimization
+- Fast loading times
+- GitHub Pages deployment
+- Custom domain support
+### 4. Markdown Variants
+- GitHub Flavored Markdown
+- CommonMark compliance
+- Extension support (tables, footnotes)
+- Cross-reference linking
+- Image optimization
+## Template System
+- Jinja2-based templating
+- Customizable themes
+- Component-based design
+- Asset management
+- Multi-language support
+## Integration Points
+- Documentation platforms (GitBook, Docusaurus)
+- CI/CD pipelines
+- Static site hosting
+- Content management systems
+- Version control workflows

moai_adk/templates/.claude/skills/moai-docs-generation/modules/user-guides.md ADDED Viewed

@@ -0,0 +1,147 @@
+# User Guide Generation
+## Overview
+Automated creation of comprehensive user guides, tutorials, getting started documentation, and cookbooks with AI-powered content generation.
+## Quick Implementation
+```python
+class UserGuideGenerator:
+ def __init__(self, ai_client=None):
+ self.ai_client = ai_client
+ def generate_getting_started_guide(self, project_info: Dict) -> str:
+ """Generate comprehensive getting started guide."""
+ guide_structure = [
+ "# Getting Started",
+ "",
+ "## Prerequisites",
+ self.generate_prerequisites_section(project_info),
+ "",
+ "## Installation",
+ self.generate_installation_section(project_info),
+ "",
+ "## Quick Start",
+ self.generate_quick_start_section(project_info),
+ "",
+ "## Basic Usage",
+ self.generate_basic_usage_section(project_info),
+ "",
+ "## Next Steps",
+ self.generate_next_steps_section(project_info)
+ ]
+ return "\n".join(guide_structure)
+ def generate_tutorial_series(self, features: List[Dict]) -> List[str]:
+ """Generate a series of tutorials for different features."""
+ tutorials = []
+ for feature in features:
+ tutorial = self.generate_feature_tutorial(feature)
+ tutorials.append(tutorial)
+ return tutorials
+ def generate_feature_tutorial(self, feature: Dict) -> str:
+ """Generate a single tutorial for a specific feature."""
+ if self.ai_client:
+ prompt = f"""
+ Create a step-by-step tutorial for this feature:
+ Feature Name: {feature['name']}
+ Description: {feature['description']}
+ Key Functions: {', '.join(feature.get('functions', []))}
+ Example Usage: {feature.get('example', '')}
+ Please include:
+ 1. Clear introduction explaining what the feature does
+ 2. Prerequisites and setup requirements
+ 3. Step-by-step implementation guide
+ 4. Complete code example
+ 5. Common use cases and variations
+ 6. Troubleshooting tips
+ 7. Related features and next steps
+ Format as a comprehensive tutorial with clear sections and code blocks.
+ """
+ response = self.ai_client.generate_content(prompt)
+ return response["content"]
+ else:
+ return self.generate_basic_tutorial(feature)
+ def generate_cookbook(self, use_cases: List[Dict]) -> str:
+ """Generate a cookbook of common patterns and solutions."""
+ cookbook_content = ["# Cookbook", "", "## Common Patterns and Solutions"]
+ for use_case in use_cases:
+ recipe = self.generate_recipe(use_case)
+ cookbook_content.extend(["", recipe])
+ return "\n".join(cookbook_content)
+ def generate_recipe(self, use_case: Dict) -> str:
+ """Generate a single recipe for the cookbook."""
+ return f"""
+### {use_case['title']}
+Problem: {use_case['problem']}
+Solution: {use_case['solution']}
+Code Example:
+```python
+{use_case.get('example_code', '# Example implementation')}
+```
+Explanation: {use_case.get('explanation', 'Detailed explanation of the solution')}
+Variations: {use_case.get('variations', 'Common variations and adaptations')}
+Related Patterns: {', '.join(use_case.get('related_patterns', []))}
+ """
+```
+## Guide Types
+### 1. Getting Started Guides
+- Prerequisites and requirements
+- Installation and setup
+- Quick start examples
+- Basic usage patterns
+- Next steps and resources
+### 2. Feature Tutorials
+- Step-by-step implementation
+- Complete working examples
+- Common use cases
+- Troubleshooting tips
+- Advanced variations
+### 3. Cookbooks
+- Problem-solution format
+- Code-first examples
+- Common patterns
+- Best practices
+- Performance tips
+## Content Generation Features
+- AI-powered tutorial creation
+- Structured content templates
+- Code example generation
+- Progressive difficulty scaling
+- Cross-references and links
+- Troubleshooting sections
+## Integration Points
+- Project documentation systems
+- Developer onboarding workflows
+- Knowledge base platforms
+- Customer support systems
+- Educational platforms

moai_adk/templates/.claude/skills/moai-domain-backend/SKILL.md ADDED Viewed

@@ -0,0 +1,319 @@
+---
+name: moai-domain-backend
+description: Backend development specialist covering API design, database integration, microservices architecture, and modern backend patterns
+version: 1.0.0
+category: domain
+tags:
+ - backend
+ - api
+ - database
+ - microservices
+ - architecture
+updated: 2025-11-30
+status: active
+author: MoAI-ADK Team
+---
+# Backend Development Specialist
+## Quick Reference (30 seconds)
+Backend Development Mastery - Comprehensive backend development patterns covering API design, database integration, microservices, and modern architecture patterns.
+Core Capabilities:
+- API Design: REST, GraphQL, gRPC with OpenAPI 3.1
+- Database Integration: PostgreSQL, MongoDB, Redis, caching strategies
+- Microservices: Service mesh, distributed patterns, event-driven architecture
+- Security: Authentication, authorization, OWASP compliance
+- Performance: Caching, optimization, monitoring, scaling
+When to Use:
+- Backend API development and architecture
+- Database design and optimization
+- Microservices implementation
+- Performance optimization and scaling
+- Security integration for backend systems
+---
+## Implementation Guide
+### API Design Patterns
+RESTful API Architecture:
+```python
+from fastapi import FastAPI, Depends, HTTPException
+from fastapi.security import HTTPBearer
+from pydantic import BaseModel
+from typing import List, Optional
+app = FastAPI(title="Modern API", version="2.0.0")
+security = HTTPBearer()
+class UserResponse(BaseModel):
+ id: int
+ email: str
+ name: str
+@app.get("/users", response_model=List[UserResponse])
+async def list_users(token: str = Depends(security)):
+ """List users with authentication."""
+ return await user_service.get_all_users()
+@app.post("/users", response_model=UserResponse)
+async def create_user(user: UserCreate):
+ """Create new user with validation."""
+ return await user_service.create(user)
+```
+GraphQL Implementation:
+```python
+import strawberry
+from typing import List
+@strawberry.type
+class User:
+ id: int
+ email: str
+ name: str
+@strawberry.type
+class Query:
+ @strawberry.field
+ async def users(self) -> List[User]:
+ return await user_service.get_all_users()
+schema = strawberry.Schema(query=Query)
+```
+### Database Integration Patterns
+PostgreSQL with SQLAlchemy:
+```python
+from sqlalchemy import create_engine, Column, Integer, String
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+Base = declarative_base()
+class User(Base):
+ __tablename__ = "users"
+ id = Column(Integer, primary_key=True)
+ email = Column(String, unique=True)
+ name = Column(String)
+# Connection pooling and optimization
+engine = create_engine(
+ DATABASE_URL,
+ pool_size=20,
+ max_overflow=30,
+ pool_pre_ping=True
+)
+```
+MongoDB with Motor:
+```python
+from motor.motor_asyncio import AsyncIOMotorClient
+from pymongo import IndexModel
+class UserService:
+ def __init__(self, client: AsyncIOMotorClient):
+ self.db = client.myapp
+ self.users = self.db.users
+ # Index optimization
+ self.users.create_indexes([
+ IndexModel("email", unique=True),
+ IndexModel("created_at")
+ ])
+ async def create_user(self, user_data: dict) -> str:
+ result = await self.users.insert_one(user_data)
+ return str(result.inserted_id)
+```
+### Microservices Architecture
+Service Discovery with Consul:
+```python
+import consul
+class ServiceRegistry:
+ def __init__(self, consul_host="localhost", consul_port=8500):
+ self.consul = consul.Consul(host=consul_host, port=consul_port)
+ def register_service(self, service_name: str, service_id: str, port: int):
+ self.consul.agent.service.register(
+ name=service_name,
+ service_id=service_id,
+ port=port,
+ check=consul.Check.http(f"http://localhost:{port}/health", interval="10s")
+ )
+ def discover_service(self, service_name: str) -> List[str]:
+ _, services = self.consul.health.service(service_name, passing=True)
+ return [f"{s['Service']['Address']}:{s['Service']['Port']}" for s in services]
+```
+Event-Driven Architecture:
+```python
+import asyncio
+from aio_pika import connect_robust
+class EventBus:
+ def __init__(self, amqp_url: str):
+ self.connection = None
+ self.channel = None
+ self.amqp_url = amqp_url
+ async def connect(self):
+ self.connection = await connect_robust(self.amqp_url)
+ self.channel = await self.connection.channel()
+ async def publish_event(self, event_type: str, data: dict):
+ await self.channel.default_exchange.publish(
+ aio_pika.Message(
+ json.dumps({"type": event_type, "data": data}).encode(),
+ content_type="application/json"
+ ),
+ routing_key=event_type
+ )
+```
+---
+## Advanced Patterns
+### Caching Strategies
+Redis Integration:
+```python
+import redis.asyncio as redis
+from functools import wraps
+import json
+import hashlib
+class CacheManager:
+ def __init__(self, redis_url: str):
+ self.redis = redis.from_url(redis_url)
+ def cache_result(self, ttl: int = 3600):
+ def decorator(func):
+ @wraps(func)
+ async def wrapper(*args, kwargs):
+ cache_key = self._generate_cache_key(func.__name__, args, kwargs)
+ # Try to get from cache
+ cached = await self.redis.get(cache_key)
+ if cached:
+ return json.loads(cached)
+ # Execute function and cache result
+ result = await func(*args, kwargs)
+ await self.redis.setex(
+ cache_key,
+ ttl,
+ json.dumps(result, default=str)
+ )
+ return result
+ return wrapper
+ return decorator
+```
+### Security Implementation
+JWT Authentication:
+```python
+import jwt
+from datetime import datetime, timedelta
+from passlib.context import CryptContext
+class SecurityManager:
+ def __init__(self, secret_key: str):
+ self.secret_key = secret_key
+ self.pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
+ def hash_password(self, password: str) -> str:
+ return self.pwd_context.hash(password)
+ def verify_password(self, plain_password: str, hashed_password: str) -> bool:
+ return self.pwd_context.verify(plain_password, hashed_password)
+ def create_access_token(self, data: dict, expires_delta: timedelta = None) -> str:
+ to_encode = data.copy()
+ if expires_delta:
+ expire = datetime.utcnow() + expires_delta
+ else:
+ expire = datetime.utcnow() + timedelta(minutes=15)
+ to_encode.update({"exp": expire})
+ return jwt.encode(to_encode, self.secret_key, algorithm="HS256")
+```
+### Performance Optimization
+Database Connection Pooling:
+```python
+from sqlalchemy.pool import QueuePool
+from sqlalchemy import event
+def create_optimized_engine(database_url: str):
+ engine = create_engine(
+ database_url,
+ poolclass=QueuePool,
+ pool_size=20,
+ max_overflow=30,
+ pool_pre_ping=True,
+ pool_recycle=3600,
+ echo=False
+ )
+ @event.listens_for(engine, "before_cursor_execute")
+ def receive_before_cursor_execute(conn, cursor, statement, parameters, context, executemany):
+ context._query_start_time = time.time()
+ @event.listens_for(engine, "after_cursor_execute")
+ def receive_after_cursor_execute(conn, cursor, statement, parameters, context, executemany):
+ total = time.time() - context._query_start_time
+ if total > 0.1: # Log slow queries
+ logger.warning(f"Slow query: {total:.2f}s - {statement[:100]}")
+ return engine
+```
+---
+## Works Well With
+- moai-domain-frontend - Full-stack development integration
+- moai-domain-database - Advanced database patterns
+- moai-integration-mcp - MCP server development for backend services
+- moai-quality-security - Security validation and compliance
+- moai-foundation-core - Core architectural principles
+---
+## Technology Stack
+Primary Technologies:
+- Languages: Python 3.13+, Node.js 20+, Go 1.23
+- Frameworks: FastAPI, Django, Express.js, Gin
+- Databases: PostgreSQL 16+, MongoDB 7+, Redis 7+
+- Message Queues: RabbitMQ, Apache Kafka, Redis Pub/Sub
+- Containerization: Docker, Kubernetes
+- Monitoring: Prometheus, Grafana, OpenTelemetry
+Integration Patterns:
+- RESTful APIs with OpenAPI 3.1
+- GraphQL with Apollo Federation
+- gRPC for high-performance services
+- Event-driven architecture with CQRS
+- API Gateway patterns
+- Circuit breakers and resilience patterns
+---
+Status: Production Ready
+Last Updated: 2025-11-30
+Maintained by: MoAI-ADK Backend Team

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

Potentially problematic release.

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