@jaypie/mcp 0.3.4 → 0.4.1

package/skills/datadog.md

@@ -1,61 +1,15 @@
 ---
-description: Datadog integration and observability
-related: logs, debugging, aws
+description: Datadog integration, logging, and observability code patterns
+related: logs, debugging, aws, tools-datadog
 ---
 
 # Datadog Integration
 
 Jaypie integrates with Datadog for logging, monitoring, and APM.
 
-## MCP Datadog Tools
+## MCP Tools
 
-The Jaypie MCP provides tools for querying Datadog:
-
-### Log Search
-```
-datadog_logs          - Search individual log entries
-datadog_log_analytics - Aggregate logs with groupBy
-```
-
-### Monitoring
-```
-datadog_monitors      - List and check monitor status
-datadog_synthetics    - List synthetic tests and results
-datadog_metrics       - Query timeseries metrics
-datadog_rum           - Search Real User Monitoring events
-```
-
-## Environment Variables
-
-Configure Datadog tools via environment:
-
-| Variable | Description |
-|----------|-------------|
-| `DATADOG_API_KEY` or `DD_API_KEY` | API key |
-| `DATADOG_APP_KEY` or `DD_APP_KEY` | Application key |
-| `DD_ENV` | Default environment filter |
-| `DD_SERVICE` | Default service filter |
-| `DD_SOURCE` | Default log source (default: lambda) |
-
-## Common Queries
-
-### Search Error Logs
-
-```
-datadog_logs --query "status:error" --from "now-1h"
-```
-
-### Count Errors by Service
-
-```
-datadog_log_analytics --groupBy '["service"]' --query "status:error"
-```
-
-### Check Alerting Monitors
-
-```
-datadog_monitors --status '["Alert", "Warn"]'
-```
+For interactive Datadog tools (logs, monitors, metrics, synthetics, RUM), see **tools-datadog**.
 
 ## Lambda Integration
 
@@ -65,6 +19,7 @@ Enable Datadog tracing in CDK:
 import { JaypieLambda } from "@jaypie/constructs";
 
 const handler = new JaypieLambda(this, "Handler", {
+  entry: "src/handler.ts",
   datadogApiKeyArn: process.env.CDK_ENV_DATADOG_API_KEY_ARN,
   environment: {
     DD_ENV: "production",
@@ -87,26 +42,32 @@ log.info("Request processed", {
   action: "checkout",
   duration: 150,
 });
+
+// Error logs include stack traces
+log.error("Payment failed", {
+  error,
+  orderId: "order-456",
+});
 ```
 
-## Query Syntax
+## @jaypie/datadog Package
 
-### Log Search Syntax
+The `@jaypie/datadog` package provides utilities:
 
-```
-status:error                    # By status
-@http.status_code:500          # By attribute
-service:my-api                  # By service
-*timeout*                       # Wildcard
-```
+```typescript
+import { datadogMetric, datadogEvent } from "@jaypie/datadog";
 
-### Time Ranges
+// Send custom metric
+await datadogMetric("checkout.completed", 1, {
+  tags: ["env:production", "service:checkout"],
+});
 
-```
-now-15m                         # Last 15 minutes
-now-1h                          # Last hour
-now-1d                          # Last day
-2024-01-15T10:00:00Z           # Specific time (ISO 8601)
+// Send event
+await datadogEvent({
+  title: "Deployment completed",
+  text: "Version 1.2.3 deployed to production",
+  tags: ["env:production"],
+});
 ```
 
 ## Unified Service Tagging
@@ -127,3 +88,76 @@ environment: {
 }
 ```
 
+## Environment Variables
+
+### CDK Configuration
+
+| Variable | Description |
+|----------|-------------|
+| `CDK_ENV_DATADOG_API_KEY_ARN` | Datadog API key ARN in Secrets Manager |
+
+### Lambda Environment
+
+| Variable | Description |
+|----------|-------------|
+| `DD_ENV` | Environment tag |
+| `DD_SERVICE` | Service tag |
+| `DD_VERSION` | Version tag |
+| `DD_TRACE_ENABLED` | Enable APM tracing |
+| `DD_LOGS_INJECTION` | Inject trace IDs in logs |
+
+## Trace Correlation
+
+Correlate logs with traces:
+
+```typescript
+import { log, getTraceContext } from "jaypie";
+
+function processRequest() {
+  const traceContext = getTraceContext();
+
+  log.info("Processing request", {
+    ...traceContext,
+    requestId: "req-123",
+  });
+}
+```
+
+## Custom Metrics
+
+Send custom metrics from Lambda:
+
+```typescript
+import { log } from "jaypie";
+
+// Use log for metrics that Datadog indexes
+log.info("MONITORING", {
+  metric: "orders.processed",
+  value: 1,
+  tags: { env: "production", region: "us-east-1" },
+});
+```
+
+## Testing
+
+Mock Datadog in tests:
+
+```typescript
+import { datadogMetric } from "@jaypie/datadog";
+import { vi } from "vitest";
+
+vi.mock("@jaypie/datadog");
+
+describe("CheckoutService", () => {
+  it("sends metric on completion", async () => {
+    await processCheckout();
+
+    expect(datadogMetric).toHaveBeenCalledWith(
+      "checkout.completed",
+      1,
+      expect.objectContaining({ tags: expect.any(Array) })
+    );
+  });
+});
+```
+

package/skills/dynamodb.md

@@ -1,20 +1,15 @@
 ---
-description: DynamoDB patterns and queries
-related: aws, cdk, models
+description: DynamoDB code patterns, key design, and queries
+related: aws, cdk, models, tools-dynamodb
 ---
 
 # DynamoDB Patterns
 
 Best practices for DynamoDB with Jaypie applications.
 
-## MCP DynamoDB Tools
+## MCP Tools
 
-```
-aws_dynamodb_describe_table   - Get table schema and indexes
-aws_dynamodb_query            - Query by partition key (efficient)
-aws_dynamodb_scan             - Full table scan (use sparingly)
-aws_dynamodb_get_item         - Get single item by key
-```
+For interactive DynamoDB tools (query, scan, get-item, describe-table), see **tools-dynamodb**.
 
 ## Key Design
 
@@ -48,21 +43,7 @@ Use prefixed keys for multiple entity types:
 | List user orders | pk = USER#123, sk begins_with ORDER# |
 | Get specific order | pk = USER#123, sk = ORDER#2024-01-15#abc |
 
-## Query Examples
-
-### Query via MCP
-
-```
-# Get user profile
-aws_dynamodb_get_item --tableName "MyTable" --key '{"pk":{"S":"USER#123"},"sk":{"S":"PROFILE"}}'
-
-# List user orders
-aws_dynamodb_query --tableName "MyTable" \
-  --keyConditionExpression "pk = :pk AND begins_with(sk, :prefix)" \
-  --expressionAttributeValues '{":pk":{"S":"USER#123"},":prefix":{"S":"ORDER#"}}'
-```
-
-### Query in Code
+## Query in Code
 
 ```typescript
 import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
@@ -98,10 +79,15 @@ const result = await client.send(new QueryCommand({
 
 Query pending orders:
 
-```
-aws_dynamodb_query --tableName "MyTable" --indexName "gsi1" \
-  --keyConditionExpression "gsi1pk = :status" \
-  --expressionAttributeValues '{":status":{"S":"ORDER#pending"}}'
+```typescript
+const result = await client.send(new QueryCommand({
+  TableName: process.env.CDK_ENV_TABLE,
+  IndexName: "gsi1",
+  KeyConditionExpression: "gsi1pk = :status",
+  ExpressionAttributeValues: {
+    ":status": "ORDER#pending",
+  },
+}));
 ```
 
 ## CDK Table Definition
@@ -138,3 +124,26 @@ AWS_ACCESS_KEY_ID=local AWS_SECRET_ACCESS_KEY=local \
   --endpoint-url http://127.0.0.1:8000
 ```
 
+## Testing
+
+Mock DynamoDB in tests:
+
+```typescript
+import { DynamoDBClient } from "@aws-sdk/client-dynamodb";
+import { vi } from "vitest";
+
+vi.mock("@aws-sdk/client-dynamodb");
+
+describe("OrderService", () => {
+  it("queries user orders", async () => {
+    vi.mocked(DynamoDBClient.prototype.send).mockResolvedValue({
+      Items: [{ pk: "USER#123", sk: "ORDER#abc" }],
+    });
+
+    const orders = await getOrders("123");
+
+    expect(orders).toHaveLength(1);
+  });
+});
+```
+

package/skills/fabric.md

@@ -54,10 +54,18 @@ program.addCommand(fabricCommand(greetService));
 ### MCP Tool
 
 ```typescript
-import { fabricMcpTool } from "@jaypie/fabric";
+import { fabricMcp, FabricMcpServer } from "@jaypie/fabric/mcp";
 
-server.tool(...fabricMcpTool(greetService));
-// Available as MCP tool "greet"
+// Single service registration
+fabricMcp({ service: greetService, server });
+
+// Multi-service server (preferred)
+const server = FabricMcpServer({
+  name: "my-server",
+  version: "1.0.0",
+  services: [greetService, searchService],
+});
+// Available as MCP tools "greet" and "search"
 ```
 
 ### LLM Tool
@@ -97,6 +105,25 @@ const suite = createServiceSuite({
 
 suite.register(userService, "users");
 suite.register(userListService, "users");
+
+// Access services
+suite.services;                    // ServiceMeta[] - metadata for listing
+suite.getServiceFunctions();       // Service[] - actual functions
+suite.execute("user_get", { id }); // Direct execution
+```
+
+### Suite to MCP Server
+
+Connect suites directly to MCP:
+
+```typescript
+import { createMcpServerFromSuite } from "@jaypie/fabric/mcp";
+
+const server = createMcpServerFromSuite(suite, {
+  name: "users-api",    // Optional override
+  version: "1.0.0",
+});
+// All suite services now available as MCP tools
 ```
 
 ## Input Validation

package/skills/issues.md

@@ -0,0 +1,55 @@
+---
+description: Submitting issues to Jaypie repositories
+related: jaypie, agents
+---
+
+# Jaypie Issues
+
+## Repository
+
+Submit issues to: **github.com/finlaysonstudio/jaypie**
+
+## Agent Guidelines
+
+**CRITICAL: Never submit issues without explicit user approval.**
+
+Before creating an issue:
+1. Draft the issue title and body
+2. Present the draft to the user
+3. Wait for explicit approval ("yes", "submit it", etc.)
+4. Only then use `mcp__github__issue_write` to create the issue
+
+## Issue Format
+
+```markdown
+**Title**: [Brief, descriptive title]
+
+**Description**:
+[What is the issue or feature request]
+
+**Context**:
+- Package: [affected package, e.g., `jaypie`, `@jaypie/express`]
+- Version: [if known]
+- Environment: [if relevant]
+
+**Steps to Reproduce** (for bugs):
+1. ...
+2. ...
+
+**Expected Behavior**:
+[What should happen]
+
+**Actual Behavior**:
+[What actually happens]
+```
+
+## Labels
+
+Common labels: `bug`, `enhancement`, `documentation`, `question`
+
+## When to Suggest Issues
+
+- Bugs in Jaypie packages discovered during development
+- Missing features that would benefit multiple projects
+- Documentation gaps or errors
+- API inconsistencies