omgkit 1.0.0

package/plugin/mcp/.mcp.json

@@ -0,0 +1,20 @@
+{
+  "mcpServers": {
+    "context7": {
+      "command": "npx",
+      "args": ["-y", "@upstash/context7-mcp"]
+    },
+    "sequential-thinking": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
+    },
+    "memory": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-memory"]
+    },
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
+    }
+  }
+}

package/plugin/mcp/README.md

@@ -0,0 +1,68 @@
+# MCP Server Integrations
+
+OMGKIT supports Model Context Protocol (MCP) servers for enhanced capabilities.
+
+## Supported Servers
+
+| Server | Package | Purpose |
+|--------|---------|---------|
+| **Context7** | `@upstash/context7-mcp` | Up-to-date library documentation |
+| **Sequential Thinking** | `@modelcontextprotocol/server-sequential-thinking` | Multi-step reasoning |
+| **Memory** | `@modelcontextprotocol/server-memory` | Persistent knowledge graph |
+| **Filesystem** | `@modelcontextprotocol/server-filesystem` | Secure file operations |
+
+## Setup
+
+### Option 1: Use provided config
+
+Copy `.mcp.json` to your project root or Claude Code config directory.
+
+### Option 2: Manual setup
+
+Add to your Claude Code MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "context7": {
+      "command": "npx",
+      "args": ["-y", "@upstash/context7-mcp"]
+    },
+    "sequential-thinking": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-sequential-thinking"]
+    },
+    "memory": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-memory"]
+    },
+    "filesystem": {
+      "command": "npx",
+      "args": ["-y", "@modelcontextprotocol/server-filesystem", "."]
+    }
+  }
+}
+```
+
+## Command Enhancements
+
+| Command | MCP Servers | Enhancement |
+|---------|-------------|-------------|
+| `/feature` | Context7, Sequential | Accurate docs, structured planning |
+| `/fix` | Sequential, Memory | Step-by-step debugging |
+| `/test` | Filesystem | File-based test generation |
+| `/plan` | Sequential, Memory | Structured breakdown |
+| `/research` | Context7 | Real-time documentation |
+
+## Enabling/Disabling
+
+In `.omgkit/config.yaml`:
+
+```yaml
+mcp:
+  context7: true
+  sequential: true
+  memory: true
+  filesystem: true
+  playwright: false
+```

package/plugin/modes/autonomous.md

@@ -0,0 +1,48 @@
+---
+name: autonomous
+description: AI team self-management mode for sprint execution.
+---
+
+# Autonomous Mode 🤖
+
+AI team operates with minimal human intervention.
+
+## Behavior
+- Execute tasks continuously
+- Make decisions autonomously
+- Only pause for critical issues
+- Report progress periodically
+- Self-correct when possible
+
+## When to Use
+- Well-defined sprints
+- Clear requirements
+- Trusted codebase
+- Non-critical systems
+
+## Guardrails
+- Follow the plan strictly
+- Respect all constraints
+- Maintain quality gates
+- Log all decisions
+- No destructive operations
+
+## Pause Conditions
+- Critical error encountered
+- Security concern detected
+- Scope creep identified
+- Ambiguous requirement
+- Test failures
+
+## Autonomy Levels
+```
+Full-Auto:  ████████████ 100%
+Semi-Auto:  ████████░░░░  66%
+Manual:     ████░░░░░░░░  33%
+```
+
+## Settings
+- Intervention: Minimal
+- Decision-making: Autonomous
+- Logging: Comprehensive
+- Checkpoints: Periodic

package/plugin/modes/brainstorm.md

@@ -0,0 +1,33 @@
+---
+name: brainstorm
+description: Creative exploration mode for design and ideation.
+---
+
+# Brainstorm Mode
+
+Optimized for creative exploration and ideation.
+
+## Behavior
+- Ask one question at a time
+- Explore multiple alternatives
+- Challenge assumptions
+- No premature judgment
+- Build on ideas
+
+## When to Use
+- Designing new features
+- Exploring solutions
+- Architecture decisions
+- Problem exploration
+
+## Process
+1. Understand the problem deeply
+2. Generate many options
+3. Evaluate trade-offs
+4. Recommend with rationale
+
+## Settings
+- Questions: One at a time
+- Judgment: Deferred
+- Options: 3+ minimum
+- Depth: Exploratory

package/plugin/modes/deep-research.md

@@ -0,0 +1,41 @@
+---
+name: deep-research
+description: Thorough analysis mode with citations and sources.
+---
+
+# Deep Research Mode
+
+Thorough analysis with comprehensive sourcing.
+
+## Behavior
+- Search multiple sources
+- Cite all claims
+- Provide confidence levels
+- Compare alternatives
+- Document assumptions
+
+## When to Use
+- Technical research
+- Architecture decisions
+- Technology evaluation
+- Complex problem analysis
+
+## Output Format
+```markdown
+## Finding
+[Statement] [Source]
+
+## Confidence: HIGH | MEDIUM | LOW
+
+## Sources
+1. [Source] - [Relevance]
+
+## Alternatives Considered
+- [Option] - [Trade-offs]
+```
+
+## Settings
+- Sources: Multiple required
+- Citations: Mandatory
+- Depth: Comprehensive
+- Confidence: Explicit

package/plugin/modes/default.md

@@ -0,0 +1,25 @@
+---
+name: default
+description: Balanced standard behavior for general tasks.
+---
+
+# Default Mode
+
+Balanced approach for general development tasks.
+
+## Behavior
+- Standard planning before implementation
+- Regular quality checks
+- Normal verbosity level
+- Balanced speed vs thoroughness
+
+## When to Use
+- General development tasks
+- Mixed requirements
+- When unsure which mode to use
+
+## Settings
+- Planning: Standard
+- Verbosity: Normal
+- Review: At milestones
+- Testing: Required

package/plugin/modes/implementation.md

@@ -0,0 +1,35 @@
+---
+name: implementation
+description: Code-focused mode with minimal prose.
+---
+
+# Implementation Mode
+
+Optimized for writing code efficiently.
+
+## Behavior
+- Code-first responses
+- Minimal explanations
+- Execute plans directly
+- Focus on output
+- Fast iteration
+
+## When to Use
+- Executing plans
+- Writing code
+- Making changes
+- Bug fixes
+
+## Output
+```typescript
+// Code with minimal comments
+function implementation() {
+  // Only essential comments
+}
+```
+
+## Settings
+- Output: Code primary
+- Comments: Essential only
+- Explanations: Minimal
+- Speed: Prioritized

package/plugin/modes/omega.md

@@ -0,0 +1,38 @@
+---
+name: omega
+description: 10x-1000x thinking mode for breakthrough solutions.
+---
+
+# Omega Mode 🔮
+
+Apply Omega principles to EVERYTHING.
+
+## Mindset
+- Challenge 10x vs 100x vs 1000x
+- Apply 7 thinking modes
+- Seek leverage multiplication
+- Build systems, not features
+- Excellence in everything
+
+## 7 Omega Principles
+1. **Ω1 Leverage Multiplication** - Build systems that build
+2. **Ω2 Transcendent Abstraction** - Solve the class
+3. **Ω3 Agentic Decomposition** - Orchestra of specialists
+4. **Ω4 Feedback Acceleration** - Compress loops
+5. **Ω5 Zero-Marginal-Cost** - Scale infinitely
+6. **Ω6 Emergent Intelligence** - System > parts
+7. **Ω7 Aesthetic Perfection** - Excellence always
+
+## Questions for Every Task
+1. What's the 10x version?
+2. Can we solve the class, not instance?
+3. Can we automate this forever?
+4. What would make this obsolete?
+
+## Mantras
+- "Think 1000x before settling for 10x"
+- "Don't do. Create systems that do."
+- "Solve once for N cases."
+
+---
+🔮 *Think Omega. Build Omega. Be Omega.*

package/plugin/modes/orchestration.md

@@ -0,0 +1,41 @@
+---
+name: orchestration
+description: Multi-task coordination mode for parallel work.
+---
+
+# Orchestration Mode
+
+Coordinate multiple tasks and agents.
+
+## Behavior
+- Parallel task management
+- Agent delegation
+- Result aggregation
+- Workflow optimization
+- Progress tracking
+
+## When to Use
+- Complex features
+- Multiple files
+- Team coordination
+- Sprint execution
+
+## Pattern
+```
+┌─────────────────┐
+│  Orchestrator   │
+└────────┬────────┘
+    ┌────┼────┐
+    ▼    ▼    ▼
+  [A]  [B]  [C]
+    │    │    │
+    └────┼────┘
+         ▼
+   [Aggregate]
+```
+
+## Settings
+- Parallelism: Enabled
+- Delegation: Automatic
+- Sync points: Defined
+- Aggregation: Required

package/plugin/modes/review.md

@@ -0,0 +1,44 @@
+---
+name: review
+description: Critical analysis mode for code review.
+---
+
+# Review Mode
+
+Critical analysis for code review and quality.
+
+## Behavior
+- Find issues proactively
+- Security-focused
+- Performance analysis
+- Constructive feedback
+- Prioritize findings
+
+## Checklist
+- [ ] Security vulnerabilities
+- [ ] Performance issues
+- [ ] Code quality
+- [ ] Best practices
+- [ ] Edge cases
+
+## Output Format
+```markdown
+## Review: [File/PR]
+
+### Status: APPROVED | CHANGES_REQUESTED
+
+### Critical Issues
+1. [Issue] - [Location] - [Fix]
+
+### Suggestions
+1. [Improvement] - [Rationale]
+
+### Positive Notes
+- [Good practice observed]
+```
+
+## Settings
+- Focus: Issues first
+- Security: High priority
+- Feedback: Constructive
+- Severity: Prioritized

package/plugin/modes/token-efficient.md

@@ -0,0 +1,37 @@
+---
+name: token-efficient
+description: Compressed output mode for cost savings (30-70%).
+---
+
+# Token-Efficient Mode
+
+Minimize token usage for cost savings.
+
+## Behavior
+- Concise responses
+- Code over prose
+- No explanations unless asked
+- Abbreviated output
+- Skip optional details
+
+## When to Use
+- Routine tasks
+- Cost-sensitive work
+- When speed matters
+- Familiar patterns
+
+## Savings
+- 30-70% token reduction
+- Faster responses
+- Lower costs
+
+## Trade-offs
+- Less explanation
+- Assumes familiarity
+- May need clarification
+
+## Settings
+- Verbosity: Minimal
+- Explanations: On request only
+- Format: Code-first
+- Comments: Essential only

package/plugin/skills/databases/mongodb/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: mongodb
+description: MongoDB database. Use for document storage, aggregation, NoSQL.
+---
+
+# MongoDB Skill
+
+## Document Design
+```javascript
+{
+  _id: ObjectId(),
+  email: "user@example.com",
+  profile: {
+    name: "John",
+    avatar: "url"
+  },
+  createdAt: ISODate()
+}
+```
+
+## Query Patterns
+```javascript
+// Find
+db.users.find({ email: /example.com/ });
+
+// Aggregation
+db.users.aggregate([
+  { $match: { active: true } },
+  { $group: { _id: "$role", count: { $sum: 1 } } }
+]);
+
+// Update
+db.users.updateOne(
+  { _id: id },
+  { $set: { name: "New Name" } }
+);
+```
+
+## Best Practices
+- Design for queries
+- Embed related data
+- Use indexes
+- Avoid deep nesting

package/plugin/skills/databases/postgresql/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: postgresql
+description: PostgreSQL database. Use for schema design, queries, optimization.
+---
+
+# PostgreSQL Skill
+
+## Schema Design
+```sql
+CREATE TABLE users (
+  id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+  email VARCHAR(255) UNIQUE NOT NULL,
+  password_hash VARCHAR(255) NOT NULL,
+  created_at TIMESTAMPTZ DEFAULT NOW(),
+  updated_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+CREATE INDEX idx_users_email ON users(email);
+```
+
+## Query Patterns
+```sql
+-- Pagination
+SELECT * FROM users
+ORDER BY created_at DESC
+LIMIT 10 OFFSET 20;
+
+-- Search
+SELECT * FROM users
+WHERE email ILIKE '%@example.com';
+
+-- Aggregation
+SELECT DATE(created_at), COUNT(*)
+FROM users
+GROUP BY DATE(created_at);
+```
+
+## Best Practices
+- Use UUIDs for IDs
+- Add indexes for queries
+- Use EXPLAIN ANALYZE
+- Use transactions
+- Use connection pooling

package/plugin/skills/databases/prisma/SKILL.md

@@ -0,0 +1,55 @@
+---
+name: prisma
+description: Prisma ORM. Use for database access, migrations, type-safe queries.
+---
+
+# Prisma Skill
+
+## Schema
+```prisma
+model User {
+  id        String   @id @default(cuid())
+  email     String   @unique
+  posts     Post[]
+  createdAt DateTime @default(now())
+}
+
+model Post {
+  id       String @id @default(cuid())
+  title    String
+  author   User   @relation(fields: [authorId], references: [id])
+  authorId String
+}
+```
+
+## Queries
+```typescript
+// Create
+const user = await prisma.user.create({
+  data: { email: 'test@example.com' }
+});
+
+// Find with relations
+const users = await prisma.user.findMany({
+  include: { posts: true },
+  where: { email: { contains: '@example.com' } }
+});
+
+// Update
+await prisma.user.update({
+  where: { id },
+  data: { email: 'new@example.com' }
+});
+
+// Transaction
+await prisma.$transaction([
+  prisma.user.create({ data: userData }),
+  prisma.post.create({ data: postData })
+]);
+```
+
+## Best Practices
+- Use migrations
+- Use transactions
+- Include only needed relations
+- Use select for partial data

package/plugin/skills/databases/redis/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: redis
+description: Redis caching. Use for caching, sessions, pub/sub.
+---
+
+# Redis Skill
+
+## Patterns
+
+### Caching
+```javascript
+// Set with expiry
+await redis.set('user:123', JSON.stringify(user), 'EX', 3600);
+
+// Get
+const cached = await redis.get('user:123');
+if (cached) return JSON.parse(cached);
+```
+
+### Session
+```javascript
+await redis.hset(`session:${id}`, {
+  userId: user.id,
+  createdAt: Date.now()
+});
+await redis.expire(`session:${id}`, 86400);
+```
+
+### Rate Limiting
+```javascript
+const key = `rate:${ip}`;
+const count = await redis.incr(key);
+if (count === 1) await redis.expire(key, 60);
+if (count > 100) throw new Error('Rate limited');
+```
+
+## Best Practices
+- Set TTL on keys
+- Use pipelines for batch ops
+- Use appropriate data structures
+- Monitor memory usage

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

@@ -0,0 +1,51 @@
+---
+name: aws
+description: AWS services. Use for Lambda, S3, RDS, ECS, and other AWS services.
+---
+
+# AWS Skill
+
+## Common Services
+
+### Lambda
+```typescript
+export const handler = async (event: APIGatewayEvent) => {
+  const body = JSON.parse(event.body || '{}');
+
+  return {
+    statusCode: 200,
+    body: JSON.stringify({ message: 'Success' }),
+  };
+};
+```
+
+### S3
+```typescript
+import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
+
+const s3 = new S3Client({ region: 'us-east-1' });
+
+await s3.send(new PutObjectCommand({
+  Bucket: 'my-bucket',
+  Key: 'file.txt',
+  Body: 'content',
+}));
+```
+
+### DynamoDB
+```typescript
+import { DynamoDBClient, PutItemCommand } from '@aws-sdk/client-dynamodb';
+
+const client = new DynamoDBClient({});
+
+await client.send(new PutItemCommand({
+  TableName: 'users',
+  Item: { id: { S: '123' }, email: { S: 'test@example.com' } },
+}));
+```
+
+## Best Practices
+- Use IAM roles
+- Enable encryption
+- Use VPC for security
+- Monitor with CloudWatch