omgkit 1.0.0

package/plugin/skills/devops/docker/SKILL.md

@@ -0,0 +1,54 @@
+---
+name: docker
+description: Docker containerization. Use for Dockerfiles, docker-compose, container patterns.
+---
+
+# Docker Skill
+
+## Multi-stage Build
+```dockerfile
+FROM node:20-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+RUN npm run build
+
+FROM node:20-alpine
+WORKDIR /app
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/node_modules ./node_modules
+EXPOSE 3000
+CMD ["node", "dist/index.js"]
+```
+
+## Docker Compose
+```yaml
+version: '3.8'
+services:
+  app:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - DATABASE_URL=postgres://db:5432/app
+    depends_on:
+      - db
+
+  db:
+    image: postgres:15-alpine
+    environment:
+      - POSTGRES_DB=app
+    volumes:
+      - pgdata:/var/lib/postgresql/data
+
+volumes:
+  pgdata:
+```
+
+## Best Practices
+- Use specific base image tags
+- Multi-stage builds
+- .dockerignore file
+- Non-root user
+- Health checks

package/plugin/skills/devops/github-actions/SKILL.md

@@ -0,0 +1,63 @@
+---
+name: github-actions
+description: GitHub Actions CI/CD. Use for workflows, automation, deployments.
+---
+
+# GitHub Actions Skill
+
+## CI Workflow
+```yaml
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          cache: 'npm'
+
+      - run: npm ci
+      - run: npm run lint
+      - run: npm test
+      - run: npm run build
+```
+
+## Deploy Workflow
+```yaml
+deploy:
+  needs: test
+  if: github.ref == 'refs/heads/main'
+  runs-on: ubuntu-latest
+
+  steps:
+    - uses: actions/checkout@v4
+    - run: npm ci && npm run build
+    - uses: some/deploy-action@v1
+      with:
+        token: ${{ secrets.DEPLOY_TOKEN }}
+```
+
+## Matrix Build
+```yaml
+strategy:
+  matrix:
+    node: [18, 20, 22]
+    os: [ubuntu-latest, macos-latest]
+```
+
+## Best Practices
+- Cache dependencies
+- Use matrix for multiple versions
+- Use secrets for sensitive data
+- Add status badges

package/plugin/skills/devops/kubernetes/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: kubernetes
+description: Kubernetes orchestration. Use for K8s manifests, deployments, services.
+---
+
+# Kubernetes Skill
+
+## Deployment
+```yaml
+apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: app
+spec:
+  replicas: 3
+  selector:
+    matchLabels:
+      app: myapp
+  template:
+    metadata:
+      labels:
+        app: myapp
+    spec:
+      containers:
+        - name: app
+          image: myapp:latest
+          ports:
+            - containerPort: 3000
+          resources:
+            limits:
+              memory: "256Mi"
+              cpu: "500m"
+```
+
+## Service
+```yaml
+apiVersion: v1
+kind: Service
+metadata:
+  name: app-service
+spec:
+  selector:
+    app: myapp
+  ports:
+    - port: 80
+      targetPort: 3000
+  type: LoadBalancer
+```
+
+## ConfigMap
+```yaml
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: app-config
+data:
+  API_URL: "https://api.example.com"
+```
+
+## Best Practices
+- Use namespaces
+- Set resource limits
+- Use health probes
+- Use ConfigMaps/Secrets

package/plugin/skills/frameworks/django/SKILL.md

@@ -0,0 +1,47 @@
+---
+name: django
+description: Django development. Use for Django projects, ORM, admin, templates.
+---
+
+# Django Skill
+
+## Patterns
+
+### Model
+```python
+from django.db import models
+
+class User(models.Model):
+    email = models.EmailField(unique=True)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+    class Meta:
+        ordering = ['-created_at']
+```
+
+### View
+```python
+from django.views import View
+from django.http import JsonResponse
+
+class UserView(View):
+    def get(self, request, id):
+        user = User.objects.get(id=id)
+        return JsonResponse({'email': user.email})
+```
+
+### Serializer (DRF)
+```python
+from rest_framework import serializers
+
+class UserSerializer(serializers.ModelSerializer):
+    class Meta:
+        model = User
+        fields = ['id', 'email', 'created_at']
+```
+
+## Best Practices
+- Use class-based views
+- Use Django REST Framework
+- Use migrations
+- Use signals sparingly

package/plugin/skills/frameworks/express/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: express
+description: Express.js development. Use for Express APIs, middleware, routing.
+---
+
+# Express.js Skill
+
+## Patterns
+
+### Basic Setup
+```javascript
+import express from 'express';
+
+const app = express();
+app.use(express.json());
+```
+
+### Routes
+```javascript
+app.get('/users', async (req, res) => {
+  const users = await db.users.findMany();
+  res.json(users);
+});
+
+app.post('/users', async (req, res) => {
+  const user = await db.users.create(req.body);
+  res.status(201).json(user);
+});
+```
+
+### Middleware
+```javascript
+function authMiddleware(req, res, next) {
+  const token = req.headers.authorization;
+  if (!token) return res.status(401).json({ error: 'Unauthorized' });
+  req.user = verifyToken(token);
+  next();
+}
+
+app.use('/api', authMiddleware);
+```
+
+### Error Handler
+```javascript
+app.use((err, req, res, next) => {
+  console.error(err);
+  res.status(500).json({ error: 'Internal Server Error' });
+});
+```
+
+## Best Practices
+- Use async/await with try/catch
+- Use middleware for cross-cutting concerns
+- Validate input
+- Use proper status codes

package/plugin/skills/frameworks/fastapi/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: fastapi
+description: FastAPI development. Use for FastAPI projects, async APIs, Pydantic models.
+---
+
+# FastAPI Skill
+
+## Setup
+```python
+from fastapi import FastAPI, HTTPException, Depends
+from pydantic import BaseModel
+
+app = FastAPI()
+```
+
+## Patterns
+
+### Route with Pydantic
+```python
+class UserCreate(BaseModel):
+    email: str
+    password: str
+
+class User(BaseModel):
+    id: str
+    email: str
+
+@app.post("/users", response_model=User)
+async def create_user(user: UserCreate):
+    return await db.create_user(user)
+```
+
+### Dependency Injection
+```python
+async def get_db():
+    db = Database()
+    try:
+        yield db
+    finally:
+        await db.close()
+
+@app.get("/users/{id}")
+async def get_user(id: str, db: Database = Depends(get_db)):
+    return await db.get_user(id)
+```
+
+### Error Handling
+```python
+@app.exception_handler(ValueError)
+async def value_error_handler(request, exc):
+    return JSONResponse(status_code=400, content={"error": str(exc)})
+```
+
+## Best Practices
+- Use Pydantic for validation
+- Use async/await
+- Use dependency injection
+- Document with OpenAPI

package/plugin/skills/frameworks/laravel/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: laravel
+description: Laravel PHP development. Use for Laravel projects, Eloquent, Blade.
+---
+
+# Laravel Skill
+
+## Patterns
+
+### Model
+```php
+class User extends Model
+{
+    protected $fillable = ['email', 'password'];
+    protected $hidden = ['password'];
+
+    public function posts()
+    {
+        return $this->hasMany(Post::class);
+    }
+}
+```
+
+### Controller
+```php
+class UserController extends Controller
+{
+    public function index()
+    {
+        return User::all();
+    }
+
+    public function store(Request $request)
+    {
+        $validated = $request->validate([
+            'email' => 'required|email|unique:users',
+            'password' => 'required|min:8',
+        ]);
+
+        $user = User::create($validated);
+        return response()->json($user, 201);
+    }
+}
+```
+
+### Routes
+```php
+Route::apiResource('users', UserController::class);
+```
+
+### Migration
+```php
+Schema::create('users', function (Blueprint $table) {
+    $table->id();
+    $table->string('email')->unique();
+    $table->string('password');
+    $table->timestamps();
+});
+```
+
+## Best Practices
+- Use Eloquent relationships
+- Use Form Requests
+- Use Resources for API responses
+- Use Jobs for async

package/plugin/skills/frameworks/nestjs/SKILL.md

@@ -0,0 +1,67 @@
+---
+name: nestjs
+description: NestJS development. Use for NestJS projects, modules, dependency injection.
+---
+
+# NestJS Skill
+
+## Patterns
+
+### Module
+```typescript
+@Module({
+  imports: [DatabaseModule],
+  controllers: [UsersController],
+  providers: [UsersService],
+  exports: [UsersService],
+})
+export class UsersModule {}
+```
+
+### Controller
+```typescript
+@Controller('users')
+export class UsersController {
+  constructor(private usersService: UsersService) {}
+
+  @Get()
+  findAll() {
+    return this.usersService.findAll();
+  }
+
+  @Post()
+  create(@Body() dto: CreateUserDto) {
+    return this.usersService.create(dto);
+  }
+}
+```
+
+### Service
+```typescript
+@Injectable()
+export class UsersService {
+  constructor(private db: DatabaseService) {}
+
+  async findAll() {
+    return this.db.users.findMany();
+  }
+}
+```
+
+### DTO
+```typescript
+export class CreateUserDto {
+  @IsEmail()
+  email: string;
+
+  @IsString()
+  @MinLength(8)
+  password: string;
+}
+```
+
+## Best Practices
+- Use modules for organization
+- Use DTOs for validation
+- Use dependency injection
+- Use guards for auth

package/plugin/skills/frameworks/nextjs/SKILL.md

@@ -0,0 +1,77 @@
+---
+name: nextjs
+description: Next.js development. Use for Next.js projects, App Router, Server Components, Server Actions.
+---
+
+# Next.js Skill
+
+## App Router
+
+### Server Component (default)
+```tsx
+// app/users/page.tsx
+async function UsersPage() {
+  const users = await fetch('/api/users').then(r => r.json());
+  return <UserList users={users} />;
+}
+```
+
+### Client Component
+```tsx
+'use client';
+
+import { useState } from 'react';
+
+export function Counter() {
+  const [count, setCount] = useState(0);
+  return <button onClick={() => setCount(c => c + 1)}>{count}</button>;
+}
+```
+
+### Server Action
+```tsx
+'use server';
+
+import { revalidatePath } from 'next/cache';
+
+export async function createUser(formData: FormData) {
+  await db.users.create({
+    email: formData.get('email'),
+  });
+  revalidatePath('/users');
+}
+```
+
+### Route Handler
+```tsx
+// app/api/users/route.ts
+export async function GET() {
+  const users = await db.users.findMany();
+  return Response.json(users);
+}
+
+export async function POST(request: Request) {
+  const body = await request.json();
+  const user = await db.users.create(body);
+  return Response.json(user, { status: 201 });
+}
+```
+
+## File Structure
+```
+app/
+├── layout.tsx
+├── page.tsx
+├── users/
+│   ├── page.tsx
+│   └── [id]/page.tsx
+└── api/
+    └── users/route.ts
+```
+
+## Best Practices
+- Default to Server Components
+- Use 'use client' only when needed
+- Use Server Actions for mutations
+- Use loading.tsx for loading states
+- Use error.tsx for error handling

package/plugin/skills/frameworks/rails/SKILL.md

@@ -0,0 +1,56 @@
+---
+name: rails
+description: Ruby on Rails development. Use for Rails projects, MVC, ActiveRecord.
+---
+
+# Ruby on Rails Skill
+
+## Patterns
+
+### Model
+```ruby
+class User < ApplicationRecord
+  validates :email, presence: true, uniqueness: true
+  has_many :posts
+
+  scope :active, -> { where(active: true) }
+end
+```
+
+### Controller
+```ruby
+class UsersController < ApplicationController
+  def index
+    @users = User.all
+    render json: @users
+  end
+
+  def create
+    @user = User.new(user_params)
+    if @user.save
+      render json: @user, status: :created
+    else
+      render json: @user.errors, status: :unprocessable_entity
+    end
+  end
+
+  private
+
+  def user_params
+    params.require(:user).permit(:email, :password)
+  end
+end
+```
+
+### Routes
+```ruby
+Rails.application.routes.draw do
+  resources :users, only: [:index, :create, :show]
+end
+```
+
+## Best Practices
+- Use strong params
+- Use scopes for queries
+- Use concerns for shared code
+- Use background jobs for async

package/plugin/skills/frameworks/react/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: react
+description: React development. Use for React components, hooks, state management.
+---
+
+# React Skill
+
+## Patterns
+
+### Functional Component
+```tsx
+interface ButtonProps {
+  onClick: () => void;
+  children: React.ReactNode;
+}
+
+export function Button({ onClick, children }: ButtonProps) {
+  return <button onClick={onClick}>{children}</button>;
+}
+```
+
+### Hooks
+```tsx
+// useState
+const [count, setCount] = useState(0);
+
+// useEffect
+useEffect(() => {
+  fetchData();
+  return () => cleanup();
+}, [dependency]);
+
+// useCallback
+const handleClick = useCallback(() => {
+  doSomething(value);
+}, [value]);
+
+// useMemo
+const computed = useMemo(() => expensiveCalc(data), [data]);
+```
+
+### Custom Hook
+```tsx
+function useUser(id: string) {
+  const [user, setUser] = useState<User | null>(null);
+  const [loading, setLoading] = useState(true);
+
+  useEffect(() => {
+    fetchUser(id).then(setUser).finally(() => setLoading(false));
+  }, [id]);
+
+  return { user, loading };
+}
+```
+
+## Best Practices
+- Use functional components
+- Keep components small
+- Lift state up when needed
+- Use custom hooks for logic
+- Memoize expensive operations