aia 0.9.11 → 0.9.12

data/docs/examples/mcp/index.md

@@ -0,0 +1,479 @@
+# MCP Examples
+
+Collection of Model Context Protocol (MCP) client examples and configurations for extending AIA with external services.
+
+## Available MCP Clients
+
+### GitHub Integration
+- **github_analyzer.py** - Comprehensive GitHub repository analysis
+- **github_issue_manager.js** - Issue tracking and management
+- **github_pr_analyzer.py** - Pull request analysis and review
+- **github_metrics.rb** - Repository metrics and statistics
+
+### File System Access
+- **filesystem_analyzer.py** - Safe file system analysis
+- **directory_scanner.js** - Directory structure analysis
+- **file_watcher.py** - File change monitoring
+- **backup_manager.go** - File backup and versioning
+
+### Database Integration
+- **postgres_analyzer.py** - PostgreSQL database analysis
+- **mysql_connector.js** - MySQL database operations
+- **sqlite_manager.py** - SQLite database management
+- **schema_validator.rb** - Database schema validation
+
+### API Integration
+- **rest_client.py** - RESTful API client and testing
+- **graphql_client.js** - GraphQL query and analysis
+- **webhook_server.py** - Webhook handling and processing
+- **api_monitor.go** - API performance monitoring
+
+### Development Tools
+- **docker_manager.py** - Docker container management
+- **kubernetes_analyzer.js** - Kubernetes cluster analysis
+- **ci_cd_monitor.py** - CI/CD pipeline monitoring
+- **log_aggregator.rb** - Distributed log collection
+
+## MCP Client Structure
+
+MCP clients follow the Model Context Protocol specification:
+
+### Python MCP Server
+```python
+from mcp.server import Server
+from mcp.types import Resource, Tool, TextContent
+import asyncio
+
+server = Server("client-name", "1.0.0")
+
+@server.list_tools()
+async def list_tools():
+    return [
+        Tool(
+            name="tool_name",
+            description="Tool description",
+            inputSchema={
+                "type": "object",
+                "properties": {
+                    "param": {"type": "string"}
+                },
+                "required": ["param"]
+            }
+        )
+    ]
+
+@server.call_tool()
+async def call_tool(name: str, arguments: dict):
+    if name == "tool_name":
+        result = process_request(arguments["param"])
+        return TextContent(type="text", text=result)
+
+if __name__ == "__main__":
+    asyncio.run(server.run())
+```
+
+### Node.js MCP Server
+```javascript
+const { Server } = require('@anthropic-ai/mcp-sdk/server');
+
+const server = new Server('client-name', '1.0.0');
+
+server.setRequestHandler('tools/list', async () => {
+  return {
+    tools: [{
+      name: 'tool_name',
+      description: 'Tool description',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          param: { type: 'string' }
+        },
+        required: ['param']
+      }
+    }]
+  };
+});
+
+server.setRequestHandler('tools/call', async (request) => {
+  const { name, arguments: args } = request.params;
+  
+  if (name === 'tool_name') {
+    const result = processRequest(args.param);
+    return { content: [{ type: 'text', text: result }] };
+  }
+});
+
+server.connect();
+```
+
+## Configuration Examples
+
+### Basic MCP Configuration
+```yaml
+# ~/.aia/config.yml
+mcp:
+  enabled: true
+  clients:
+    - name: github
+      command: ["python", "github_analyzer.py"]
+      env:
+        GITHUB_TOKEN: "${GITHUB_TOKEN}"
+        
+    - name: filesystem
+      command: ["node", "filesystem_analyzer.js"]
+      args: ["/allowed/path"]
+      
+    - name: database
+      command: ["python", "postgres_analyzer.py"]
+      env:
+        DATABASE_URL: "${DATABASE_URL}"
+```
+
+### Advanced MCP Configuration
+```yaml
+mcp:
+  enabled: true
+  security:
+    sandbox_mode: true
+    timeout: 30000  # 30 seconds
+    max_memory: "512MB"
+    
+  clients:
+    - name: github
+      command: ["python", "mcp_clients/github_analyzer.py"]
+      working_directory: "/opt/aia-mcp"
+      env:
+        GITHUB_TOKEN: "${GITHUB_TOKEN}"
+        LOG_LEVEL: "INFO"
+      security:
+        network_access: true
+        file_access: false
+        
+    - name: filesystem
+      command: ["node", "mcp_clients/filesystem_analyzer.js"]
+      args: ["/home/user/projects", "/tmp/workspace"]
+      security:
+        network_access: false
+        file_access: true
+        allowed_paths: ["/home/user/projects", "/tmp"]
+        
+    - name: database
+      command: ["python", "mcp_clients/postgres_analyzer.py"]
+      env:
+        DATABASE_URL: "${READ_ONLY_DB_URL}"
+        MAX_QUERY_TIME: "10000"
+      security:
+        network_access: true
+        file_access: false
+        read_only: true
+```
+
+## Usage Examples
+
+### GitHub Repository Analysis
+```bash
+# Configure GitHub MCP client
+export GITHUB_TOKEN="your_github_token"
+
+# Use in AIA prompt
+aia --mcp github repo_analysis --owner microsoft --repo vscode
+```
+
+```markdown
+# github_analysis.txt
+//mcp github
+
+# GitHub Repository Analysis
+
+Repository: <%= owner %>/<%= repo %>
+
+Analyze the repository and provide:
+1. Repository health and activity metrics
+2. Code quality and organization assessment
+3. Issue and PR management effectiveness
+4. Contributor activity and patterns
+5. Security and maintenance status
+
+Generate comprehensive analysis with recommendations.
+```
+
+### Database Schema Analysis
+```bash
+# Configure database MCP client
+export DATABASE_URL="postgresql://user:pass@localhost/db"
+
+# Use in AIA prompt
+aia --mcp database schema_analysis --schema public
+```
+
+```markdown
+# database_analysis.txt
+//mcp database
+
+# Database Schema Analysis
+
+Schema: <%= schema %>
+
+Perform comprehensive database analysis:
+1. Table structure and relationships
+2. Index optimization opportunities
+3. Data quality assessment
+4. Performance bottlenecks
+5. Security considerations
+
+Provide actionable optimization recommendations.
+```
+
+### Multi-Client Integration
+```markdown
+# comprehensive_project_audit.txt
+//mcp github,filesystem,database
+
+# Comprehensive Project Audit
+
+Project: <%= project_name %>
+
+## Phase 1: Repository Analysis (GitHub MCP)
+- Repository health and activity
+- Code review processes
+- Issue management effectiveness
+- Release and deployment practices
+
+## Phase 2: File System Analysis (Filesystem MCP)
+- Project structure and organization
+- Configuration management
+- Documentation completeness
+- Security file analysis
+
+## Phase 3: Database Analysis (Database MCP)
+- Schema design and integrity
+- Performance optimization
+- Data quality assessment
+- Security configuration
+
+## Integration Analysis
+Cross-analyze findings from all systems to identify:
+- Consistency across different layers
+- Integration gaps and opportunities
+- Security vulnerabilities
+- Performance optimization priorities
+
+Generate unified recommendations with implementation priority.
+```
+
+## Security Considerations
+
+### MCP Security Best Practices
+```yaml
+# Secure MCP configuration
+mcp:
+  security:
+    # Global security settings
+    default_timeout: 30000
+    max_memory_per_client: "256MB"
+    sandbox_mode: true
+    
+    # Network restrictions
+    allowed_domains: ["api.github.com", "localhost"]
+    blocked_domains: ["*.suspicious-domain.com"]
+    
+    # File system restrictions
+    allowed_paths: ["/home/user/projects", "/tmp/aia-workspace"]
+    blocked_paths: ["/etc", "/var", "/usr"]
+    
+  clients:
+    - name: github
+      security_profile: "network_only"
+      allowed_operations: ["read", "list"]
+      blocked_operations: ["write", "delete"]
+      
+    - name: filesystem
+      security_profile: "filesystem_readonly"
+      max_file_size: "10MB"
+      max_files_per_request: 100
+      
+    - name: database
+      security_profile: "database_readonly"
+      query_timeout: 10000
+      max_rows_per_query: 1000
+```
+
+### Access Control
+```python
+# MCP client with access control
+class SecureGitHubAnalyzer:
+    def __init__(self, allowed_operations=None):
+        self.allowed_operations = allowed_operations or ['read', 'list']
+    
+    async def analyze_repository(self, owner, repo):
+        if 'read' not in self.allowed_operations:
+            raise PermissionError("Read access not allowed")
+        
+        # Safe repository analysis
+        return await self._safe_analyze(owner, repo)
+    
+    async def _safe_analyze(self, owner, repo):
+        # Implementation with safety checks
+        pass
+```
+
+## Performance Optimization
+
+### Caching Strategies
+```python
+# MCP client with caching
+import asyncio
+from datetime import datetime, timedelta
+import json
+
+class CachedMCPClient:
+    def __init__(self):
+        self.cache = {}
+        self.cache_ttl = timedelta(hours=1)
+    
+    async def cached_request(self, cache_key, request_func, *args):
+        now = datetime.now()
+        
+        if cache_key in self.cache:
+            cached_result, timestamp = self.cache[cache_key]
+            if now - timestamp < self.cache_ttl:
+                return cached_result
+        
+        # Fetch new data
+        result = await request_func(*args)
+        self.cache[cache_key] = (result, now)
+        return result
+```
+
+### Connection Pooling
+```javascript
+// Node.js MCP client with connection pooling
+const { Pool } = require('pg');
+
+class DatabaseMCPClient {
+  constructor() {
+    this.pool = new Pool({
+      max: 10,
+      idleTimeoutMillis: 30000,
+      connectionTimeoutMillis: 2000,
+    });
+  }
+  
+  async query(sql, params) {
+    const client = await this.pool.connect();
+    try {
+      const result = await client.query(sql, params);
+      return result;
+    } finally {
+      client.release();
+    }
+  }
+}
+```
+
+## Troubleshooting
+
+### Common MCP Issues
+
+#### Connection Failures
+```bash
+# Debug MCP client connections
+aia --debug --mcp github test_connection
+
+# Check client process status
+ps aux | grep mcp
+
+# Test client directly
+python github_analyzer.py --test
+```
+
+#### Protocol Errors
+```yaml
+# Enable detailed MCP logging
+mcp:
+  logging:
+    level: debug
+    file: /var/log/aia-mcp.log
+    include_request_response: true
+    
+  error_handling:
+    retry_attempts: 3
+    retry_delay: 1000
+    fallback_mode: graceful
+```
+
+#### Performance Issues
+```python
+# MCP performance monitoring
+import time
+import logging
+
+class PerformanceMCP:
+    def __init__(self):
+        self.logger = logging.getLogger('mcp_performance')
+    
+    async def timed_operation(self, operation_name, func, *args):
+        start_time = time.time()
+        try:
+            result = await func(*args)
+            duration = time.time() - start_time
+            self.logger.info(f"{operation_name}: {duration:.2f}s")
+            return result
+        except Exception as e:
+            duration = time.time() - start_time
+            self.logger.error(f"{operation_name} failed after {duration:.2f}s: {e}")
+            raise
+```
+
+## Development Guidelines
+
+### MCP Client Development
+1. **Follow Protocol** - Implement MCP specification correctly
+2. **Error Handling** - Comprehensive error handling and reporting
+3. **Security First** - Validate inputs and limit access
+4. **Performance** - Optimize for concurrent requests
+5. **Testing** - Include unit and integration tests
+
+### Example Test Suite
+```python
+# test_github_mcp.py
+import pytest
+import asyncio
+from unittest.mock import patch
+from github_analyzer import GitHubAnalyzer
+
+@pytest.fixture
+def analyzer():
+    return GitHubAnalyzer()
+
+@pytest.mark.asyncio
+async def test_repository_analysis(analyzer):
+    with patch('aiohttp.ClientSession.get') as mock_get:
+        mock_get.return_value.__aenter__.return_value.json.return_value = {
+            'name': 'test-repo',
+            'stargazers_count': 100
+        }
+        
+        result = await analyzer.analyze_repository('owner', 'repo')
+        assert result['repository']['name'] == 'test-repo'
+        assert result['repository']['stars'] == 100
+
+@pytest.mark.asyncio
+async def test_error_handling(analyzer):
+    with patch('aiohttp.ClientSession.get') as mock_get:
+        mock_get.side_effect = Exception("Network error")
+        
+        with pytest.raises(Exception):
+            await analyzer.analyze_repository('owner', 'repo')
+```
+
+## Related Documentation
+
+- [MCP Integration Guide](../../mcp-integration.md) - Detailed MCP integration
+- [Tools Examples](../tools/index.md) - Alternative Ruby tools approach
+- [Advanced Prompting](../../advanced-prompting.md) - Complex MCP usage patterns
+- [Configuration](../../configuration.md) - MCP configuration options
+
+---
+
+MCP clients provide powerful integration capabilities for AIA. Start with simple read-only clients and gradually build more sophisticated integrations as your needs grow!

data/docs/examples/prompts/analysis/index.md

@@ -0,0 +1,78 @@
+# Analysis Prompts
+
+Collection of prompts for data analysis, research, and analytical tasks.
+
+## Available Prompts
+
+### Data Analysis
+- **data_analysis.txt** - Comprehensive data analysis
+- **statistical_analysis.txt** - Statistical analysis and insights
+- **trend_analysis.txt** - Trend identification and analysis
+- **correlation_analysis.txt** - Correlation and relationship analysis
+
+### Research
+- **research_summary.txt** - Research synthesis and summarization
+- **literature_review.txt** - Academic literature review
+- **competitive_analysis.txt** - Competitive landscape analysis
+- **market_research.txt** - Market analysis and insights
+
+### Business Analysis
+- **business_analysis.txt** - Business process analysis
+- **performance_analysis.txt** - Performance metrics analysis
+- **risk_assessment.txt** - Risk analysis and mitigation
+- **opportunity_analysis.txt** - Opportunity identification
+
+### Financial Analysis
+- **financial_analysis.txt** - Financial data analysis
+- **budget_analysis.txt** - Budget review and analysis
+- **roi_analysis.txt** - Return on investment analysis
+- **cost_benefit.txt** - Cost-benefit analysis
+
+### Report Generation
+- **executive_summary.txt** - Executive summary creation
+- **detailed_report.txt** - Comprehensive report generation
+- **dashboard_insights.txt** - Dashboard and metrics interpretation
+- **recommendations.txt** - Actionable recommendations generation
+
+## Usage Examples
+
+```bash
+# Analyze a dataset
+aia data_analysis dataset.csv --focus "sales trends"
+
+# Generate research summary
+aia research_summary research_papers/ --topic "AI trends"
+
+# Create executive summary
+aia executive_summary quarterly_data.xlsx --audience "executives"
+```
+
+## Analysis Workflows
+
+### Data Pipeline
+1. **data_preprocessing.txt** - Clean and prepare data
+2. **exploratory_analysis.txt** - Initial data exploration
+3. **detailed_analysis.txt** - Deep dive analysis
+4. **insight_generation.txt** - Extract actionable insights
+5. **report_creation.txt** - Generate final report
+
+### Research Workflow
+1. **source_collection.txt** - Gather research sources
+2. **content_analysis.txt** - Analyze source content
+3. **synthesis.txt** - Synthesize findings
+4. **gap_analysis.txt** - Identify research gaps
+5. **conclusion.txt** - Draw conclusions
+
+## Customization Parameters
+
+- **Focus Area** - Specific aspect to analyze
+- **Depth Level** - Surface or deep analysis
+- **Audience** - Target audience for results
+- **Format** - Output format (charts, tables, narrative)
+- **Timeframe** - Analysis time period
+
+## Related
+
+- [Development Prompts](../development/index.md) - Code analysis
+- [Automation Prompts](../automation/index.md) - Process analysis
+- [Tools Examples](../../tools/index.md) - Analysis tools

data/docs/examples/prompts/automation/index.md

@@ -0,0 +1,108 @@
+# Automation Prompts
+
+Collection of prompts for system administration, process automation, and workflow management.
+
+## Available Prompts
+
+### System Administration
+- **system_health.txt** - System health monitoring and analysis
+- **log_analysis.txt** - Log file analysis and insights
+- **performance_monitoring.txt** - System performance analysis
+- **security_audit.txt** - Security assessment and audit
+
+### Deployment and DevOps
+- **deployment_checklist.txt** - Deployment readiness assessment
+- **ci_cd_analysis.txt** - CI/CD pipeline analysis
+- **infrastructure_review.txt** - Infrastructure assessment
+- **rollback_procedures.txt** - Rollback planning and procedures
+
+### Process Automation
+- **workflow_optimization.txt** - Process optimization suggestions
+- **task_automation.txt** - Task automation recommendations
+- **monitoring_setup.txt** - Monitoring and alerting setup
+- **maintenance_scheduler.txt** - Maintenance task scheduling
+
+### Configuration Management
+- **config_validation.txt** - Configuration file validation
+- **environment_sync.txt** - Environment synchronization
+- **dependency_check.txt** - Dependency analysis and management
+- **version_management.txt** - Version control and management
+
+### Incident Response
+- **incident_analysis.txt** - Incident investigation and analysis
+- **root_cause_analysis.txt** - Root cause identification
+- **recovery_procedures.txt** - Recovery planning and execution
+- **post_mortem.txt** - Post-incident analysis and learning
+
+## Usage Examples
+
+```bash
+# Analyze system health
+aia system_health --logs /var/log/ --timeframe "24h"
+
+# Validate deployment readiness
+aia deployment_checklist --environment production --service api
+
+# Perform security audit
+aia security_audit --scope "web_application" --depth comprehensive
+```
+
+## Automation Workflows
+
+### Deployment Pipeline
+1. **pre_deployment.txt** - Pre-deployment checks
+2. **deployment_execution.txt** - Deployment process
+3. **post_deployment.txt** - Post-deployment validation
+4. **rollback_if_needed.txt** - Conditional rollback
+5. **deployment_report.txt** - Deployment summary
+
+### Monitoring Setup
+1. **baseline_establishment.txt** - Establish performance baselines
+2. **alert_configuration.txt** - Configure monitoring alerts
+3. **dashboard_creation.txt** - Create monitoring dashboards
+4. **escalation_procedures.txt** - Define escalation paths
+5. **monitoring_validation.txt** - Validate monitoring effectiveness
+
+### Incident Response
+1. **incident_detection.txt** - Initial incident assessment
+2. **impact_analysis.txt** - Assess incident impact
+3. **mitigation_actions.txt** - Define mitigation steps
+4. **communication_plan.txt** - Stakeholder communication
+5. **resolution_verification.txt** - Verify resolution
+
+## Integration Points
+
+### Shell Integration
+```markdown
+//shell systemctl status nginx
+//shell df -h
+//shell top -b -n 1 | head -20
+```
+
+### Tool Integration
+```bash
+# Use with system monitoring tools
+aia --tools system_monitor.rb system_health
+
+# Combine with log analysis tools
+aia --tools log_analyzer.rb incident_analysis /var/log/app.log
+```
+
+### MCP Integration
+```markdown
+//mcp filesystem,monitoring
+```
+
+## Customization Parameters
+
+- **Environment** - target environment (dev, staging, prod)
+- **Service** - specific service or application
+- **Timeframe** - analysis time window
+- **Depth** - analysis depth level
+- **Scope** - analysis scope and boundaries
+
+## Related
+
+- [Development Prompts](../development/index.md) - Development automation
+- [Analysis Prompts](../analysis/index.md) - System analysis
+- [MCP Examples](../../mcp/index.md) - External system integration