aigroup-workflow 2.1.1 → 2.2.0

package/skills/nextjs-developer/references/server-components.md

@@ -1,384 +0,0 @@
-# React Server Components
-
-## Server Components (Default)
-
-```tsx
-// app/page.tsx - Server Component by default
-import { db } from '@/lib/db'
-
-export default async function Page() {
-  // Data fetching in Server Component
-  const users = await db.user.findMany()
-
-  return (
-    <div>
-      <h1>Users</h1>
-      <ul>
-        {users.map(user => (
-          <li key={user.id}>{user.name}</li>
-        ))}
-      </ul>
-    </div>
-  )
-}
-```
-
-## Benefits of Server Components
-
-- **Zero bundle size** - Server Components don't add JavaScript to client bundle
-- **Direct backend access** - Query databases, read files, use secrets
-- **Automatic code splitting** - Only Client Components add to bundle
-- **Streaming** - Send UI progressively as data loads
-- **No client-side waterfalls** - Fetch all data in parallel on server
-
-## Client Components
-
-```tsx
-// components/counter.tsx
-'use client' // Required directive
-
-import { useState } from 'react'
-
-export function Counter() {
-  const [count, setCount] = useState(0)
-
-  return (
-    <button onClick={() => setCount(count + 1)}>
-      Count: {count}
-    </button>
-  )
-}
-```
-
-## When to Use Client Components
-
-Use `'use client'` when you need:
-- **Interactivity** - onClick, onChange, event handlers
-- **State** - useState, useReducer
-- **Effects** - useEffect, useLayoutEffect
-- **Browser APIs** - localStorage, window, document
-- **Custom hooks** - Any hook using client-only features
-- **Class components** - Component lifecycle methods
-
-## Composition Pattern
-
-```tsx
-// app/page.tsx - Server Component
-import { ClientWrapper } from './client-wrapper'
-import { db } from '@/lib/db'
-
-export default async function Page() {
-  const data = await db.query()
-
-  return (
-    <div>
-      {/* Server Component content */}
-      <h1>Server Content</h1>
-
-      {/* Pass data to Client Component */}
-      <ClientWrapper initialData={data}>
-        {/* Server Component as children */}
-        <ServerSidebar />
-      </ClientWrapper>
-    </div>
-  )
-}
-
-// components/client-wrapper.tsx
-'use client'
-
-export function ClientWrapper({
-  children,
-  initialData,
-}: {
-  children: React.ReactNode
-  initialData: Data
-}) {
-  const [data, setData] = useState(initialData)
-
-  return (
-    <div>
-      {/* Client Component UI */}
-      <button onClick={() => refresh()}>Refresh</button>
-      {/* Server Component children */}
-      {children}
-    </div>
-  )
-}
-```
-
-## Streaming with Suspense
-
-```tsx
-// app/page.tsx
-import { Suspense } from 'react'
-import { SlowComponent } from './slow-component'
-import { FastComponent } from './fast-component'
-
-export default function Page() {
-  return (
-    <div>
-      {/* Renders immediately */}
-      <FastComponent />
-
-      {/* Shows fallback while loading */}
-      <Suspense fallback={<div>Loading...</div>}>
-        <SlowComponent />
-      </Suspense>
-    </div>
-  )
-}
-
-// components/slow-component.tsx
-async function getData() {
-  await new Promise(resolve => setTimeout(resolve, 3000))
-  return { data: 'Loaded!' }
-}
-
-export async function SlowComponent() {
-  const data = await getData()
-  return <div>{data.data}</div>
-}
-```
-
-## Parallel Data Fetching
-
-```tsx
-// app/dashboard/page.tsx
-async function getUser() {
-  return fetch('https://api.example.com/user')
-}
-
-async function getPosts() {
-  return fetch('https://api.example.com/posts')
-}
-
-export default async function Dashboard() {
-  // Fetch in parallel
-  const [user, posts] = await Promise.all([
-    getUser(),
-    getPosts(),
-  ])
-
-  return (
-    <div>
-      <UserProfile user={user} />
-      <PostsList posts={posts} />
-    </div>
-  )
-}
-```
-
-## Sequential Data Fetching
-
-```tsx
-// app/artist/[id]/page.tsx
-async function getArtist(id: string) {
-  return fetch(`https://api.example.com/artists/${id}`)
-}
-
-async function getAlbums(artistId: string) {
-  return fetch(`https://api.example.com/artists/${artistId}/albums`)
-}
-
-export default async function ArtistPage({ params }: { params: { id: string } }) {
-  // Sequential: albums depends on artist
-  const artist = await getArtist(params.id)
-  const albums = await getAlbums(artist.id)
-
-  return (
-    <div>
-      <h1>{artist.name}</h1>
-      <Albums albums={albums} />
-    </div>
-  )
-}
-```
-
-## Preloading Data
-
-```tsx
-// lib/data.ts
-import { cache } from 'react'
-
-export const getUser = cache(async (id: string) => {
-  return db.user.findUnique({ where: { id } })
-})
-
-// components/user-profile.tsx
-export async function UserProfile({ userId }: { userId: string }) {
-  const user = await getUser(userId)
-  return <div>{user.name}</div>
-}
-
-// app/page.tsx
-import { getUser } from '@/lib/data'
-import { UserProfile } from '@/components/user-profile'
-
-export default async function Page() {
-  // Preload
-  getUser('123')
-
-  return (
-    <div>
-      {/* This will use cached result */}
-      <UserProfile userId="123" />
-    </div>
-  )
-}
-```
-
-## Server Component Patterns
-
-### Pattern: Layout with Data Fetching
-
-```tsx
-// app/dashboard/layout.tsx
-import { auth } from '@/lib/auth'
-import { db } from '@/lib/db'
-
-export default async function DashboardLayout({
-  children,
-}: {
-  children: React.ReactNode
-}) {
-  const session = await auth()
-  const user = await db.user.findUnique({ where: { id: session.userId } })
-
-  return (
-    <div>
-      <Sidebar user={user} />
-      <main>{children}</main>
-    </div>
-  )
-}
-```
-
-### Pattern: Conditional Client Components
-
-```tsx
-// app/page.tsx
-import { ClientComponent } from './client-component'
-
-export default async function Page() {
-  const data = await fetchData()
-
-  // Only render Client Component when needed
-  if (data.requiresInteractivity) {
-    return <ClientComponent data={data} />
-  }
-
-  return <div>{data.content}</div>
-}
-```
-
-### Pattern: Server Component with Client Island
-
-```tsx
-// app/blog/[slug]/page.tsx
-import { LikeButton } from './like-button'
-
-export default async function BlogPost({ params }: { params: { slug: string } }) {
-  const post = await getPost(params.slug)
-
-  return (
-    <article>
-      {/* Server-rendered content */}
-      <h1>{post.title}</h1>
-      <div dangerouslySetInnerHTML={{ __html: post.content }} />
-
-      {/* Client island for interactivity */}
-      <LikeButton postId={post.id} initialLikes={post.likes} />
-    </article>
-  )
-}
-```
-
-## Context in Server/Client Components
-
-```tsx
-// app/providers.tsx
-'use client'
-
-import { ThemeProvider } from 'next-themes'
-
-export function Providers({ children }: { children: React.ReactNode }) {
-  return <ThemeProvider>{children}</ThemeProvider>
-}
-
-// app/layout.tsx
-import { Providers } from './providers'
-
-export default function RootLayout({
-  children,
-}: {
-  children: React.ReactNode
-}) {
-  return (
-    <html>
-      <body>
-        <Providers>{children}</Providers>
-      </body>
-    </html>
-  )
-}
-```
-
-## Third-Party Components
-
-```tsx
-// components/carousel-wrapper.tsx
-'use client'
-
-import { Carousel } from 'third-party-carousel'
-
-export function CarouselWrapper({ items }: { items: Item[] }) {
-  return <Carousel items={items} />
-}
-
-// app/page.tsx
-import { CarouselWrapper } from '@/components/carousel-wrapper'
-
-export default async function Page() {
-  const items = await fetchItems()
-  return <CarouselWrapper items={items} />
-}
-```
-
-## Edge Runtime
-
-```tsx
-// app/api/route.ts
-export const runtime = 'edge'
-
-export async function GET() {
-  return new Response('Hello from Edge!')
-}
-
-// app/page.tsx
-export const runtime = 'edge'
-
-export default async function Page() {
-  return <div>Edge-rendered page</div>
-}
-```
-
-## Quick Reference
-
-| Capability | Server Component | Client Component |
-|------------|------------------|------------------|
-| Data fetching | ✅ Yes | ⚠️ Use SWR/React Query |
-| Backend access | ✅ Yes (DB, files) | ❌ No |
-| Event handlers | ❌ No | ✅ Yes |
-| State/Effects | ❌ No | ✅ Yes |
-| Browser APIs | ❌ No | ✅ Yes |
-| Bundle size | 0 KB | Adds to bundle |
-| Streaming | ✅ Yes | ❌ No |
-
-## Best Practices
-
-1. **Default to Server Components** - Only use 'use client' when needed
-2. **Move Client Components down** - Push them to leaves of component tree
-3. **Pass data down** - Fetch in Server Components, pass to Client Components
-4. **Use composition** - Nest Server Components inside Client Components via children
-5. **Cache expensive operations** - Use React cache() for deduplication

package/skills/pandas-pro/SKILL.md

@@ -1,178 +0,0 @@
----
-name: pandas-pro
-description: Performs pandas DataFrame operations for data analysis, manipulation, and transformation. Use when working with pandas DataFrames, data cleaning, aggregation, merging, or time series analysis. Invoke for data manipulation tasks such as joining DataFrames on multiple keys, pivoting tables, resampling time series, handling NaN values with interpolation or forward-fill, groupby aggregations, type conversion, or performance optimization of large datasets.
-license: MIT
-metadata:
-  author: https://github.com/Jeffallan
-  version: "1.1.0"
-  domain: data-ml
-  triggers: pandas, DataFrame, data manipulation, data cleaning, aggregation, groupby, merge, join, time series, data wrangling, pivot table, data transformation
-  role: expert
-  scope: implementation
-  output-format: code
-  related-skills: python-pro
----
-
-# Pandas Pro
-
-Expert pandas developer specializing in efficient data manipulation, analysis, and transformation workflows with production-grade performance patterns.
-
-## Core Workflow
-
-1. **Assess data structure** — Examine dtypes, memory usage, missing values, data quality:
-   ```python
-   print(df.dtypes)
-   print(df.memory_usage(deep=True).sum() / 1e6, "MB")
-   print(df.isna().sum())
-   print(df.describe(include="all"))
-   ```
-2. **Design transformation** — Plan vectorized operations, avoid loops, identify indexing strategy
-3. **Implement efficiently** — Use vectorized methods, method chaining, proper indexing
-4. **Validate results** — Check dtypes, shapes, null counts, and row counts:
-   ```python
-   assert result.shape[0] == expected_rows, f"Row count mismatch: {result.shape[0]}"
-   assert result.isna().sum().sum() == 0, "Unexpected nulls after transform"
-   assert set(result.columns) == expected_cols
-   ```
-5. **Optimize** — Profile memory, apply categorical types, use chunking if needed
-
-## Reference Guide
-
-Load detailed guidance based on context:
-
-| Topic | Reference | Load When |
-|-------|-----------|-----------|
-| DataFrame Operations | `references/dataframe-operations.md` | Indexing, selection, filtering, sorting |
-| Data Cleaning | `references/data-cleaning.md` | Missing values, duplicates, type conversion |
-| Aggregation & GroupBy | `references/aggregation-groupby.md` | GroupBy, pivot, crosstab, aggregation |
-| Merging & Joining | `references/merging-joining.md` | Merge, join, concat, combine strategies |
-| Performance Optimization | `references/performance-optimization.md` | Memory usage, vectorization, chunking |
-
-## Code Patterns
-
-### Vectorized Operations (before/after)
-
-```python
-# ❌ AVOID: row-by-row iteration
-for i, row in df.iterrows():
-    df.at[i, 'tax'] = row['price'] * 0.2
-
-# ✅ USE: vectorized assignment
-df['tax'] = df['price'] * 0.2
-```
-
-### Safe Subsetting with `.copy()`
-
-```python
-# ❌ AVOID: chained indexing triggers SettingWithCopyWarning
-df['A']['B'] = 1
-
-# ✅ USE: .loc[] with explicit copy when mutating a subset
-subset = df.loc[df['status'] == 'active', :].copy()
-subset['score'] = subset['score'].fillna(0)
-```
-
-### GroupBy Aggregation
-
-```python
-summary = (
-    df.groupby(['region', 'category'], observed=True)
-    .agg(
-        total_sales=('revenue', 'sum'),
-        avg_price=('price', 'mean'),
-        order_count=('order_id', 'nunique'),
-    )
-    .reset_index()
-)
-```
-
-### Merge with Validation
-
-```python
-merged = pd.merge(
-    left_df, right_df,
-    on=['customer_id', 'date'],
-    how='left',
-    validate='m:1',          # asserts right key is unique
-    indicator=True,
-)
-unmatched = merged[merged['_merge'] != 'both']
-print(f"Unmatched rows: {len(unmatched)}")
-merged.drop(columns=['_merge'], inplace=True)
-```
-
-### Missing Value Handling
-
-```python
-# Forward-fill then interpolate numeric gaps
-df['price'] = df['price'].ffill().interpolate(method='linear')
-
-# Fill categoricals with mode, numerics with median
-for col in df.select_dtypes(include='object'):
-    df[col] = df[col].fillna(df[col].mode()[0])
-for col in df.select_dtypes(include='number'):
-    df[col] = df[col].fillna(df[col].median())
-```
-
-### Time Series Resampling
-
-```python
-daily = (
-    df.set_index('timestamp')
-    .resample('D')
-    .agg({'revenue': 'sum', 'sessions': 'count'})
-    .fillna(0)
-)
-```
-
-### Pivot Table
-
-```python
-pivot = df.pivot_table(
-    values='revenue',
-    index='region',
-    columns='product_line',
-    aggfunc='sum',
-    fill_value=0,
-    margins=True,
-)
-```
-
-### Memory Optimization
-
-```python
-# Downcast numerics and convert low-cardinality strings to categorical
-df['category'] = df['category'].astype('category')
-df['count'] = pd.to_numeric(df['count'], downcast='integer')
-df['score'] = pd.to_numeric(df['score'], downcast='float')
-print(df.memory_usage(deep=True).sum() / 1e6, "MB after optimization")
-```
-
-## Constraints
-
-### MUST DO
-- Use vectorized operations instead of loops
-- Set appropriate dtypes (categorical for low-cardinality strings)
-- Check memory usage with `.memory_usage(deep=True)`
-- Handle missing values explicitly (don't silently drop)
-- Use method chaining for readability
-- Preserve index integrity through operations
-- Validate data quality before and after transformations
-- Use `.copy()` when modifying subsets to avoid SettingWithCopyWarning
-
-### MUST NOT DO
-- Iterate over DataFrame rows with `.iterrows()` unless absolutely necessary
-- Use chained indexing (`df['A']['B']`) — use `.loc[]` or `.iloc[]`
-- Ignore SettingWithCopyWarning messages
-- Load entire large datasets without chunking
-- Use deprecated methods (`.ix`, `.append()` — use `pd.concat()`)
-- Convert to Python lists for operations possible in pandas
-- Assume data is clean without validation
-
-## Output Templates
-
-When implementing pandas solutions, provide:
-1. Code with vectorized operations and proper indexing
-2. Comments explaining complex transformations
-3. Memory/performance considerations if dataset is large
-4. Data validation checks (dtypes, nulls, shapes)