omgkit 1.0.0

package/plugin/skills/methodology/defense-in-depth/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: defense-in-depth
+description: Security defense in depth. Use when designing secure systems.
+---
+
+# Defense in Depth Skill
+
+## Layers
+
+### 1. Perimeter
+- Firewall
+- Rate limiting
+- WAF
+
+### 2. Network
+- VPC
+- Security groups
+- TLS everywhere
+
+### 3. Application
+- Input validation
+- Output encoding
+- CSRF protection
+
+### 4. Data
+- Encryption at rest
+- Encryption in transit
+- Access control
+
+### 5. Monitoring
+- Logging
+- Alerting
+- Audit trails
+
+## Principle
+> If one layer fails, others protect.
+
+## Implementation
+```typescript
+// Layer 1: Rate limiting
+app.use(rateLimit({ max: 100 }));
+
+// Layer 2: Input validation
+const validated = schema.parse(input);
+
+// Layer 3: Parameterized query
+db.query('SELECT * FROM users WHERE id = $1', [id]);
+
+// Layer 4: Output encoding
+res.json(sanitize(data));
+```

package/plugin/skills/methodology/dispatching-parallel-agents/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: dispatching-parallel-agents
+description: Parallel agent execution. Use when tasks can run concurrently.
+---
+
+# Dispatching Parallel Agents Skill
+
+## When to Parallelize
+- Independent tasks
+- No shared state
+- Different file scopes
+- Research + implementation
+
+## Pattern
+```
+┌─────────────────────────────────────┐
+│           Main Agent                │
+└──────────────┬──────────────────────┘
+               │
+    ┌──────────┼──────────┐
+    ▼          ▼          ▼
+┌───────┐ ┌───────┐ ┌───────┐
+│Agent A│ │Agent B│ │Agent C│
+│(task1)│ │(task2)│ │(task3)│
+└───────┘ └───────┘ └───────┘
+    │          │          │
+    └──────────┼──────────┘
+               ▼
+       [Aggregate Results]
+```
+
+## Commands
+```bash
+/spawn "Research authentication options"
+/spawn "Write tests for user module"
+/spawn:collect
+```
+
+## Best Practices
+- Clear task boundaries
+- Define sync points
+- Aggregate results
+- Handle failures

package/plugin/skills/methodology/executing-plans/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: executing-plans
+description: Executing implementation plans. Use when implementing from a plan.
+---
+
+# Executing Plans Skill
+
+## Process
+1. Read the plan completely
+2. Verify understanding
+3. Execute tasks in order
+4. Check off completed tasks
+5. Report blockers immediately
+
+## Per Task
+1. Read task description
+2. Navigate to code location
+3. Implement change
+4. Verify it works
+5. Mark complete
+6. Proceed to next
+
+## Quality Gates
+- After each task: Does it work?
+- After each phase: Run tests
+- After completion: Full verification
+
+## Reporting
+```markdown
+## Progress Update
+- Completed: 5/10 tasks
+- Current: Task 6 - [description]
+- Blockers: [None | Description]
+```

package/plugin/skills/methodology/finishing-development-branch/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: finishing-development-branch
+description: Completing a development branch. Use when wrapping up feature work.
+---
+
+# Finishing Development Branch Skill
+
+## Checklist
+
+### Code Complete
+- [ ] All tasks done
+- [ ] Tests written
+- [ ] Docs updated
+- [ ] No TODOs left
+
+### Quality
+- [ ] Tests passing
+- [ ] Lint passing
+- [ ] Type check passing
+- [ ] Self-reviewed
+
+### Git
+- [ ] Clean commit history
+- [ ] Meaningful messages
+- [ ] Rebased on main
+- [ ] No merge conflicts
+
+### PR
+- [ ] Description complete
+- [ ] Reviewers assigned
+- [ ] Labels added
+
+## Final Steps
+```bash
+git fetch origin main
+git rebase origin/main
+npm test
+npm run build
+git push origin feature-branch
+gh pr create
+```

package/plugin/skills/methodology/receiving-code-review/SKILL.md

@@ -0,0 +1,41 @@
+---
+name: receiving-code-review
+description: Receiving code review feedback. Use when handling review comments.
+---
+
+# Receiving Code Review Skill
+
+## Mindset
+- Feedback is about code, not you
+- Reviewers want to help
+- Every comment is an opportunity
+
+## Response Types
+
+### Agree
+```
+Good catch! Fixed in abc123.
+```
+
+### Discuss
+```
+I considered that, but chose X because [reason].
+What do you think about [alternative]?
+```
+
+### Clarify
+```
+Could you elaborate on [specific point]?
+I want to make sure I understand.
+```
+
+## Process
+1. Read all comments first
+2. Address each comment
+3. Mark resolved when fixed
+4. Re-request review
+
+## Anti-Patterns
+- Defensive reactions
+- Ignoring comments
+- Changing without acknowledgment

package/plugin/skills/methodology/requesting-code-review/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: requesting-code-review
+description: Requesting code reviews. Use when submitting code for review.
+---
+
+# Requesting Code Review Skill
+
+## Before Requesting
+- [ ] Tests pass
+- [ ] Self-reviewed
+- [ ] No debug code
+- [ ] Docs updated
+
+## PR Description
+```markdown
+## Summary
+[What changed and why]
+
+## Changes
+- [Specific change 1]
+- [Specific change 2]
+
+## Testing
+- [ ] Unit tests added
+- [ ] Manual testing done
+
+## Screenshots
+[If UI changes]
+
+## Questions
+[Specific areas needing review]
+```
+
+## Best Practices
+- Keep PRs small (<400 lines)
+- One concern per PR
+- Descriptive commit messages
+- Respond to feedback promptly

package/plugin/skills/methodology/root-cause-tracing/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: root-cause-tracing
+description: Finding root causes. Use when debugging complex issues.
+---
+
+# Root Cause Tracing Skill
+
+## 5 Whys
+```
+Problem: App crashed
+Why? → Out of memory
+Why? → Memory leak
+Why? → Event listeners not cleaned
+Why? → Missing cleanup in useEffect
+Why? → Developer unaware of cleanup pattern
+Root: Training/documentation gap
+```
+
+## Fishbone Diagram
+```
+                    ┌─ Code
+                    ├─ Config
+Problem ────────────├─ Environment
+                    ├─ Data
+                    └─ Dependencies
+```
+
+## Categories
+1. **Code** - Bug in logic
+2. **Data** - Invalid input
+3. **Config** - Wrong settings
+4. **Environment** - System issues
+5. **External** - Third-party failure
+
+## Output
+```markdown
+## Root Cause Analysis
+
+### Symptom
+[What was observed]
+
+### Proximate Cause
+[Immediate cause]
+
+### Root Cause
+[Underlying reason]
+
+### Systemic Factors
+[Why it wasn't caught]
+
+### Prevention
+[How to prevent recurrence]
+```

package/plugin/skills/methodology/systematic-debugging/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: systematic-debugging
+description: Systematic debugging process. Use when investigating bugs.
+---
+
+# Systematic Debugging Skill
+
+## Process
+
+### 1. Reproduce
+- Can you reproduce consistently?
+- What are the exact steps?
+- What environment?
+
+### 2. Isolate
+- What's the smallest case?
+- Which component fails?
+- When did it start?
+
+### 3. Hypothesize
+Form 3 hypotheses:
+1. [Most likely cause]
+2. [Second possibility]
+3. [Unlikely but possible]
+
+### 4. Test
+- Test each hypothesis
+- Use binary search for large codebases
+- Add logging strategically
+
+### 5. Fix
+- Minimal fix first
+- Add regression test
+- Verify fix works
+
+## Tools
+```bash
+git bisect start
+git bisect bad HEAD
+git bisect good v1.0.0
+```
+
+## Output
+```markdown
+## Debug Report
+- Problem: [Description]
+- Root Cause: [Actual cause]
+- Fix: [What changed]
+- Prevention: [How to prevent]
+```

package/plugin/skills/methodology/test-driven-development/SKILL.md

@@ -0,0 +1,39 @@
+---
+name: test-driven-development
+description: TDD workflow. Use when implementing features with test-first approach.
+---
+
+# Test-Driven Development Skill
+
+## TDD Cycle
+1. 🔴 **RED** - Write failing test
+2. 🟢 **GREEN** - Make it pass (minimal code)
+3. ♻️ **REFACTOR** - Improve code
+
+## Rules
+- No production code without failing test
+- Only enough code to pass test
+- Refactor only when green
+- One assertion per test
+
+## Example
+```typescript
+// 1. RED - Write test first
+describe('calculateTax', () => {
+  it('calculates 10% tax', () => {
+    expect(calculateTax(100, 0.1)).toBe(10);
+  });
+});
+
+// 2. GREEN - Minimal implementation
+function calculateTax(amount: number, rate: number) {
+  return amount * rate;
+}
+
+// 3. REFACTOR if needed
+```
+
+## Benefits
+- Design emerges from tests
+- 100% coverage by default
+- Confidence in refactoring

package/plugin/skills/methodology/testing-anti-patterns/SKILL.md

@@ -0,0 +1,50 @@
+---
+name: testing-anti-patterns
+description: Testing anti-patterns to avoid. Use when writing or reviewing tests.
+---
+
+# Testing Anti-Patterns Skill
+
+## Anti-Patterns
+
+### 1. Testing Implementation
+```typescript
+// Bad - tests internal implementation
+expect(component.state.count).toBe(1);
+
+// Good - tests behavior
+expect(screen.getByText('1')).toBeInTheDocument();
+```
+
+### 2. Flaky Tests
+```typescript
+// Bad - timing dependent
+await sleep(1000);
+expect(result).toBe(true);
+
+// Good - wait for condition
+await waitFor(() => expect(result).toBe(true));
+```
+
+### 3. Test Interdependence
+```typescript
+// Bad - tests share state
+let user;
+it('creates user', () => { user = create(); });
+it('uses user', () => { expect(user).toBe(...); });
+
+// Good - independent tests
+beforeEach(() => { user = create(); });
+```
+
+### 4. Overmocking
+```typescript
+// Bad - mock everything
+// Good - use real implementations when practical
+```
+
+## Guidelines
+- Test behavior, not implementation
+- Keep tests independent
+- Mock only external dependencies
+- Use realistic test data

package/plugin/skills/methodology/token-optimization/SKILL.md

@@ -0,0 +1,51 @@
+---
+name: token-optimization
+description: Token/cost optimization. Use for efficient AI interactions.
+---
+
+# Token Optimization Skill
+
+## Strategies
+
+### 1. Concise Prompts
+```
+# Bad
+Can you please help me understand what this function does
+and explain it in detail with examples?
+
+# Good
+Explain this function briefly.
+```
+
+### 2. Targeted Reading
+```
+# Bad
+Read("entire-large-file.ts")
+
+# Good
+Read("file.ts", { offset: 50, limit: 30 })
+```
+
+### 3. Efficient Searches
+```
+# Bad
+Grep(".*") in all files
+
+# Good
+Grep("specificPattern", { path: "src/", glob: "*.ts" })
+```
+
+### 4. Batch Operations
+```
+# Bad
+Multiple separate tool calls
+
+# Good
+Combined operations in one call
+```
+
+## Savings
+- 30-70% reduction possible
+- Focus on high-value output
+- Minimize unnecessary context
+- Use token-efficient mode

package/plugin/skills/methodology/verification-before-completion/SKILL.md

@@ -0,0 +1,32 @@
+---
+name: verification-before-completion
+description: Evidence-based verification. Use before marking tasks complete.
+---
+
+# Verification Before Completion Skill
+
+## Checklist
+Before marking complete:
+
+- [ ] **Tests pass** - All tests green
+- [ ] **Manual test** - Verified manually
+- [ ] **Edge cases** - Considered and handled
+- [ ] **Errors** - Error handling works
+- [ ] **Types** - No type errors
+- [ ] **Lint** - No lint errors
+
+## Verification Steps
+1. Run full test suite
+2. Test happy path manually
+3. Test error cases
+4. Check type safety
+5. Verify in production-like env
+
+## Evidence
+Document verification:
+```markdown
+## Verification
+- Tests: ✅ 45 passed
+- Manual: ✅ Tested [scenario]
+- Edge cases: ✅ Handled [case]
+```

package/plugin/skills/methodology/writing-plans/SKILL.md

@@ -0,0 +1,34 @@
+---
+name: writing-plans
+description: Writing implementation plans. Use when planning features or tasks.
+---
+
+# Writing Plans Skill
+
+## Plan Structure
+```markdown
+# Plan: [Feature Name]
+
+## Overview
+[1-2 sentence description]
+
+## Tasks
+1. [ ] [Task] - [2-5 min] - `path/file.ts:line`
+2. [ ] [Task] - [2-5 min] - `path/file.ts:line`
+
+## Files to Modify
+- `src/file.ts` - [What changes]
+
+## Testing Strategy
+- Unit: [What to test]
+- Integration: [What flows]
+
+## Risks
+| Risk | Likelihood | Impact | Mitigation |
+```
+
+## Guidelines
+- Each task: 2-5 minutes
+- Include exact file locations
+- Identify dependencies
+- Note testing requirements

package/plugin/skills/omega/omega-architecture/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: omega-architecture
+description: Omega system architecture. Use for designing scalable systems.
+---
+
+# Omega Architecture Skill
+
+## 7 Omega Principles Applied
+
+### Ω1. Leverage Multiplication
+- Build systems, not features
+- Automate everything
+- Create multipliers
+
+### Ω2. Transcendent Abstraction
+- Solve the class, not instance
+- Find patterns behind patterns
+- Build frameworks
+
+### Ω3. Agentic Decomposition
+- Specialist components
+- Clear interfaces
+- Autonomous operation
+
+### Ω5. Zero-Marginal-Cost Scaling
+- No per-unit cost
+- Horizontal scaling
+- Platform thinking
+
+## Architecture Patterns
+
+### Event-Driven
+```
+[Producer] → [Event Bus] → [Consumer]
+                       → [Consumer]
+                       → [Consumer]
+```
+
+### Microservices
+```
+[API Gateway]
+     │
+┌────┼────┐
+▼    ▼    ▼
+[A] [B]  [C]
+```
+
+### Serverless
+```
+[Request] → [Function] → [Database]
+                      → [Queue]
+                      → [Storage]
+```
+
+## Design Questions
+1. How does this scale to 1000x?
+2. What's the single point of failure?
+3. How do we deploy without downtime?
+4. What's the cost at scale?

package/plugin/skills/omega/omega-coding/SKILL.md

@@ -0,0 +1,61 @@
+---
+name: omega-coding
+description: AI-first development patterns. Use for leveraging AI in development.
+---
+
+# Omega Coding Skill
+
+## Principles
+
+### 1. AI-First Design
+Design for AI assistance:
+- Clear interfaces
+- Self-documenting code
+- Predictable patterns
+
+### 2. Prompt-Driven Development
+```markdown
+1. Write clear requirements
+2. Let AI generate first draft
+3. Review and refine
+4. Iterate with feedback
+```
+
+### 3. Leverage Multiplication (Ω1)
+```
+Manual:    1 task = 1 hour
+AI-Assisted: 1 task = 5 minutes
+Leverage:  12x improvement
+```
+
+## Patterns
+
+### Specification First
+```markdown
+## Spec: UserService
+
+### Methods
+- createUser(email, password) → User
+- getUser(id) → User | null
+
+### Constraints
+- Email must be unique
+- Password hashed with bcrypt
+
+### Tests
+- Creates user successfully
+- Rejects duplicate email
+```
+
+### Iterative Refinement
+1. Generate initial code
+2. Add tests
+3. Fix edge cases
+4. Optimize
+5. Document
+
+## Best Practices
+- Clear specifications
+- Incremental generation
+- Verification at each step
+- Learn from AI suggestions