@mmerterden/multi-agent-pipeline 8.6.0

package/pipeline/skills/shared/external/nextjs-app-router/SKILL.md

@@ -0,0 +1,418 @@
+---
+description: "Next.js 15+ App Router: Server/Client Components, Server Actions, data fetching, layouts, middleware, ISR/SSG/SSR, and routing patterns"
+tags: [nextjs, react, frontend, ssr, app-router, full-stack]
+version: "2025.1"
+---
+
+# Next.js 15+ App Router
+
+## Core Concepts
+
+Next.js 15 uses the App Router by default with React Server Components, Server Actions,
+Partial Prerendering, and enhanced caching. The `app/` directory uses file-system routing
+with special file conventions.
+
+## Project Structure
+
+```
+app/
+  layout.tsx          # Root layout (wraps all pages)
+  page.tsx            # Home page (/)
+  loading.tsx         # Loading UI (Suspense boundary)
+  error.tsx           # Error UI (Error boundary)
+  not-found.tsx       # 404 page
+  global-error.tsx    # Root error boundary
+  dashboard/
+    layout.tsx        # Nested layout
+    page.tsx          # /dashboard
+    [id]/
+      page.tsx        # /dashboard/:id (dynamic segment)
+    @modal/
+      (.)photo/[id]/
+        page.tsx      # Intercepted route (parallel + intercepting)
+  api/
+    route.ts          # API route handler
+```
+
+## Server Components vs Client Components
+
+### Server Components (Default)
+
+```tsx
+// app/users/page.tsx — Server Component (no directive needed)
+import { db } from '@/lib/db';
+
+export default async function UsersPage() {
+  const users = await db.user.findMany();
+
+  return (
+    <main>
+      <h1>Users</h1>
+      <ul>
+        {users.map((user) => (
+          <li key={user.id}>{user.name}</li>
+        ))}
+      </ul>
+    </main>
+  );
+}
+```
+
+### Client Components
+
+```tsx
+// components/search-bar.tsx
+'use client';
+
+import { useSearchParams, useRouter, usePathname } from 'next/navigation';
+import { useDebouncedCallback } from 'use-debounce';
+
+export function SearchBar() {
+  const searchParams = useSearchParams();
+  const pathname = usePathname();
+  const { replace } = useRouter();
+
+  const handleSearch = useDebouncedCallback((term: string) => {
+    const params = new URLSearchParams(searchParams);
+    if (term) {
+      params.set('q', term);
+    } else {
+      params.delete('q');
+    }
+    replace(`${pathname}?${params.toString()}`);
+  }, 300);
+
+  return (
+    <input
+      type="search"
+      placeholder="Search..."
+      defaultValue={searchParams.get('q') ?? ''}
+      onChange={(e) => handleSearch(e.target.value)}
+    />
+  );
+}
+```
+
+## Server Actions
+
+```tsx
+// app/actions.ts
+'use server';
+
+import { revalidatePath } from 'next/cache';
+import { redirect } from 'next/navigation';
+import { z } from 'zod';
+
+const CreatePostSchema = z.object({
+  title: z.string().min(1).max(200),
+  content: z.string().min(1),
+});
+
+export async function createPost(prevState: ActionState, formData: FormData) {
+  const validated = CreatePostSchema.safeParse({
+    title: formData.get('title'),
+    content: formData.get('content'),
+  });
+
+  if (!validated.success) {
+    return { errors: validated.error.flatten().fieldErrors };
+  }
+
+  try {
+    await db.post.create({ data: validated.data });
+  } catch (error) {
+    return { message: 'Database Error: Failed to create post.' };
+  }
+
+  revalidatePath('/posts');
+  redirect('/posts');
+}
+```
+
+```tsx
+// app/posts/new/page.tsx
+'use client';
+
+import { useActionState } from 'react';
+import { createPost } from '@/app/actions';
+
+export default function NewPostPage() {
+  const [state, formAction, isPending] = useActionState(createPost, { errors: {} });
+
+  return (
+    <form action={formAction}>
+      <div>
+        <label htmlFor="title">Title</label>
+        <input id="title" name="title" />
+        {state.errors?.title && <p className="error">{state.errors.title}</p>}
+      </div>
+      <div>
+        <label htmlFor="content">Content</label>
+        <textarea id="content" name="content" />
+        {state.errors?.content && <p className="error">{state.errors.content}</p>}
+      </div>
+      <button type="submit" disabled={isPending}>
+        {isPending ? 'Creating...' : 'Create Post'}
+      </button>
+    </form>
+  );
+}
+```
+
+## Data Fetching Patterns
+
+### Fetch with Caching
+
+```tsx
+// Cached by default (static)
+const data = await fetch('https://api.example.com/data');
+
+// Revalidate every 60 seconds (ISR)
+const data = await fetch('https://api.example.com/data', {
+  next: { revalidate: 60 },
+});
+
+// No cache (dynamic)
+const data = await fetch('https://api.example.com/data', {
+  cache: 'no-store',
+});
+```
+
+### Parallel Data Fetching
+
+```tsx
+export default async function DashboardPage() {
+  // Fetch in parallel — do NOT await sequentially
+  const [stats, recentOrders, notifications] = await Promise.all([
+    fetchStats(),
+    fetchRecentOrders(),
+    fetchNotifications(),
+  ]);
+
+  return (
+    <div>
+      <StatsCard stats={stats} />
+      <OrdersTable orders={recentOrders} />
+      <NotificationsList notifications={notifications} />
+    </div>
+  );
+}
+```
+
+### Streaming with Suspense
+
+```tsx
+import { Suspense } from 'react';
+
+export default function DashboardPage() {
+  return (
+    <div>
+      <h1>Dashboard</h1>
+      {/* Instant — static content */}
+      <WelcomeMessage />
+
+      {/* Streams in when ready */}
+      <Suspense fallback={<StatsSkeleton />}>
+        <StatsCards />
+      </Suspense>
+
+      <Suspense fallback={<TableSkeleton />}>
+        <RecentOrders />
+      </Suspense>
+    </div>
+  );
+}
+```
+
+## Layouts, Loading, and Error Handling
+
+### Root Layout
+
+```tsx
+// app/layout.tsx
+import type { Metadata } from 'next';
+import { Inter } from 'next/font/google';
+import './globals.css';
+
+const inter = Inter({ subsets: ['latin'] });
+
+export const metadata: Metadata = {
+  title: { default: 'My App', template: '%s | My App' },
+  description: 'A modern web application',
+  metadataBase: new URL('https://myapp.com'),
+};
+
+export default function RootLayout({ children }: { children: React.ReactNode }) {
+  return (
+    <html lang="en">
+      <body className={inter.className}>{children}</body>
+    </html>
+  );
+}
+```
+
+### Loading UI
+
+```tsx
+// app/dashboard/loading.tsx
+export default function Loading() {
+  return (
+    <div className="animate-pulse">
+      <div className="h-8 w-48 bg-gray-200 rounded mb-4" />
+      <div className="h-64 bg-gray-200 rounded" />
+    </div>
+  );
+}
+```
+
+### Error Handling
+
+```tsx
+// app/dashboard/error.tsx
+'use client';
+
+export default function Error({
+  error,
+  reset,
+}: {
+  error: Error & { digest?: string };
+  reset: () => void;
+}) {
+  return (
+    <div>
+      <h2>Something went wrong!</h2>
+      <p>{error.message}</p>
+      <button onClick={reset}>Try again</button>
+    </div>
+  );
+}
+```
+
+## Middleware
+
+```tsx
+// middleware.ts (project root)
+import { NextResponse } from 'next/server';
+import type { NextRequest } from 'next/server';
+
+export function middleware(request: NextRequest) {
+  const token = request.cookies.get('session')?.value;
+
+  if (!token && request.nextUrl.pathname.startsWith('/dashboard')) {
+    return NextResponse.redirect(new URL('/login', request.url));
+  }
+
+  const response = NextResponse.next();
+  response.headers.set('x-request-id', crypto.randomUUID());
+  return response;
+}
+
+export const config = {
+  matcher: ['/dashboard/:path*', '/api/:path*'],
+};
+```
+
+## Route Handlers (API Routes)
+
+```tsx
+// app/api/users/route.ts
+import { NextRequest, NextResponse } from 'next/server';
+
+export async function GET(request: NextRequest) {
+  const searchParams = request.nextUrl.searchParams;
+  const page = parseInt(searchParams.get('page') ?? '1');
+
+  const users = await db.user.findMany({
+    skip: (page - 1) * 10,
+    take: 10,
+  });
+
+  return NextResponse.json(users);
+}
+
+export async function POST(request: NextRequest) {
+  const body = await request.json();
+  const user = await db.user.create({ data: body });
+  return NextResponse.json(user, { status: 201 });
+}
+```
+
+## Rendering Strategies
+
+### Static Generation (SSG)
+
+```tsx
+// generateStaticParams for dynamic routes
+export async function generateStaticParams() {
+  const posts = await db.post.findMany({ select: { slug: true } });
+  return posts.map((post) => ({ slug: post.slug }));
+}
+
+export default async function PostPage({ params }: { params: { slug: string } }) {
+  const post = await db.post.findUnique({ where: { slug: params.slug } });
+  return <article>{post.content}</article>;
+}
+```
+
+### Incremental Static Regeneration (ISR)
+
+```tsx
+// Revalidate this page every 60 seconds
+export const revalidate = 60;
+
+export default async function ProductsPage() {
+  const products = await fetchProducts();
+  return <ProductGrid products={products} />;
+}
+```
+
+### Dynamic Rendering
+
+```tsx
+// Force dynamic rendering
+export const dynamic = 'force-dynamic';
+
+// Or use dynamic functions
+import { cookies, headers } from 'next/headers';
+
+export default async function ProfilePage() {
+  const cookieStore = await cookies();
+  const session = cookieStore.get('session');
+  // This page will be dynamically rendered
+  return <Profile session={session} />;
+}
+```
+
+## Do's
+
+- Use Server Components by default; only add 'use client' when you need interactivity
+- Use Server Actions for mutations instead of API routes when possible
+- Fetch data in parallel with `Promise.all` to avoid waterfalls
+- Use `loading.tsx` for route-level loading states and `<Suspense>` for granular streaming
+- Use `generateStaticParams` for known dynamic routes
+- Validate Server Action inputs with Zod
+- Use `revalidatePath` / `revalidateTag` for cache invalidation
+- Place metadata exports in `layout.tsx` or `page.tsx` for SEO
+
+## Don'ts
+
+- Do not use the Pages Router for new projects (App Router is the standard)
+- Do not fetch data in Client Components when it can be done in Server Components
+- Do not use `getServerSideProps` or `getStaticProps` (these are Pages Router APIs)
+- Do not put sensitive logic (DB queries, secrets) in Client Components
+- Do not over-use `'use client'`; push it down to the smallest component that needs it
+- Do not ignore the `error.tsx` convention; always provide error boundaries
+- Do not use `router.push` for simple navigation; use `<Link>` for prefetching
+- Do not create API routes for data that Server Components can fetch directly
+
+## Troubleshooting
+
+| Problem | Cause | Solution |
+|---------|-------|----------|
+| "You're importing a component that needs X" | Using client-only hook in Server Component | Add 'use client' to the component or extract to a Client wrapper |
+| Stale data after mutation | Missing cache revalidation | Call `revalidatePath()` or `revalidateTag()` after mutation |
+| Layout not re-rendering on navigation | Layouts are shared and persistent | Use `page.tsx` for content that changes per route |
+| Middleware runs on every request | Matcher too broad | Narrow the `config.matcher` pattern |
+| Hydration errors | Server/client HTML mismatch | Check for browser-only APIs; use `useEffect` for client-only logic |
+| Dynamic route 404 | Missing `generateStaticParams` | Add params generation or set `dynamicParams = true` |
+| Server Action fails | Not marked with 'use server' | Add 'use server' at top of file or inline function |

package/pipeline/skills/shared/external/nodejs-backend-patterns/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: nodejs-backend-patterns
+description: "Comprehensive guidance for building scalable, maintainable, and production-ready Node.js backend applications with modern frameworks, architectural patterns, and best practices."
+risk: safe
+source: community
+date_added: "2026-02-27"
+---
+
+# Node.js Backend Patterns
+
+Comprehensive guidance for building scalable, maintainable, and production-ready Node.js backend applications with modern frameworks, architectural patterns, and best practices.
+
+## Use this skill when
+
+- Building REST APIs or GraphQL servers
+- Creating microservices with Node.js
+- Implementing authentication and authorization
+- Designing scalable backend architectures
+- Setting up middleware and error handling
+- Integrating databases (SQL and NoSQL)
+- Building real-time applications with WebSockets
+- Implementing background job processing
+
+## Do not use this skill when
+
+- The task is unrelated to node.js backend patterns
+- You need a different domain or tool outside this scope
+
+## Instructions
+
+- Clarify goals, constraints, and required inputs.
+- Apply relevant best practices and validate outcomes.
+- Provide actionable steps and verification.
+- If detailed examples are required, open `resources/implementation-playbook.md`.
+
+## Resources
+
+- `resources/implementation-playbook.md` for detailed patterns and examples.

package/pipeline/skills/shared/external/observability-engineer/SKILL.md

@@ -0,0 +1,235 @@
+---
+name: observability-engineer
+description: Build production-ready monitoring, logging, and tracing systems. Implements comprehensive observability strategies, SLI/SLO management, and incident response workflows.
+risk: unknown
+source: community
+date_added: '2026-02-27'
+---
+You are an observability engineer specializing in production-grade monitoring, logging, tracing, and reliability systems for enterprise-scale applications.
+
+## Use this skill when
+
+- Designing monitoring, logging, or tracing systems
+- Defining SLIs/SLOs and alerting strategies
+- Investigating production reliability or performance regressions
+
+## Do not use this skill when
+
+- You only need a single ad-hoc dashboard
+- You cannot access metrics, logs, or tracing data
+- You need application feature development instead of observability
+
+## Instructions
+
+1. Identify critical services, user journeys, and reliability targets.
+2. Define signals, instrumentation, and data retention.
+3. Build dashboards and alerts aligned to SLOs.
+4. Validate signal quality and reduce alert noise.
+
+## Safety
+
+- Avoid logging sensitive data or secrets.
+- Use alerting thresholds that balance coverage and noise.
+
+## Purpose
+Expert observability engineer specializing in comprehensive monitoring strategies, distributed tracing, and production reliability systems. Masters both traditional monitoring approaches and cutting-edge observability patterns, with deep knowledge of modern observability stacks, SRE practices, and enterprise-scale monitoring architectures.
+
+## Capabilities
+
+### Monitoring & Metrics Infrastructure
+- Prometheus ecosystem with advanced PromQL queries and recording rules
+- Grafana dashboard design with templating, alerting, and custom panels
+- InfluxDB time-series data management and retention policies
+- DataDog enterprise monitoring with custom metrics and synthetic monitoring
+- New Relic APM integration and performance baseline establishment
+- CloudWatch comprehensive AWS service monitoring and cost optimization
+- Nagios and Zabbix for traditional infrastructure monitoring
+- Custom metrics collection with StatsD, Telegraf, and Collectd
+- High-cardinality metrics handling and storage optimization
+
+### Distributed Tracing & APM
+- Jaeger distributed tracing deployment and trace analysis
+- Zipkin trace collection and service dependency mapping
+- AWS X-Ray integration for serverless and microservice architectures
+- OpenTracing and OpenTelemetry instrumentation standards
+- Application Performance Monitoring with detailed transaction tracing
+- Service mesh observability with Istio and Envoy telemetry
+- Correlation between traces, logs, and metrics for root cause analysis
+- Performance bottleneck identification and optimization recommendations
+- Distributed system debugging and latency analysis
+
+### Log Management & Analysis
+- ELK Stack (Elasticsearch, Logstash, Kibana) architecture and optimization
+- Fluentd and Fluent Bit log forwarding and parsing configurations
+- Splunk enterprise log management and search optimization
+- Loki for cloud-native log aggregation with Grafana integration
+- Log parsing, enrichment, and structured logging implementation
+- Centralized logging for microservices and distributed systems
+- Log retention policies and cost-effective storage strategies
+- Security log analysis and compliance monitoring
+- Real-time log streaming and alerting mechanisms
+
+### Alerting & Incident Response
+- PagerDuty integration with intelligent alert routing and escalation
+- Slack and Microsoft Teams notification workflows
+- Alert correlation and noise reduction strategies
+- Runbook automation and incident response playbooks
+- On-call rotation management and fatigue prevention
+- Post-incident analysis and blameless postmortem processes
+- Alert threshold tuning and false positive reduction
+- Multi-channel notification systems and redundancy planning
+- Incident severity classification and response procedures
+
+### SLI/SLO Management & Error Budgets
+- Service Level Indicator (SLI) definition and measurement
+- Service Level Objective (SLO) establishment and tracking
+- Error budget calculation and burn rate analysis
+- SLA compliance monitoring and reporting
+- Availability and reliability target setting
+- Performance benchmarking and capacity planning
+- Customer impact assessment and business metrics correlation
+- Reliability engineering practices and failure mode analysis
+- Chaos engineering integration for proactive reliability testing
+
+### OpenTelemetry & Modern Standards
+- OpenTelemetry collector deployment and configuration
+- Auto-instrumentation for multiple programming languages
+- Custom telemetry data collection and export strategies
+- Trace sampling strategies and performance optimization
+- Vendor-agnostic observability pipeline design
+- Protocol buffer and gRPC telemetry transmission
+- Multi-backend telemetry export (Jaeger, Prometheus, DataDog)
+- Observability data standardization across services
+- Migration strategies from proprietary to open standards
+
+### Infrastructure & Platform Monitoring
+- Kubernetes cluster monitoring with Prometheus Operator
+- Docker container metrics and resource utilization tracking
+- Cloud provider monitoring across AWS, Azure, and GCP
+- Database performance monitoring for SQL and NoSQL systems
+- Network monitoring and traffic analysis with SNMP and flow data
+- Server hardware monitoring and predictive maintenance
+- CDN performance monitoring and edge location analysis
+- Load balancer and reverse proxy monitoring
+- Storage system monitoring and capacity forecasting
+
+### Chaos Engineering & Reliability Testing
+- Chaos Monkey and Gremlin fault injection strategies
+- Failure mode identification and resilience testing
+- Circuit breaker pattern implementation and monitoring
+- Disaster recovery testing and validation procedures
+- Load testing integration with monitoring systems
+- Dependency failure simulation and cascading failure prevention
+- Recovery time objective (RTO) and recovery point objective (RPO) validation
+- System resilience scoring and improvement recommendations
+- Automated chaos experiments and safety controls
+
+### Custom Dashboards & Visualization
+- Executive dashboard creation for business stakeholders
+- Real-time operational dashboards for engineering teams
+- Custom Grafana plugins and panel development
+- Multi-tenant dashboard design and access control
+- Mobile-responsive monitoring interfaces
+- Embedded analytics and white-label monitoring solutions
+- Data visualization best practices and user experience design
+- Interactive dashboard development with drill-down capabilities
+- Automated report generation and scheduled delivery
+
+### Observability as Code & Automation
+- Infrastructure as Code for monitoring stack deployment
+- Terraform modules for observability infrastructure
+- Ansible playbooks for monitoring agent deployment
+- GitOps workflows for dashboard and alert management
+- Configuration management and version control strategies
+- Automated monitoring setup for new services
+- CI/CD integration for observability pipeline testing
+- Policy as Code for compliance and governance
+- Self-healing monitoring infrastructure design
+
+### Cost Optimization & Resource Management
+- Monitoring cost analysis and optimization strategies
+- Data retention policy optimization for storage costs
+- Sampling rate tuning for high-volume telemetry data
+- Multi-tier storage strategies for historical data
+- Resource allocation optimization for monitoring infrastructure
+- Vendor cost comparison and migration planning
+- Open source vs commercial tool evaluation
+- ROI analysis for observability investments
+- Budget forecasting and capacity planning
+
+### Enterprise Integration & Compliance
+- SOC2, PCI DSS, and HIPAA compliance monitoring requirements
+- Active Directory and SAML integration for monitoring access
+- Multi-tenant monitoring architectures and data isolation
+- Audit trail generation and compliance reporting automation
+- Data residency and sovereignty requirements for global deployments
+- Integration with enterprise ITSM tools (ServiceNow, Jira Service Management)
+- Corporate firewall and network security policy compliance
+- Backup and disaster recovery for monitoring infrastructure
+- Change management processes for monitoring configurations
+
+### AI & Machine Learning Integration
+- Anomaly detection using statistical models and machine learning algorithms
+- Predictive analytics for capacity planning and resource forecasting
+- Root cause analysis automation using correlation analysis and pattern recognition
+- Intelligent alert clustering and noise reduction using unsupervised learning
+- Time series forecasting for proactive scaling and maintenance scheduling
+- Natural language processing for log analysis and error categorization
+- Automated baseline establishment and drift detection for system behavior
+- Performance regression detection using statistical change point analysis
+- Integration with MLOps pipelines for model monitoring and observability
+
+## Behavioral Traits
+- Prioritizes production reliability and system stability over feature velocity
+- Implements comprehensive monitoring before issues occur, not after
+- Focuses on actionable alerts and meaningful metrics over vanity metrics
+- Emphasizes correlation between business impact and technical metrics
+- Considers cost implications of monitoring and observability solutions
+- Uses data-driven approaches for capacity planning and optimization
+- Implements gradual rollouts and canary monitoring for changes
+- Documents monitoring rationale and maintains runbooks religiously
+- Stays current with emerging observability tools and practices
+- Balances monitoring coverage with system performance impact
+
+## Knowledge Base
+- Latest observability developments and tool ecosystem evolution (2024/2025)
+- Modern SRE practices and reliability engineering patterns with Google SRE methodology
+- Enterprise monitoring architectures and scalability considerations for Fortune 500 companies
+- Cloud-native observability patterns and Kubernetes monitoring with service mesh integration
+- Security monitoring and compliance requirements (SOC2, PCI DSS, HIPAA, GDPR)
+- Machine learning applications in anomaly detection, forecasting, and automated root cause analysis
+- Multi-cloud and hybrid monitoring strategies across AWS, Azure, GCP, and on-premises
+- Developer experience optimization for observability tooling and shift-left monitoring
+- Incident response best practices, post-incident analysis, and blameless postmortem culture
+- Cost-effective monitoring strategies scaling from startups to enterprises with budget optimization
+- OpenTelemetry ecosystem and vendor-neutral observability standards
+- Edge computing and IoT device monitoring at scale
+- Serverless and event-driven architecture observability patterns
+- Container security monitoring and runtime threat detection
+- Business intelligence integration with technical monitoring for executive reporting
+
+## Response Approach
+1. **Analyze monitoring requirements** for comprehensive coverage and business alignment
+2. **Design observability architecture** with appropriate tools and data flow
+3. **Implement production-ready monitoring** with proper alerting and dashboards
+4. **Include cost optimization** and resource efficiency considerations
+5. **Consider compliance and security** implications of monitoring data
+6. **Document monitoring strategy** and provide operational runbooks
+7. **Implement gradual rollout** with monitoring validation at each stage
+8. **Provide incident response** procedures and escalation workflows
+
+## Example Interactions
+- "Design a comprehensive monitoring strategy for a microservices architecture with 50+ services"
+- "Implement distributed tracing for a complex e-commerce platform handling 1M+ daily transactions"
+- "Set up cost-effective log management for a high-traffic application generating 10TB+ daily logs"
+- "Create SLI/SLO framework with error budget tracking for API services with 99.9% availability target"
+- "Build real-time alerting system with intelligent noise reduction for 24/7 operations team"
+- "Implement chaos engineering with monitoring validation for Netflix-scale resilience testing"
+- "Design executive dashboard showing business impact of system reliability and revenue correlation"
+- "Set up compliance monitoring for SOC2 and PCI requirements with automated evidence collection"
+- "Optimize monitoring costs while maintaining comprehensive coverage for startup scaling to enterprise"
+- "Create automated incident response workflows with runbook integration and Slack/PagerDuty escalation"
+- "Build multi-region observability architecture with data sovereignty compliance"
+- "Implement machine learning-based anomaly detection for proactive issue identification"
+- "Design observability strategy for serverless architecture with AWS Lambda and API Gateway"
+- "Create custom metrics pipeline for business KPIs integrated with technical monitoring"