aigroup-workflow 2.1.1 → 2.2.0

package/skills/mcp-developer/references/typescript-sdk.md

@@ -1,350 +0,0 @@
-# TypeScript SDK Implementation
-
-## Installation
-
-```bash
-npm install @modelcontextprotocol/sdk zod
-```
-
-## Basic Server Setup
-
-```typescript
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import {
-  CallToolRequestSchema,
-  ListToolsRequestSchema,
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-import { z } from "zod";
-
-// Create server instance
-const server = new Server(
-  {
-    name: "example-server",
-    version: "1.0.0",
-  },
-  {
-    capabilities: {
-      resources: {},
-      tools: {},
-      prompts: {},
-    },
-  }
-);
-
-// Handle tools/list request
-server.setRequestHandler(ListToolsRequestSchema, async () => {
-  return {
-    tools: [
-      {
-        name: "get_weather",
-        description: "Get current weather for a location",
-        inputSchema: {
-          type: "object",
-          properties: {
-            location: {
-              type: "string",
-              description: "City name or zip code",
-            },
-            units: {
-              type: "string",
-              enum: ["celsius", "fahrenheit"],
-              default: "celsius",
-            },
-          },
-          required: ["location"],
-        },
-      },
-    ],
-  };
-});
-
-// Handle tools/call request
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  if (request.params.name === "get_weather") {
-    const location = String(request.params.arguments?.location);
-    const units = String(request.params.arguments?.units ?? "celsius");
-
-    // Your tool logic here
-    const weatherData = await fetchWeather(location, units);
-
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Weather in ${location}: ${weatherData.temp}°${units === "celsius" ? "C" : "F"}`,
-        },
-      ],
-    };
-  }
-
-  throw new Error(`Unknown tool: ${request.params.name}`);
-});
-
-// Start server with stdio transport
-async function main() {
-  const transport = new StdioServerTransport();
-  await server.connect(transport);
-  console.error("MCP Server running on stdio");
-}
-
-main().catch(console.error);
-```
-
-## Resource Provider
-
-```typescript
-import {
-  ListResourcesRequestSchema,
-  ReadResourceRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-
-// List resources
-server.setRequestHandler(ListResourcesRequestSchema, async () => {
-  return {
-    resources: [
-      {
-        uri: "file:///config/settings.json",
-        name: "Application Settings",
-        description: "Current application configuration",
-        mimeType: "application/json",
-      },
-      {
-        uri: "db://users/schema",
-        name: "User Schema",
-        description: "Database schema for users table",
-        mimeType: "text/plain",
-      },
-    ],
-  };
-});
-
-// Read resource content
-server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-  const uri = request.params.uri;
-
-  if (uri === "file:///config/settings.json") {
-    const settings = await loadSettings();
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "application/json",
-          text: JSON.stringify(settings, null, 2),
-        },
-      ],
-    };
-  }
-
-  if (uri.startsWith("db://users/")) {
-    const schema = await getDatabaseSchema("users");
-    return {
-      contents: [
-        {
-          uri,
-          mimeType: "text/plain",
-          text: schema,
-        },
-      ],
-    };
-  }
-
-  throw new Error(`Resource not found: ${uri}`);
-});
-```
-
-## Prompt Templates
-
-```typescript
-import {
-  ListPromptsRequestSchema,
-  GetPromptRequestSchema,
-} from "@modelcontextprotocol/sdk/types.js";
-
-server.setRequestHandler(ListPromptsRequestSchema, async () => {
-  return {
-    prompts: [
-      {
-        name: "code_review",
-        description: "Generate code review comments",
-        arguments: [
-          {
-            name: "language",
-            description: "Programming language",
-            required: true,
-          },
-          {
-            name: "code",
-            description: "Code to review",
-            required: true,
-          },
-        ],
-      },
-    ],
-  };
-});
-
-server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-  if (request.params.name === "code_review") {
-    const language = String(request.params.arguments?.language);
-    const code = String(request.params.arguments?.code);
-
-    return {
-      messages: [
-        {
-          role: "user",
-          content: {
-            type: "text",
-            text: `Review this ${language} code and provide feedback:\n\n${code}`,
-          },
-        },
-      ],
-    };
-  }
-
-  throw new Error(`Unknown prompt: ${request.params.name}`);
-});
-```
-
-## Input Validation with Zod
-
-```typescript
-import { z } from "zod";
-
-// Define schemas for validation
-const WeatherArgsSchema = z.object({
-  location: z.string().min(1),
-  units: z.enum(["celsius", "fahrenheit"]).default("celsius"),
-});
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  if (request.params.name === "get_weather") {
-    // Validate and parse arguments
-    const args = WeatherArgsSchema.parse(request.params.arguments);
-
-    const weatherData = await fetchWeather(args.location, args.units);
-
-    return {
-      content: [
-        {
-          type: "text",
-          text: `Temperature: ${weatherData.temp}°${args.units === "celsius" ? "C" : "F"}`,
-        },
-      ],
-    };
-  }
-
-  throw new Error(`Unknown tool: ${request.params.name}`);
-});
-```
-
-## Error Handling
-
-```typescript
-import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
-
-server.setRequestHandler(CallToolRequestSchema, async (request) => {
-  try {
-    // Validate input
-    if (!request.params.arguments?.location) {
-      throw new McpError(
-        ErrorCode.InvalidParams,
-        "location parameter is required"
-      );
-    }
-
-    const result = await executeTool(request.params.name, request.params.arguments);
-    return { content: [{ type: "text", text: result }] };
-
-  } catch (error) {
-    if (error instanceof McpError) {
-      throw error; // Re-throw MCP errors
-    }
-
-    // Wrap other errors
-    throw new McpError(
-      ErrorCode.InternalError,
-      `Tool execution failed: ${error.message}`
-    );
-  }
-});
-```
-
-## Basic Client Setup
-
-```typescript
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-
-const client = new Client(
-  {
-    name: "example-client",
-    version: "1.0.0",
-  },
-  {
-    capabilities: {},
-  }
-);
-
-// Connect to server
-const transport = new StdioClientTransport({
-  command: "node",
-  args: ["./server.js"],
-});
-
-await client.connect(transport);
-
-// List available tools
-const toolsResponse = await client.request(
-  { method: "tools/list" },
-  ListToolsResultSchema
-);
-
-console.log("Available tools:", toolsResponse.tools);
-
-// Call a tool
-const result = await client.request(
-  {
-    method: "tools/call",
-    params: {
-      name: "get_weather",
-      arguments: { location: "San Francisco" },
-    },
-  },
-  CallToolResultSchema
-);
-
-console.log("Result:", result.content);
-```
-
-## Notifications
-
-```typescript
-// Server sends notification
-server.notification({
-  method: "notifications/resources/updated",
-  params: {
-    uri: "file:///config/settings.json",
-  },
-});
-
-// Client handles notifications
-client.setNotificationHandler((notification) => {
-  if (notification.method === "notifications/resources/updated") {
-    console.log("Resource updated:", notification.params.uri);
-  }
-});
-```
-
-## Best Practices
-
-1. **Type Safety**: Use Zod for runtime validation
-2. **Error Handling**: Always wrap errors in McpError
-3. **Async/Await**: Use async/await throughout
-4. **Logging**: Log to stderr, not stdout (stdio transport)
-5. **Cleanup**: Handle graceful shutdown
-6. **Testing**: Use unit tests with mock transports
-7. **Performance**: Cache expensive operations
-8. **Security**: Validate all inputs, sanitize outputs

package/skills/microservices-architect/SKILL.md

@@ -1,164 +0,0 @@
----
-name: microservices-architect
-description: Designs distributed system architectures, decomposes monoliths into bounded-context services, recommends communication patterns, and produces service boundary diagrams and resilience strategies. Use when designing distributed systems, decomposing monoliths, or implementing microservices patterns — including service boundaries, DDD, saga patterns, event sourcing, CQRS, service mesh, or distributed tracing.
-license: MIT
-metadata:
-  author: https://github.com/Jeffallan
-  version: "1.1.0"
-  domain: api-architecture
-  triggers: microservices, service mesh, distributed systems, service boundaries, domain-driven design, event sourcing, CQRS, saga pattern, Kubernetes microservices, Istio, distributed tracing
-  role: architect
-  scope: system-design
-  output-format: architecture
-  related-skills: devops-engineer, kubernetes-specialist, graphql-architect, architecture-designer, monitoring-expert
----
-
-# Microservices Architect
-
-Senior distributed systems architect specializing in cloud-native microservices architectures, resilience patterns, and operational excellence.
-
-## Core Workflow
-
-1. **Domain Analysis** — Apply DDD to identify bounded contexts and service boundaries.
-   - *Validation checkpoint:* Each candidate service owns its data exclusively, has a clear public API contract, and can be deployed independently.
-2. **Communication Design** — Choose sync/async patterns and protocols (REST, gRPC, events).
-   - *Validation checkpoint:* Long-running or cross-aggregate operations use async messaging; only query/command pairs with sub-100 ms SLA use synchronous calls.
-3. **Data Strategy** — Database per service, event sourcing, eventual consistency.
-   - *Validation checkpoint:* No shared database schema exists between services; consistency boundaries align with bounded contexts.
-4. **Resilience** — Circuit breakers, retries, timeouts, bulkheads, fallbacks.
-   - *Validation checkpoint:* Every external call has an explicit timeout, retry budget, and graceful degradation path.
-5. **Observability** — Distributed tracing, correlation IDs, centralized logging.
-   - *Validation checkpoint:* A single request can be traced end-to-end using its correlation ID across all services.
-6. **Deployment** — Container orchestration, service mesh, progressive delivery.
-   - *Validation checkpoint:* Health and readiness probes are defined; canary or blue-green rollout strategy is documented.
-
-## Reference Guide
-
-Load detailed guidance based on context:
-
-| Topic | Reference | Load When |
-|-------|-----------|-----------|
-| Service Boundaries | `references/decomposition.md` | Monolith decomposition, bounded contexts, DDD |
-| Communication | `references/communication.md` | REST vs gRPC, async messaging, event-driven |
-| Resilience Patterns | `references/patterns.md` | Circuit breakers, saga, bulkhead, retry strategies |
-| Data Management | `references/data.md` | Database per service, event sourcing, CQRS |
-| Observability | `references/observability.md` | Distributed tracing, correlation IDs, metrics |
-
-## Implementation Examples
-
-### Correlation ID Middleware (Node.js / Express)
-```js
-const { v4: uuidv4 } = require('uuid');
-
-function correlationMiddleware(req, res, next) {
-  req.correlationId = req.headers['x-correlation-id'] || uuidv4();
-  res.setHeader('x-correlation-id', req.correlationId);
-  // Attach to logger context so every log line includes the ID
-  req.log = logger.child({ correlationId: req.correlationId });
-  next();
-}
-```
-Propagate `x-correlation-id` in every outbound HTTP call and Kafka message header.
-
-### Circuit Breaker (Python / `pybreaker`)
-```python
-import pybreaker
-
-# Opens after 5 failures; resets after 30 s in half-open state
-breaker = pybreaker.CircuitBreaker(fail_max=5, reset_timeout=30)
-
-@breaker
-def call_inventory_service(order_id: str):
-    response = requests.get(f"{INVENTORY_URL}/stock/{order_id}", timeout=2)
-    response.raise_for_status()
-    return response.json()
-
-def get_inventory(order_id: str):
-    try:
-        return call_inventory_service(order_id)
-    except pybreaker.CircuitBreakerError:
-        return {"status": "unavailable", "fallback": True}
-```
-
-### Saga Orchestration Skeleton (TypeScript)
-```ts
-// Each step defines execute() and compensate() so rollback is automatic.
-interface SagaStep<T> {
-  execute(ctx: T): Promise<T>;
-  compensate(ctx: T): Promise<void>;
-}
-
-async function runSaga<T>(steps: SagaStep<T>[], initialCtx: T): Promise<T> {
-  const completed: SagaStep<T>[] = [];
-  let ctx = initialCtx;
-  for (const step of steps) {
-    try {
-      ctx = await step.execute(ctx);
-      completed.push(step);
-    } catch (err) {
-      for (const done of completed.reverse()) {
-        await done.compensate(ctx).catch(console.error);
-      }
-      throw err;
-    }
-  }
-  return ctx;
-}
-
-// Usage: order creation saga
-const orderSaga = [reserveInventoryStep, chargePaymentStep, scheduleShipmentStep];
-await runSaga(orderSaga, { orderId, customerId, items });
-```
-
-### Health & Readiness Probe (Kubernetes)
-```yaml
-livenessProbe:
-  httpGet:
-    path: /health/live
-    port: 8080
-  initialDelaySeconds: 10
-  periodSeconds: 15
-readinessProbe:
-  httpGet:
-    path: /health/ready
-    port: 8080
-  initialDelaySeconds: 5
-  periodSeconds: 10
-```
-`/health/live` — returns 200 if the process is running.  
-`/health/ready` — returns 200 only when the service can serve traffic (DB connected, caches warm).
-
-## Constraints
-
-### MUST DO
-- Apply domain-driven design for service boundaries
-- Use database per service pattern
-- Implement circuit breakers for external calls
-- Add correlation IDs to all requests
-- Use async communication for cross-aggregate operations
-- Design for failure and graceful degradation
-- Implement health checks and readiness probes
-- Use API versioning strategies
-
-### MUST NOT DO
-- Create distributed monoliths
-- Share databases between services
-- Use synchronous calls for long-running operations
-- Skip distributed tracing implementation
-- Ignore network latency and partial failures
-- Create chatty service interfaces
-- Store shared state without proper patterns
-- Deploy without observability
-
-## Output Templates
-
-When designing microservices architecture, provide:
-1. Service boundary diagram with bounded contexts
-2. Communication patterns (sync/async, protocols)
-3. Data ownership and consistency model
-4. Resilience patterns for each integration point
-5. Deployment and infrastructure requirements
-
-## Knowledge Reference
-
-Domain-driven design, bounded contexts, event storming, REST/gRPC, message queues (Kafka, RabbitMQ), service mesh (Istio, Linkerd), Kubernetes, circuit breakers, saga patterns, event sourcing, CQRS, distributed tracing (Jaeger, Zipkin), API gateways, eventual consistency, CAP theorem