aigroup-workflow 2.1.2 → 2.2.0

package/skills/legacy-modernizer/references/system-assessment.md

@@ -1,487 +0,0 @@
-# System Assessment
-
-## Codebase Analysis Checklist
-
-```python
-# Automated assessment script
-from pathlib import Path
-import ast
-import re
-from collections import defaultdict
-
-class LegacyCodeAnalyzer:
-    def __init__(self, codebase_path: Path):
-        self.path = codebase_path
-        self.metrics = defaultdict(int)
-        self.issues = []
-
-    def analyze(self):
-        """Run comprehensive analysis"""
-        self.count_lines_of_code()
-        self.analyze_dependencies()
-        self.find_code_smells()
-        self.check_test_coverage()
-        self.identify_hotspots()
-        return self.generate_report()
-
-    def count_lines_of_code(self):
-        """Basic size metrics"""
-        for py_file in self.path.rglob("*.py"):
-            with open(py_file) as f:
-                lines = f.readlines()
-                self.metrics['total_lines'] += len(lines)
-                self.metrics['files'] += 1
-
-                # Count code vs comments
-                code_lines = [l for l in lines if l.strip() and not l.strip().startswith('#')]
-                self.metrics['code_lines'] += len(code_lines)
-
-    def analyze_dependencies(self):
-        """Find external and internal dependencies"""
-        dependencies = set()
-
-        for py_file in self.path.rglob("*.py"):
-            with open(py_file) as f:
-                tree = ast.parse(f.read())
-
-            for node in ast.walk(tree):
-                if isinstance(node, ast.Import):
-                    for alias in node.names:
-                        dependencies.add(alias.name.split('.')[0])
-                elif isinstance(node, ast.ImportFrom):
-                    if node.module:
-                        dependencies.add(node.module.split('.')[0])
-
-        self.metrics['dependencies'] = len(dependencies)
-        self.dependencies = dependencies
-
-    def find_code_smells(self):
-        """Detect common legacy code issues"""
-        for py_file in self.path.rglob("*.py"):
-            with open(py_file) as f:
-                content = f.read()
-                tree = ast.parse(content)
-
-            # Long functions
-            for node in ast.walk(tree):
-                if isinstance(node, ast.FunctionDef):
-                    func_length = node.end_lineno - node.lineno
-                    if func_length > 50:
-                        self.issues.append({
-                            'type': 'long_function',
-                            'file': str(py_file),
-                            'function': node.name,
-                            'lines': func_length,
-                        })
-
-            # Global variables
-            if re.search(r'^[A-Z_]+ = ', content, re.MULTILINE):
-                self.metrics['global_vars'] += len(
-                    re.findall(r'^[A-Z_]+ = ', content, re.MULTILINE)
-                )
-
-            # SQL in code (sign of tight coupling)
-            if re.search(r'(SELECT|INSERT|UPDATE|DELETE)\s+', content, re.IGNORECASE):
-                self.metrics['raw_sql'] += 1
-                self.issues.append({
-                    'type': 'raw_sql',
-                    'file': str(py_file),
-                })
-
-    def check_test_coverage(self):
-        """Calculate test coverage"""
-        test_files = list(self.path.rglob("test_*.py"))
-        self.metrics['test_files'] = len(test_files)
-        self.metrics['test_coverage_estimate'] = (
-            len(test_files) / max(self.metrics['files'], 1) * 100
-        )
-
-    def identify_hotspots(self):
-        """Find files changed most often (requires git)"""
-        import subprocess
-
-        try:
-            result = subprocess.run(
-                ['git', 'log', '--format=format:', '--name-only'],
-                cwd=self.path,
-                capture_output=True,
-                text=True,
-            )
-
-            file_changes = defaultdict(int)
-            for line in result.stdout.split('\n'):
-                if line.strip():
-                    file_changes[line.strip()] += 1
-
-            # Top 10 changed files
-            self.hotspots = sorted(
-                file_changes.items(),
-                key=lambda x: x[1],
-                reverse=True
-            )[:10]
-        except Exception:
-            self.hotspots = []
-
-    def generate_report(self):
-        """Generate assessment report"""
-        return {
-            'summary': {
-                'total_files': self.metrics['files'],
-                'total_lines': self.metrics['total_lines'],
-                'code_lines': self.metrics['code_lines'],
-                'dependencies': self.metrics['dependencies'],
-                'test_coverage_estimate': f"{self.metrics['test_coverage_estimate']:.1f}%",
-            },
-            'issues': {
-                'long_functions': len([i for i in self.issues if i['type'] == 'long_function']),
-                'raw_sql_usage': self.metrics['raw_sql'],
-                'global_variables': self.metrics['global_vars'],
-            },
-            'hotspots': self.hotspots,
-            'detailed_issues': self.issues[:20],  # Top 20 issues
-        }
-
-# Usage
-analyzer = LegacyCodeAnalyzer(Path('./legacy_app'))
-report = analyzer.analyze()
-print(json.dumps(report, indent=2))
-```
-
-## Dependency Analysis
-
-```python
-# Identify circular dependencies and tight coupling
-import subprocess
-import json
-from pathlib import Path
-from collections import defaultdict
-
-def analyze_dependencies(project_path: Path):
-    """Map internal module dependencies"""
-    dependencies = defaultdict(set)
-
-    for py_file in project_path.rglob("*.py"):
-        module_name = str(py_file.relative_to(project_path)).replace('/', '.').replace('.py', '')
-
-        with open(py_file) as f:
-            tree = ast.parse(f.read())
-
-        for node in ast.walk(tree):
-            if isinstance(node, ast.ImportFrom):
-                if node.module and not node.module.startswith('.'):
-                    # Internal imports only
-                    if node.module.split('.')[0] in ['app', 'lib', 'models']:
-                        dependencies[module_name].add(node.module)
-
-    return dependencies
-
-def find_circular_dependencies(dependencies: dict):
-    """Detect circular dependencies"""
-    circular = []
-
-    def has_path(start, end, visited=None):
-        if visited is None:
-            visited = set()
-        if start == end:
-            return True
-        if start in visited:
-            return False
-        visited.add(start)
-        for dep in dependencies.get(start, []):
-            if has_path(dep, end, visited):
-                return True
-        return False
-
-    for module, deps in dependencies.items():
-        for dep in deps:
-            if has_path(dep, module):
-                circular.append((module, dep))
-
-    return circular
-
-# Visualize dependency graph
-def generate_dependency_graph(dependencies: dict, output_file: str):
-    """Generate GraphViz diagram"""
-    dot_lines = ["digraph dependencies {"]
-
-    for module, deps in dependencies.items():
-        for dep in deps:
-            dot_lines.append(f'    "{module}" -> "{dep}";')
-
-    dot_lines.append("}")
-
-    Path(output_file).write_text('\n'.join(dot_lines))
-    print(f"Generated {output_file} - render with: dot -Tpng {output_file} -o deps.png")
-```
-
-## Technical Debt Calculation
-
-```python
-from datetime import datetime, timedelta
-
-class TechnicalDebtCalculator:
-    """Calculate technical debt using SQALE method"""
-
-    SEVERITY_MULTIPLIERS = {
-        'critical': 1.0,   # 1 day to fix
-        'major': 0.5,      # 4 hours
-        'minor': 0.25,     # 2 hours
-        'info': 0.1,       # 30 min
-    }
-
-    def __init__(self):
-        self.debt_items = []
-
-    def add_issue(self, issue_type: str, severity: str, count: int = 1):
-        """Add technical debt item"""
-        days_to_fix = self.SEVERITY_MULTIPLIERS[severity] * count
-        self.debt_items.append({
-            'type': issue_type,
-            'severity': severity,
-            'count': count,
-            'effort_days': days_to_fix,
-        })
-
-    def calculate_total_debt(self):
-        """Calculate total remediation effort"""
-        total_days = sum(item['effort_days'] for item in self.debt_items)
-        return {
-            'total_days': round(total_days, 1),
-            'total_weeks': round(total_days / 5, 1),
-            'estimated_cost': round(total_days * 800, 2),  # $800/day avg
-            'breakdown': self.debt_items,
-        }
-
-# Usage based on code analysis
-debt_calc = TechnicalDebtCalculator()
-
-# From static analysis results
-debt_calc.add_issue('long_functions', 'major', count=45)
-debt_calc.add_issue('circular_dependencies', 'critical', count=8)
-debt_calc.add_issue('missing_tests', 'major', count=120)
-debt_calc.add_issue('security_vulnerabilities', 'critical', count=12)
-debt_calc.add_issue('deprecated_dependencies', 'major', count=15)
-debt_calc.add_issue('code_duplication', 'minor', count=89)
-
-report = debt_calc.calculate_total_debt()
-# Output: ~95 days of work, ~19 weeks, ~$76,000
-```
-
-## Risk Assessment Matrix
-
-```python
-from enum import Enum
-
-class Risk(Enum):
-    LOW = 1
-    MEDIUM = 2
-    HIGH = 3
-    CRITICAL = 4
-
-class RiskAssessment:
-    def __init__(self):
-        self.risks = []
-
-    def assess(self, area: str, impact: Risk, probability: Risk, mitigation: str):
-        """Assess risk for modernization area"""
-        risk_score = impact.value * probability.value
-
-        self.risks.append({
-            'area': area,
-            'impact': impact.name,
-            'probability': probability.name,
-            'score': risk_score,
-            'severity': self._get_severity(risk_score),
-            'mitigation': mitigation,
-        })
-
-    def _get_severity(self, score: int) -> str:
-        if score >= 12:
-            return 'CRITICAL'
-        elif score >= 8:
-            return 'HIGH'
-        elif score >= 4:
-            return 'MEDIUM'
-        else:
-            return 'LOW'
-
-    def get_prioritized_risks(self):
-        """Return risks sorted by severity"""
-        return sorted(self.risks, key=lambda r: r['score'], reverse=True)
-
-# Example risk assessment
-risks = RiskAssessment()
-
-risks.assess(
-    area="Database migration",
-    impact=Risk.CRITICAL,
-    probability=Risk.MEDIUM,
-    mitigation="Implement dual-write pattern with comprehensive monitoring"
-)
-
-risks.assess(
-    area="Authentication system upgrade",
-    impact=Risk.CRITICAL,
-    probability=Risk.LOW,
-    mitigation="Shadow testing in production, feature flags for rollback"
-)
-
-risks.assess(
-    area="UI framework migration",
-    impact=Risk.MEDIUM,
-    probability=Risk.MEDIUM,
-    mitigation="Incremental component replacement, A/B testing"
-)
-
-risks.assess(
-    area="Legacy API deprecation",
-    impact=Risk.HIGH,
-    probability=Risk.HIGH,
-    mitigation="12-month sunset period, client migration support, versioning"
-)
-
-for risk in risks.get_prioritized_risks():
-    print(f"{risk['severity']}: {risk['area']}")
-```
-
-## Modernization Roadmap Template
-
-```python
-from dataclasses import dataclass
-from datetime import date, timedelta
-from typing import List
-
-@dataclass
-class MigrationPhase:
-    name: str
-    description: str
-    duration_weeks: int
-    dependencies: List[str]
-    success_metrics: dict
-    rollback_plan: str
-
-class ModernizationRoadmap:
-    def __init__(self, start_date: date):
-        self.start_date = start_date
-        self.phases = []
-
-    def add_phase(self, phase: MigrationPhase):
-        self.phases.append(phase)
-
-    def generate_timeline(self):
-        """Generate week-by-week timeline"""
-        timeline = []
-        current_date = self.start_date
-
-        for phase in self.phases:
-            end_date = current_date + timedelta(weeks=phase.duration_weeks)
-            timeline.append({
-                'phase': phase.name,
-                'start': current_date.isoformat(),
-                'end': end_date.isoformat(),
-                'duration_weeks': phase.duration_weeks,
-                'dependencies': phase.dependencies,
-            })
-            current_date = end_date
-
-        return timeline
-
-# Example roadmap
-roadmap = ModernizationRoadmap(start_date=date(2024, 1, 1))
-
-roadmap.add_phase(MigrationPhase(
-    name="Assessment & Planning",
-    description="Code analysis, dependency mapping, risk assessment",
-    duration_weeks=2,
-    dependencies=[],
-    success_metrics={'assessment_complete': True, 'roadmap_approved': True},
-    rollback_plan="N/A - planning phase"
-))
-
-roadmap.add_phase(MigrationPhase(
-    name="Test Coverage",
-    description="Build characterization tests for critical paths",
-    duration_weeks=4,
-    dependencies=["Assessment & Planning"],
-    success_metrics={'coverage': '80%', 'characterization_tests': 200},
-    rollback_plan="Continue with existing tests"
-))
-
-roadmap.add_phase(MigrationPhase(
-    name="Database Migration Setup",
-    description="Implement dual-write pattern, lazy migration",
-    duration_weeks=3,
-    dependencies=["Test Coverage"],
-    success_metrics={'dual_write_working': True, 'data_consistency': '99.9%'},
-    rollback_plan="Disable dual-write, continue legacy DB only"
-))
-
-roadmap.add_phase(MigrationPhase(
-    name="Service Extraction - Phase 1",
-    description="Extract payment service using strangler fig",
-    duration_weeks=6,
-    dependencies=["Database Migration Setup"],
-    success_metrics={'service_deployed': True, 'error_rate': '<0.1%', 'traffic': '100%'},
-    rollback_plan="Route 100% traffic back to monolith via feature flag"
-))
-
-timeline = roadmap.generate_timeline()
-```
-
-## Stakeholder Communication Template
-
-```python
-# Weekly status report generator
-from datetime import datetime
-
-class ModernizationStatusReport:
-    def __init__(self, week_number: int):
-        self.week = week_number
-        self.completed = []
-        self.in_progress = []
-        self.blockers = []
-        self.metrics = {}
-
-    def generate_report(self) -> str:
-        """Generate stakeholder-friendly report"""
-        return f"""
-# Legacy Modernization - Week {self.week} Status
-
-## Executive Summary
-- **Progress**: {self._calculate_progress()}% complete
-- **On Track**: {'Yes' if not self.blockers else 'Blocked'}
-- **Risk Level**: {self._assess_risk_level()}
-
-## This Week's Accomplishments
-{self._format_list(self.completed)}
-
-## In Progress
-{self._format_list(self.in_progress)}
-
-## Blockers & Risks
-{self._format_list(self.blockers) if self.blockers else '- None'}
-
-## Key Metrics
-{self._format_metrics()}
-
-## Next Week's Goals
-{self._format_list(self.next_week_goals)}
-        """.strip()
-
-    def _format_list(self, items: list) -> str:
-        return '\n'.join(f"- {item}" for item in items)
-
-    def _format_metrics(self) -> str:
-        return '\n'.join(f"- {k}: {v}" for k, v in self.metrics.items())
-```
-
-## Quick Reference
-
-| Assessment Area | Tools | Output |
-|----------------|-------|--------|
-| Code Quality | pylint, radon, sonarqube | Complexity, issues |
-| Dependencies | pipdeptree, pydeps | Graph, circular deps |
-| Technical Debt | SonarQube, CodeClimate | Debt hours, cost |
-| Test Coverage | coverage.py, pytest-cov | Percentage, gaps |
-| Security | bandit, safety | Vulnerabilities |
-| Performance | cProfile, py-spy | Bottlenecks |

package/skills/mcp-developer/SKILL.md

@@ -1,143 +0,0 @@
----
-name: mcp-developer
-description: Use when building, debugging, or extending MCP servers or clients that connect AI systems with external tools and data sources. Invoke to implement tool handlers, configure resource providers, set up stdio/HTTP/SSE transport layers, validate schemas with Zod or Pydantic, debug protocol compliance issues, or scaffold complete MCP server/client projects using TypeScript or Python SDKs.
-license: MIT
-metadata:
-  author: https://github.com/Jeffallan
-  version: "1.1.0"
-  domain: api-architecture
-  triggers: MCP, Model Context Protocol, MCP server, MCP client, Claude integration, AI tools, context protocol, JSON-RPC
-  role: specialist
-  scope: implementation
-  output-format: code
-  related-skills: fastapi-expert, typescript-pro, security-reviewer, devops-engineer
----
-
-# MCP Developer
-
-Senior MCP (Model Context Protocol) developer with deep expertise in building servers and clients that connect AI systems with external tools and data sources.
-
-## Core Workflow
-
-1. **Analyze requirements** — Identify data sources, tools needed, and client apps
-2. **Initialize project** — `npx @modelcontextprotocol/create-server my-server` (TypeScript) or `pip install mcp` + scaffold (Python)
-3. **Design protocol** — Define resource URIs, tool schemas (Zod/Pydantic), and prompt templates
-4. **Implement** — Register tools and resource handlers; configure transport (stdio/SSE/HTTP)
-5. **Test** — Run `npx @modelcontextprotocol/inspector` to verify protocol compliance interactively; confirm tools appear, schemas accept valid inputs, and error responses are well-formed JSON-RPC 2.0. **Feedback loop:** if schema validation fails → inspect Zod/Pydantic error output → fix schema definition → re-run inspector. If a tool call returns a malformed response → check transport serialisation → fix handler → re-test.
-6. **Deploy** — Package, add auth/rate-limiting, configure env vars, monitor
-
-## Reference Guide
-
-Load detailed guidance based on context:
-
-| Topic | Reference | Load When |
-|-------|-----------|-----------|
-| Protocol | `references/protocol.md` | Message types, lifecycle, JSON-RPC 2.0 |
-| TypeScript SDK | `references/typescript-sdk.md` | Building servers/clients in Node.js |
-| Python SDK | `references/python-sdk.md` | Building servers/clients in Python |
-| Tools | `references/tools.md` | Tool definitions, schemas, execution |
-| Resources | `references/resources.md` | Resource providers, URIs, templates |
-
-## Minimal Working Example
-
-### TypeScript — Tool with Zod Validation
-
-```typescript
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { z } from "zod";
-
-const server = new McpServer({ name: "my-server", version: "1.1.0" });
-
-// Register a tool with validated input schema
-server.tool(
-  "get_weather",
-  "Fetch current weather for a location",
-  {
-    location: z.string().min(1).describe("City name or coordinates"),
-    units: z.enum(["celsius", "fahrenheit"]).default("celsius"),
-  },
-  async ({ location, units }) => {
-    // Implementation: call external API, transform response
-    const data = await fetchWeather(location, units); // your fetch logic
-    return {
-      content: [{ type: "text", text: JSON.stringify(data) }],
-    };
-  }
-);
-
-// Register a resource provider
-server.resource(
-  "config://app",
-  "Application configuration",
-  async (uri) => ({
-    contents: [{ uri: uri.href, text: JSON.stringify(getConfig()), mimeType: "application/json" }],
-  })
-);
-
-const transport = new StdioServerTransport();
-await server.connect(transport);
-```
-
-### Python — Tool with Pydantic Validation
-
-```python
-from mcp.server.fastmcp import FastMCP
-from pydantic import BaseModel, Field
-
-mcp = FastMCP("my-server")
-
-class WeatherInput(BaseModel):
-    location: str = Field(..., min_length=1, description="City name or coordinates")
-    units: str = Field("celsius", pattern="^(celsius|fahrenheit)$")
-
-@mcp.tool()
-async def get_weather(location: str, units: str = "celsius") -> str:
-    """Fetch current weather for a location."""
-    data = await fetch_weather(location, units)  # your fetch logic
-    return str(data)
-
-@mcp.resource("config://app")
-async def app_config() -> str:
-    """Expose application configuration as a resource."""
-    return json.dumps(get_config())
-
-if __name__ == "__main__":
-    mcp.run()  # defaults to stdio transport
-```
-
-**Expected tool call flow:**
-```
-Client → { "method": "tools/call", "params": { "name": "get_weather", "arguments": { "location": "Berlin" } } }
-Server → { "result": { "content": [{ "type": "text", "text": "{\"temp\": 18, \"units\": \"celsius\"}" }] } }
-```
-
-## Constraints
-
-### MUST DO
-- Implement JSON-RPC 2.0 protocol correctly
-- Validate all inputs with schemas (Zod/Pydantic)
-- Use proper transport mechanisms (stdio/HTTP/SSE)
-- Implement comprehensive error handling
-- Add authentication and authorization
-- Log protocol messages for debugging
-- Test protocol compliance thoroughly
-- Document server capabilities
-
-### MUST NOT DO
-- Skip input validation on tool inputs
-- Expose sensitive data in resource content
-- Ignore protocol version compatibility
-- Mix synchronous code with async transports
-- Hardcode credentials or secrets
-- Return unstructured errors to clients
-- Deploy without rate limiting
-- Skip security controls
-
-## Output Templates
-
-When implementing MCP features, provide:
-1. Server/client implementation file
-2. Schema definitions (tools, resources, prompts)
-3. Configuration file (transport, auth, etc.)
-4. Brief explanation of design decisions