vibes-plug 2.5.0 → 2.11.0

package/skills/senior-fullstack/references/architecture_patterns.md

@@ -1,160 +0,0 @@
-# Architecture Patterns
-
-## Overview
-This reference guide details high-performance architecture patterns for senior fullstack systems. It covers multi-tier caching (Redis), relational database partitioning, and resilient event-driven background queues.
-
----
-
-## Production Architecture Designs
-
-### 1. Multi-Tier Caching Layer (Redis + Memory)
-
-For write-heavy/read-intensive endpoints (e.g., public API stats or product catalogs), hitting the relational database directly is a major bottleneck. Implement a Cache-Aside pattern using memory-first or Redis structures.
-
-#### Pattern: Type-Safe Cache-Aside Implementation (`lib/cache/redis.ts`)
-
-```typescript
-import { Redis } from '@upstash/redis'; // or ioredis
-
-export const redis = new Redis({
-  url: process.env.UPSTASH_REDIS_REST_URL!,
-  token: process.env.UPSTASH_REDIS_REST_TOKEN!,
-});
-
-interface CacheOptions {
-  ttlSeconds?: number;
-}
-
-export async function getOrSetCache<T>(
-  key: string,
-  fetchFn: () => Promise<T>,
-  options: CacheOptions = {}
-): Promise<T> {
-  const ttl = options.ttlSeconds ?? 3600; // Default: 1 hour
-
-  try {
-    // Attempt cache read
-    const cachedData = await redis.get<string>(key);
-    if (cachedData) {
-      return typeof cachedData === 'string' ? JSON.parse(cachedData) : cachedData;
-    }
-  } catch (err) {
-    console.error(`⚠️ Redis read failed for key ${key}:`, err);
-  }
-
-  // Cache miss - execute database hit
-  const freshData = await fetchFn();
-
-  try {
-    // Populate cache asynchronously
-    await redis.set(key, JSON.stringify(freshData), { ex: ttl });
-  } catch (err) {
-    console.error(`⚠️ Redis write failed for key ${key}:`, err);
-  }
-
-  return freshData;
-}
-```
-
----
-
-### 2. High-Performance Indexing and Query Tuning
-
-Poor database performance is almost always caused by missing indexes on fields targeted by `WHERE` and `JOIN` clauses. Use standard PostgreSQL compound indexes and profile execution paths.
-
-#### Pattern: Compound & Partial Indexing (`prisma/schema.prisma` or pure SQL)
-
-```prisma
-// Example Prisma compound index optimized for scoped tenant querying
-model Invoice {
-  id          String   @id @default(cuid())
-  tenantId    String
-  status      String   // PAID, UNPAID, OVERDUE
-  amount      Float
-  createdAt   DateTime @default(now())
-
-  // Optimize compound filters: WHERE tenantId = X AND status = Y ORDER BY createdAt DESC
-  @@index([tenantId, status, createdAt(sort: Desc)])
-}
-```
-
-#### Profiling Queries with PostgreSQL `EXPLAIN ANALYZE`
-
-Run the following SQL diagnostic query inside your migration console to detect costly Sequential Scans (Seq Scan):
-
-```sql
-EXPLAIN ANALYZE 
-SELECT * FROM "Invoice" 
-WHERE "tenantId" = 'tenant_123' 
-  AND "status" = 'PAID' 
-ORDER BY "createdAt" DESC;
-```
-
-*Look for:* `Index Scan using Invoice_tenantId_status_createdAt_idx` indicating the optimizer is executing query lookup paths with O(log N) complexity instead of O(N).
-
----
-
-### 3. Resilient Webhooks & Resilient Background Workers
-
-Handling computationally heavy tasks (e.g., PDF generation, batch emails, image processing) in the standard request/response HTTP loop leads to poor UI performance and timeout failures. Decouple execution paths with background job queues (e.g., BullMQ, Inngest, or Celery).
-
-#### Pattern: Event-Driven Queue Producer (`lib/queue/jobs.ts`)
-
-```typescript
-import { Queue } from 'bullmq';
-import IORedis from 'ioredis';
-
-const connection = new IORedis(process.env.REDIS_URL!);
-
-// 1. Establish the queue
-export const emailQueue = new Queue('EmailQueue', { connection });
-
-export async function queueWelcomeEmail(userId: string, email: string) {
-  await emailQueue.add(
-    'send_welcome',
-    { userId, email },
-    {
-      attempts: 5, // High retry resilience
-      backoff: {
-        type: 'exponential',
-        delay: 5000, // Exponential backoff starting at 5s
-      },
-    }
-  );
-}
-```
-
-#### Pattern: Decoupled Queue Worker (`workers/email.ts`)
-
-```typescript
-import { Worker, Job } from 'bullmq';
-import IORedis from 'ioredis';
-import { sendWelcomeEmail } from '@/lib/email';
-
-const connection = new IORedis(process.env.REDIS_URL!);
-
-// Decoupled consumer execution running in a separate thread/container
-const emailWorker = new Worker(
-  'EmailQueue',
-  async (job: Job) => {
-    if (job.name === 'send_welcome') {
-      const { email, userId } = job.data;
-      await sendWelcomeEmail(email, userId);
-    }
-  },
-  { connection, concurrency: 10 }
-);
-
-emailWorker.on('completed', (job) => {
-  console.log(`✅ Job ${job.id} completed successfully`);
-});
-
-emailWorker.on('failed', (job, err) => {
-  console.error(`❌ Job ${job?.id} failed:`, err);
-});
-```
-
----
-
-## Technical Summary
-Decoupling application layers using structured micro-tier architectures—caching, indexes, and background workers—prevents cascading performance issues, guarantees high availability, and maintains scalable SaaS responses.

package/skills/senior-fullstack/references/development_workflows.md

@@ -1,222 +0,0 @@
-# Development Workflows
-
-## Overview
-This reference guide details production-grade development workflows, automated testing matrices, and CI/CD pipelines for senior fullstack applications.
-
----
-
-## Production Workflows & Pipelines
-
-### 1. High-Fidelity Test Matrix (Vitest & Playwright)
-
-Senior fullstack projects must enforce a multi-tiered test strategy:
-1. **Unit Testing**: Instant feedback cycles using Vitest or Jest for pure logic and schema validations.
-2. **End-to-End (E2E) Testing**: High-fidelity customer flow validations using Playwright.
-
-#### Pattern: Vitest Schema Validator Unit Test (`__tests__/signup.test.ts`)
-
-```typescript
-import { describe, it, expect } from 'vitest';
-import { SignupSchema } from '../lib/validators/auth';
-
-describe('Signup Schema Validation', () => {
-  it('should pass on complete, valid payload', () => {
-    const payload = {
-      email: 'test@example.com',
-      password: 'password123',
-      name: 'Jane Doe',
-    };
-    const result = SignupSchema.safeParse(payload);
-    expect(result.success).toBe(true);
-  });
-
-  it('should reject passwords shorter than 8 characters', () => {
-    const payload = {
-      email: 'test@example.com',
-      password: 'short',
-    };
-    const result = SignupSchema.safeParse(payload);
-    expect(result.success).toBe(false);
-  });
-});
-```
-
-#### Pattern: Playwright Multi-Role Customer E2E Flow (`e2e/onboarding.spec.ts`)
-
-```typescript
-import { test, expect } from '@playwright/test';
-
-test.describe('Customer Workspace Onboarding', () => {
-  test('should allow authenticated customer to create a workspace and view dashboard', async ({ page }) => {
-    // 1. Visit landing page
-    await page.goto('/sign-in');
-
-    // 2. Perform mock login or enter user credentials
-    await page.fill('input[type="email"]', 'jane@company.com');
-    await page.fill('input[type="password"]', 'janePassword123');
-    await page.click('button[type="submit"]');
-
-    // 3. Confirm redirected to dashboard onboarding step
-    await expect(page).toHaveURL(/.*dashboard/);
-    await expect(page.locator('h1')).toContainText('Create Your Workspace');
-
-    // 4. Submit form
-    await page.fill('input[name="name"]', 'Jane Ventures');
-    await page.fill('input[name="slug"]', 'jane-ventures');
-    await page.click('button[type="submit"]');
-
-    // 5. Verify success state and layout rendering
-    await expect(page.locator('main')).toContainText('Jane Ventures');
-  });
-});
-```
-
----
-
-### 2. Automated CI/CD Pipelines (GitHub Actions)
-
-Establish automated quality gates on every Pull Request to verify build integrity, linter standards, and security vulnerability profiles.
-
-#### Pattern: GitHub Actions Workflow (`.github/workflows/ci.yml`)
-
-```yaml
-name: Continuous Integration
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  validate:
-    runs-on: ubuntu-latest
-
-    services:
-      postgres:
-        image: postgres:15
-        env:
-          POSTGRES_USER: test_user
-          POSTGRES_PASSWORD: test_password
-          POSTGRES_DB: test_db
-        ports:
-          - 5432:5432
-        options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-
-    steps:
-      - name: Checkout Source Code
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js Environment
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-          cache: 'npm'
-
-      - name: Install Dependencies
-        run: npm ci
-
-      - name: Verify Linter & Formatters
-        run: |
-          npm run lint
-          npm run format:check
-
-      - name: Run Database Migrations
-        env:
-          DATABASE_URL: postgresql://test_user:test_password@localhost:5432/test_db
-        run: npx prisma migrate deploy # or npx drizzle-kit migrate
-
-      - name: Execute Vitest Unit Suite
-        env:
-          DATABASE_URL: postgresql://test_user:test_password@localhost:5432/test_db
-        run: npm run test:unit
-
-      - name: Install Playwright Browsers
-        run: npx playwright install --with-deps
-
-      - name: Execute E2E Integration Suite
-        env:
-          DATABASE_URL: postgresql://test_user:test_password@localhost:5432/test_db
-        run: npm run test:e2e
-
-      - name: Validate Production Build
-        run: npm run build
-```
-
----
-
-### 3. Containerized Local Environments (Docker & Compose)
-
-To guarantee absolute environment consistency between developer workstations and staging/production clouds, define lightweight multi-container environments.
-
-#### Pattern: Production-Grade Multi-Stage Dockerfile (`Dockerfile`)
-
-```dockerfile
-# --- Stage 1: Build Workspace ---
-FROM node:20-alpine AS builder
-WORKDIR /app
-COPY package*.json ./
-RUN npm ci
-COPY . .
-RUN npm run build
-
-# --- Stage 2: Minimalist Production Runner ---
-FROM node:20-alpine AS runner
-WORKDIR /app
-ENV NODE_ENV=production
-COPY --from=builder /app/package*.json ./
-COPY --from=builder /app/node_modules ./node_modules
-COPY --from=builder /app/.next ./.next
-COPY --from=builder /app/public ./public
-
-EXPOSE 3000
-CMD ["npm", "run", "start"]
-```
-
-#### Pattern: Docker Compose Stack (`docker-compose.yml`)
-
-```yaml
-version: '3.8'
-
-services:
-  web:
-    build:
-      context: .
-      dockerfile: Dockerfile
-    ports:
-      - "3000:3000"
-    environment:
-      - DATABASE_URL=postgresql://app_user:app_password@db:5432/app_db
-      - REDIS_URL=redis://redis:6379
-    depends_on:
-      - db
-      - redis
-
-  db:
-    image: postgres:15
-    environment:
-      POSTGRES_USER: app_user
-      POSTGRES_PASSWORD: app_password
-      POSTGRES_DB: app_db
-    ports:
-      - "5432:5432"
-    volumes:
-      - pgdata:/var/lib/postgresql/data
-
-  redis:
-    image: redis:7-alpine
-    ports:
-      - "6379:6379"
-
-volumes:
-  pgdata:
-```
-
----
-
-## Conclusion
-Setting up rigorous CI/CD gates, high-fidelity testing metrics, and matching container local stacks completely eliminates "works on my machine" failures and keeps server releases highly stable.

package/skills/senior-fullstack/references/tech_stack_guide.md

@@ -1,190 +0,0 @@
-# Tech Stack Guide
-
-## Overview
-This reference guide details production-grade tech stack patterns, concrete typescript implementations, and scaling strategies for React 19, Next.js 15, PostgreSQL, and connection pooling.
-
----
-
-## Production Patterns & Practices
-
-### 1. Server-First Next.js 15 Architecture
-
-Next.js 15 standardizes on React Server Components (RSC) by default. Data fetching is co-located with rendering, preventing waterfalls and saving significant client bandwidth.
-
-#### Pattern: Modular Layout & Data Fetching
-
-```tsx
-// app/dashboard/layout.tsx
-import { ReactNode } from 'react';
-import { Sidebar } from '@/components/dashboard/sidebar';
-import { Header } from '@/components/dashboard/header';
-
-export default async function DashboardLayout({ children }: { children: ReactNode }) {
-  return (
-    <div className="flex h-screen overflow-hidden bg-slate-50">
-      <Sidebar />
-      <div className="flex flex-1 flex-col overflow-y-auto">
-        <Header />
-        <main className="p-6">{children}</main>
-      </div>
-    </div>
-  );
-}
-```
-
-```tsx
-// app/dashboard/page.tsx
-import { Suspense } from 'react';
-import { db } from '@/lib/db';
-import { workspaces } from '@/lib/db/schema';
-import { auth } from '@clerk/nextjs/server';
-import { eq } from 'drizzle-orm';
-import { Skeleton } from '@/components/ui/skeleton';
-import { WorkspaceCard } from '@/components/dashboard/workspace-card';
-
-// Server-side dynamic fetching component
-async function WorkspaceList() {
-  const { userId } = await auth();
-  if (!userId) throw new Error('Unauthorized');
-
-  const userWorkspaces = await db
-    .select()
-    .from(workspaces)
-    .where(eq(workspaces.ownerId, userId));
-
-  return (
-    <div className="grid gap-4 md:grid-cols-3">
-      {userWorkspaces.map((ws) => (
-        <WorkspaceCard key={ws.id} workspace={ws} />
-      ))}
-    </div>
-  );
-}
-
-export default function DashboardPage() {
-  return (
-    <div className="space-y-6">
-      <h1 className="text-3xl font-bold">Your Workspaces</h1>
-      <Suspense fallback={<div className="grid gap-4 md:grid-cols-3"><Skeleton className="h-32 w-full" /></div>}>
-        <WorkspaceList />
-      </Suspense>
-    </div>
-  );
-}
-```
-
----
-
-### 2. High-Performance PostgreSQL & Connection Pooling
-
-In a serverless runtime (e.g., Vercel / Netlify Functions), direct database connections spike exponentially during peak request loads. Employ transaction connection pooling (via Supabase Supavisor, PgBouncer, or Neon Serverless Driver) to recycle handles.
-
-#### Pattern: Multi-Client Connection Configuration (`lib/db/index.ts`)
-
-```typescript
-import { drizzle } from 'drizzle-orm/postgres-js';
-import postgres from 'postgres';
-import * as schema from './schema';
-
-// Enforce single database client in development to prevent hot-reload socket exhaustion
-const globalForDb = globalThis as unknown as {
-  conn: postgres.Sql | undefined;
-};
-
-// Use transaction pooling for high concurrent workloads
-const connectionString = process.env.DATABASE_URL!;
-
-const client = globalForDb.conn ?? postgres(connectionString, {
-  max: process.env.DB_MAX_CONNECTIONS ? parseInt(process.env.DB_MAX_CONNECTIONS) : 10,
-  prepare: false, // Set to false when utilizing Transaction poolers like pgBouncer/Supavisor
-  idle_timeout: 20,
-  connect_timeout: 10,
-});
-
-if (process.env.NODE_ENV !== 'production') {
-  globalForDb.conn = client;
-}
-
-export const db = drizzle(client, { schema });
-```
-
----
-
-## Technical Guidelines & Guidelines
-
-### Type-Safe REST Contracts
-
-Utilize Zod structures on both the client form schemas and the server-side Next.js route handlers to achieve full type safety across HTTP borders.
-
-```typescript
-// lib/validators/auth.ts
-import { z } from 'zod';
-
-export const SignupSchema = z.object({
-  email: z.string().email('Please supply a valid email address'),
-  password: z.string().min(8, 'Password must contain at least 8 characters'),
-  name: z.string().min(2, 'Name must contain at least 2 characters').optional(),
-});
-
-export type SignupInput = z.infer<typeof SignupSchema>;
-```
-
-```typescript
-// app/api/auth/signup/route.ts
-import { NextResponse } from 'next/server';
-import { SignupSchema } from '@/lib/validators/auth';
-import { db } from '@/lib/db';
-import { users } from '@/lib/db/schema';
-import { hash } from 'bcrypt';
-
-export async function POST(req: Request) {
-  try {
-    const body = await req.json();
-    const result = SignupSchema.safeParse(body);
-
-    if (!result.success) {
-      return NextResponse.json({ error: result.error.format() }, { status: 400 });
-    }
-
-    const { email, password, name } = result.data;
-
-    // Check if user already exists
-    const existing = await db.query.users.findFirst({
-      where: (u, { eq }) => eq(u.email, email),
-    });
-
-    if (existing) {
-      return NextResponse.json({ error: 'User already exists' }, { status: 409 });
-    }
-
-    const hashedPassword = await hash(password, 12);
-
-    const [newUser] = await db.insert(users).values({
-      email,
-      name,
-      password: hashedPassword,
-    }).returning();
-
-    return NextResponse.json({ id: newUser.id, email: newUser.email, name: newUser.name }, { status: 201 });
-  } catch (err) {
-    return NextResponse.json({ error: 'Internal Server Error' }, { status: 500 });
-  }
-}
-```
-
----
-
-## Anti-Patterns to Avoid
-
-### 🚫 Client-Side Waterfall Loading
-*Do not* chain individual API requests inside standard client-side `useEffect` declarations (e.g. Fetch user -> then fetch workspaces -> then fetch analytics).
-*Instead:* Prefetch parallel states via Next.js server components or leverage dynamic `Promise.all` scopes before returning client modules.
-
-### 🚫 Global Database Client Hot Exhaustion
-*Do not* initialize fresh database connections inline inside database-consuming server functions.
-*Instead:* Maintain a shared, global db handle scoped correctly to check development hot-reloads.
-
----
-
-## Conclusion
-Adhering to server-first Next.js models paired with secure pooled database connections will guarantee your fullstack applications execute fast, scale securely, and retain complete end-to-end type safety.

package/skills/senior-fullstack/scripts/code_quality_analyzer.py

@@ -1,114 +0,0 @@
-#!/usr/bin/env python3
-"""
-Code Quality Analyzer
-Automated tool for senior fullstack tasks
-"""
-
-import os
-import sys
-import json
-import argparse
-from pathlib import Path
-from typing import Dict, List, Optional
-
-class CodeQualityAnalyzer:
-    """Main class for code quality analyzer functionality"""
-    
-    def __init__(self, target_path: str, verbose: bool = False):
-        self.target_path = Path(target_path)
-        self.verbose = verbose
-        self.results = {}
-    
-    def run(self) -> Dict:
-        """Execute the main functionality"""
-        print(f"🚀 Running {self.__class__.__name__}...")
-        print(f"📁 Target: {self.target_path}")
-        
-        try:
-            self.validate_target()
-            self.analyze()
-            self.generate_report()
-            
-            print("✅ Completed successfully!")
-            return self.results
-            
-        except Exception as e:
-            print(f"❌ Error: {e}")
-            sys.exit(1)
-    
-    def validate_target(self):
-        """Validate the target path exists and is accessible"""
-        if not self.target_path.exists():
-            raise ValueError(f"Target path does not exist: {self.target_path}")
-        
-        if self.verbose:
-            print(f"✓ Target validated: {self.target_path}")
-    
-    def analyze(self):
-        """Perform the main analysis or operation"""
-        if self.verbose:
-            print("📊 Analyzing...")
-        
-        # Main logic here
-        self.results['status'] = 'success'
-        self.results['target'] = str(self.target_path)
-        self.results['findings'] = []
-        
-        # Add analysis results
-        if self.verbose:
-            print(f"✓ Analysis complete: {len(self.results.get('findings', []))} findings")
-    
-    def generate_report(self):
-        """Generate and display the report"""
-        print("\n" + "="*50)
-        print("REPORT")
-        print("="*50)
-        print(f"Target: {self.results.get('target')}")
-        print(f"Status: {self.results.get('status')}")
-        print(f"Findings: {len(self.results.get('findings', []))}")
-        print("="*50 + "\n")
-
-def main():
-    """Main entry point"""
-    parser = argparse.ArgumentParser(
-        description="Code Quality Analyzer"
-    )
-    parser.add_argument(
-        'target',
-        help='Target path to analyze or process'
-    )
-    parser.add_argument(
-        '--verbose', '-v',
-        action='store_true',
-        help='Enable verbose output'
-    )
-    parser.add_argument(
-        '--json',
-        action='store_true',
-        help='Output results as JSON'
-    )
-    parser.add_argument(
-        '--output', '-o',
-        help='Output file path'
-    )
-    
-    args = parser.parse_args()
-    
-    tool = CodeQualityAnalyzer(
-        args.target,
-        verbose=args.verbose
-    )
-    
-    results = tool.run()
-    
-    if args.json:
-        output = json.dumps(results, indent=2)
-        if args.output:
-            with open(args.output, 'w') as f:
-                f.write(output)
-            print(f"Results written to {args.output}")
-        else:
-            print(output)
-
-if __name__ == '__main__':
-    main()