moai-adk 0.35.1__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-docs-generation/modules/code-documentation.md

@@ -0,0 +1,152 @@
+# Code Documentation Enhancement
+
+## Overview
+AI-powered code documentation generation with AST analysis, automatic docstring enhancement, and multi-format output generation.
+
+## Quick Implementation
+
+```python
+import ast
+import inspect
+from typing import Dict, List, Any
+
+class CodeDocGenerator:
+ def __init__(self, ai_client=None):
+ self.ai_client = ai_client
+
+ def analyze_python_file(self, file_path: str) -> Dict[str, Any]:
+ """Analyze Python file and extract documentation structure."""
+ with open(file_path, 'r', encoding='utf-8') as f:
+ content = f.read()
+
+ tree = ast.parse(content)
+
+ documentation = {
+ "file": file_path,
+ "modules": [],
+ "classes": [],
+ "functions": [],
+ "imports": []
+ }
+
+ for node in ast.walk(tree):
+ if isinstance(node, ast.ClassDef):
+ class_info = self.analyze_class(node)
+ documentation["classes"].append(class_info)
+
+ elif isinstance(node, ast.FunctionDef):
+ if not any(isinstance(parent, ast.ClassDef) for parent in ast.walk(tree)):
+ func_info = self.analyze_function(node)
+ documentation["functions"].append(func_info)
+
+ elif isinstance(node, ast.Import):
+ for alias in node.names:
+ documentation["imports"].append(alias.name)
+
+ return documentation
+
+ def analyze_class(self, class_node: ast.ClassDef) -> Dict[str, Any]:
+ """Analyze class structure and generate documentation."""
+ methods = []
+ properties = []
+
+ for node in class_node.body:
+ if isinstance(node, ast.FunctionDef):
+ method_info = self.analyze_function(node)
+ methods.append(method_info)
+
+ elif isinstance(node, ast.AnnAssign) and isinstance(node.target, ast.Name):
+ prop_info = self.analyze_property(node)
+ properties.append(prop_info)
+
+ # Generate enhanced docstring with AI
+ enhanced_docstring = None
+ if self.ai_client:
+ enhanced_docstring = self.enhance_docstring_with_ai(
+ class_node.name,
+ methods,
+ properties,
+ ast.get_docstring(class_node)
+ )
+
+ return {
+ "name": class_node.name,
+ "docstring": ast.get_docstring(class_node),
+ "enhanced_docstring": enhanced_docstring,
+ "methods": methods,
+ "properties": properties,
+ "inheritance": [base.id for base in class_node.bases if isinstance(base, ast.Name)],
+ "decorators": [self.get_decorator_name(dec) for dec in class_node.decorator_list]
+ }
+
+ def enhance_docstring_with_ai(self, name: str, methods: List, properties: List, existing_doc: str = None) -> str:
+ """Enhance documentation using AI analysis."""
+ method_signatures = [method["signature"] for method in methods]
+
+ prompt = f"""
+ Enhance this Python class documentation:
+
+ Class Name: {name}
+ Existing Documentation: {existing_doc or 'No documentation'}
+
+ Methods:
+ {chr(10).join(method_signatures)}
+
+ Properties:
+ {', '.join([prop['name'] for prop in properties])}
+
+ Please provide:
+ 1. Clear class description
+ 2. Usage examples
+ 3. Method descriptions
+ 4. Implementation notes
+ 5. Best practices for using this class
+
+ Format as proper docstring with sections.
+ """
+
+ response = self.ai_client.generate_content(prompt)
+ return response["content"]
+
+ def generate_documentation_files(self, documentation: Dict, output_dir: str):
+ """Generate various documentation files from analysis."""
+ import os
+ from pathlib import Path
+
+ output_path = Path(output_dir)
+ output_path.mkdir(exist_ok=True)
+
+ # Generate README
+ readme_content = self.generate_readme(documentation)
+ (output_path / "README.md").write_text(readme_content, encoding='utf-8')
+
+ # Generate API reference
+ api_content = self.generate_api_reference(documentation)
+ (output_path / "API.md").write_text(api_content, encoding='utf-8')
+
+ # Generate examples
+ examples_content = self.generate_examples(documentation)
+ (output_path / "EXAMPLES.md").write_text(examples_content, encoding='utf-8')
+```
+
+## Key Features
+- AST-based code analysis
+- AI-powered docstring enhancement
+- Automatic documentation structure extraction
+- Multi-format output generation (README, API, Examples)
+- Class hierarchy analysis
+- Method and property documentation
+- Import dependency tracking
+
+## Usage Patterns
+1. Code Analysis: Parse Python files for documentation structure
+2. AI Enhancement: Use AI to improve existing documentation
+3. File Generation: Create comprehensive documentation files
+4. Class Analysis: Extract inheritance, methods, and properties
+5. Documentation Standards: Ensure consistent docstring format
+
+## Integration Points
+- Static analysis tools
+- Documentation generators (Sphinx, MkDocs)
+- AI services for content enhancement
+- Code review workflows

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

@@ -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

@@ -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