omgkit 2.1.1 → 2.3.0

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

@@ -1,34 +1,119 @@
 ---
 name: writing-plans
-description: Writing implementation plans. Use when planning features or tasks.
+description: AI agent creates structured implementation plans with task breakdown, dependency mapping, risk assessment, and file-level detail. Use when planning features, projects, or complex implementations.
 ---
 
-# Writing Plans Skill
+# Writing Plans
 
-## Plan Structure
-```markdown
+## Quick Start
+
+1. **Summarize** - Executive summary with goals, non-goals, background
+2. **Design** - High-level approach, architecture diagram, key decisions
+3. **Break Down** - Tasks in 2-4 hour chunks with file locations
+4. **Map Dependencies** - Identify critical path and parallel opportunities
+5. **Assess Risks** - Likelihood x Impact matrix with mitigations
+6. **Estimate** - Three-point estimation with buffers
+
+## Features
+
+| Feature | Description | Guide |
+|---------|-------------|-------|
+| Plan Structure | Comprehensive template | Summary, design, tasks, testing, risks |
+| Task Breakdown | Manageable work units | 2-4 hours, single owner, clear criteria |
+| Dependency Mapping | Sequence and parallelize | Critical path, hard/soft dependencies |
+| Risk Assessment | Anticipate problems | Likelihood x Impact matrix |
+| Effort Estimation | Realistic timing | Three-point: (O + 4M + P) / 6 |
+| File-Level Detail | Exact code locations | New files, modifications, line numbers |
+
+## Common Patterns
+
+```
+# Plan Structure
 # Plan: [Feature Name]
 
-## Overview
-[1-2 sentence description]
+## Metadata
+- Status: Draft | Approved | In Progress
+- Estimated Duration: [X days]
+- Priority: P0 | P1 | P2
+
+## Goals & Non-Goals
+Goals: [What this WILL accomplish]
+Non-Goals: [What this will NOT address]
 
-## Tasks
-1. [ ] [Task] - [2-5 min] - `path/file.ts:line`
-2. [ ] [Task] - [2-5 min] - `path/file.ts:line`
+## Design Overview
+[High-level approach, architecture diagram]
 
-## Files to Modify
-- `src/file.ts` - [What changes]
+## Implementation Tasks
 
-## Testing Strategy
-- Unit: [What to test]
-- Integration: [What flows]
+### Phase 1: [Foundation] - [X days]
+#### Task 1.1: [Name]
+- Description: [What]
+- Estimate: [X hours]
+- Files: `src/file.ts:45-60`
+- Dependencies: None
+- Acceptance Criteria:
+  - [ ] [Criterion 1]
+  - [ ] [Criterion 2]
 
-## Risks
+## Risks & Mitigations
 | Risk | Likelihood | Impact | Mitigation |
+|------|------------|--------|------------|
+| [Risk] | High | High | [Strategy] |
 ```
 
-## Guidelines
-- Each task: 2-5 minutes
-- Include exact file locations
-- Identify dependencies
-- Note testing requirements
+```
+# Dependency Diagram
+           [START]
+              |
+   +----------+----------+
+   |          |          |
+[Task 1]  [Task 2]  [Task 3]  <- Parallel
+   |          |          |
+   +-----+----+          |
+         |               |
+      [Task 4]      [Task 5]
+         |               |
+         +-------+-------+
+                 |
+            [Task 6]      <- Integration
+                 |
+            [COMPLETE]
+
+Critical Path: 1 -> 4 -> 6 (determines min duration)
+```
+
+```
+# Effort Estimation
+Three-Point: (Optimistic + 4*MostLikely + Pessimistic) / 6
+
+Example - OAuth Implementation:
+- Optimistic: 4 hours (works first try)
+- Most Likely: 8 hours (normal dev)
+- Pessimistic: 16 hours (issues)
+Estimate = (4 + 32 + 16) / 6 = 8.7 hours
+
+Buffers:
+- Individual tasks: 20%
+- Phase total: 30%
+- Project total: 40%
+```
+
+## Best Practices
+
+| Do | Avoid |
+|----|-------|
+| Keep tasks to 2-4 hour chunks | Vague tasks ("implement feature") |
+| Include exact file locations | Skipping background/context |
+| Specify clear acceptance criteria | Ignoring non-functional requirements |
+| Map dependencies explicitly | Underestimating integration work |
+| Build in buffer for unknowns | Planning more than 2 weeks in detail |
+| Include testing in the plan | Hiding risks or uncertainties |
+| Review plan with stakeholders | Assuming requirements are complete |
+| Update plan as you learn | Forgetting rollback plans |
+
+## Related Skills
+
+- `executing-plans` - Follow plans systematically
+- `thinking-sequentially` - Structure reasoning for plans
+- `brainstorming-ideas` - Generate options for plans
+- `verifying-before-completion` - Validate plan completion

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

@@ -1,59 +1,197 @@
 ---
-name: omega-architecture
-description: Omega system architecture. Use for designing scalable systems.
+name: architecting-omega-systems
+description: Designs scalable, resilient architectures using the 7 Omega principles. Use when building systems that need to scale to millions of users or designing platform-level infrastructure.
+category: omega
+triggers:
+  - omega architecture
+  - system design
+  - scalable architecture
+  - distributed systems
 ---
 
-# Omega Architecture Skill
+# Architecting Omega Systems
 
-## 7 Omega Principles Applied
+Build **scalable, resilient, and future-proof systems** following the 7 Omega Principles for platform-grade architecture.
 
-### Ω1. Leverage Multiplication
-- Build systems, not features
-- Automate everything
-- Create multipliers
+## Quick Start
 
-### Ω2. Transcendent Abstraction
-- Solve the class, not instance
-- Find patterns behind patterns
-- Build frameworks
+```yaml
+# 1. Define architectural requirements
+Architecture:
+  Name: "E-commerce Platform"
+  Scale: "1M+ concurrent users"
+  Principles: [leverage, abstraction, agentic, antifragile]
 
-### Ω3. Agentic Decomposition
-- Specialist components
-- Clear interfaces
-- Autonomous operation
+# 2. Apply Omega decision framework
+Decision:
+  Question: "Monolith or microservices?"
+  Omega_Check:
+    - Leverage: "Does this multiply capability?"
+    - Scale: "Zero-marginal-cost at 1000x?"
+    - Resilience: "Self-healing under stress?"
 
-### Ω5. Zero-Marginal-Cost Scaling
-- No per-unit cost
-- Horizontal scaling
-- Platform thinking
+# 3. Design with antifragility
+Pattern: Event-Driven + Circuit Breakers + Auto-Scaling
+```
+
+## Features
+
+| Feature | Description | Guide |
+|---------|-------------|-------|
+| 7 Omega Principles | Core architectural tenets for scalable systems | Apply all 7 to every decision |
+| Leverage Architecture | Systems that amplify effort, not add to it | Build frameworks, not features |
+| Agentic Services | Autonomous, self-healing microservices | Circuit breakers + health monitors |
+| Zero-Marginal-Cost | Platform economics at scale | Edge compute + aggressive caching |
+| Event-Driven Design | Loose coupling via event bus | Kafka/Redis streams + sagas |
+| Antifragile Patterns | Systems that strengthen under stress | Chaos engineering + adaptive config |
+| Decision Framework | Systematic architecture evaluation | Omega checklist for every choice |
 
-## Architecture Patterns
+## Common Patterns
 
-### Event-Driven
+### The 7 Omega Principles
+
+```
+1. LEVERAGE MULTIPLICATION   - Build systems that amplify effort
+2. TRANSCENDENT ABSTRACTION  - Solve classes of problems
+3. AGENTIC DECOMPOSITION     - Autonomous, self-managing services
+4. RECURSIVE IMPROVEMENT     - Systems that optimize themselves
+5. ZERO-MARGINAL-COST        - No cost per user at scale
+6. ANTIFRAGILE DESIGN        - Grow stronger under stress
+7. COMPOSABLE PRIMITIVES     - Lego blocks that combine infinitely
 ```
-[Producer] → [Event Bus] → [Consumer]
-                       → [Consumer]
-                       → [Consumer]
+
+### Leverage Architecture Pattern
+
+```typescript
+// ONE implementation handles ALL entity types
+class LeveragedEntitySystem {
+  async create<T>(type: string, data: T): Promise<T> {
+    const validated = await this.validators.get(type)?.validate(data);
+    await this.runHooks(type, 'beforeCreate', validated);
+    const result = await this.storage.create(type, validated);
+    await this.runHooks(type, 'afterCreate', result);
+    return result as T;
+  }
+
+  // New entity = configuration, not code
+  registerEntityType(type: string, config: EntityConfig): void {
+    this.validators.set(type, createValidator(config.schema));
+  }
+}
 ```
 
-### Microservices
+### Agentic Service Pattern
+
+```typescript
+abstract class AgenticService {
+  private circuitBreaker: CircuitBreaker;
+  private healthMonitor: HealthMonitor;
+  private autoScaler: AutoScaler;
+
+  constructor() {
+    // Self-monitoring
+    this.healthMonitor = new HealthMonitor({
+      onUnhealthy: () => this.selfHeal()
+    });
+
+    // Self-protecting
+    this.circuitBreaker = new CircuitBreaker({
+      failureThreshold: 5,
+      onOpen: () => this.notifyDegradation()
+    });
+  }
+
+  protected async executeWithResilience<T>(
+    operation: () => Promise<T>,
+    fallback?: () => T
+  ): Promise<T> {
+    return this.circuitBreaker.execute(operation, fallback);
+  }
+}
 ```
-[API Gateway]
-     │
-┌────┼────┐
-▼    ▼    ▼
-[A] [B]  [C]
+
+### Zero-Marginal-Cost Pattern
+
+```typescript
+// Edge-first architecture
+const platformConfig = {
+  compute: { provider: 'cloudflare-workers', pricing: 'per-invocation' },
+  storage: { provider: 'r2', cdn: { enabled: true, ttl: '1y' } },
+  database: { provider: 'planetscale', sharding: 'automatic' },
+  cache: {
+    layers: [
+      { type: 'browser', ttl: '1h' },
+      { type: 'cdn-edge', ttl: '24h' },
+      { type: 'origin', ttl: '5m' }
+    ]
+  }
+};
 ```
 
-### Serverless
+### Event-Driven Saga Pattern
+
+```typescript
+class OrderSaga {
+  constructor(eventBus: EventBus) {
+    eventBus.subscribe('order.created', this.handleOrderCreated);
+    eventBus.subscribe('payment.failed', this.handlePaymentFailed);
+  }
+
+  handleOrderCreated = async (event: DomainEvent<Order>) => {
+    await this.eventBus.publish({
+      type: 'inventory.reserve',
+      data: { orderId: event.data.id, items: event.data.items },
+      correlationId: event.correlationId
+    });
+  };
+
+  handlePaymentFailed = async (event: DomainEvent) => {
+    // Compensating action
+    await this.eventBus.publish({ type: 'inventory.release', ... });
+    await this.eventBus.publish({ type: 'order.cancelled', ... });
+  };
+}
 ```
-[Request] → [Function] → [Database]
-                      → [Queue]
-                      → [Storage]
+
+### Architecture Decision Template
+
+```markdown
+## Omega Architecture Decision
+
+### Context
+[Problem and constraints]
+
+### Omega Principles Check
+| Principle | Question | Assessment |
+|-----------|----------|------------|
+| Leverage | Does this multiply capability? | |
+| Abstraction | Solving class of problems? | |
+| Agentic | Can it operate autonomously? | |
+| Recursive | Will it self-improve? | |
+| Zero-Marginal | Sub-linear cost scaling? | |
+| Antifragile | Stronger under stress? | |
+| Composable | Combines with other components? | |
+
+### Scale Analysis
+- 10x load: [Impact]
+- 100x load: [Impact]
+- 1000x load: [Impact]
+
+### Decision
+[Chosen approach with rationale]
 ```
 
-## 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?
+## Best Practices
+
+| Do | Avoid |
+|----|-------|
+| Apply all 7 Omega principles to every decision | Building monoliths that cannot decompose |
+| Design for 1000x scale from day one | Tight coupling between services |
+| Use event-driven patterns for loose coupling | Ignoring failure modes in design |
+| Implement circuit breakers at all boundaries | Scaling vertically when horizontal is possible |
+| Build self-healing capabilities into services | Hardcoding configuration values |
+| Measure and optimize cost per transaction | Skipping capacity planning |
+| Document decisions using ADR template | Deploying without health checks |
+| Test failure scenarios with chaos engineering | Synchronous calls for non-critical paths |
+| Use infrastructure as code | Ignoring data consistency requirements |
+| Implement observability everywhere | Underestimating distributed system complexity |

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

@@ -1,61 +1,267 @@
 ---
-name: omega-coding
-description: AI-first development patterns. Use for leveraging AI in development.
+name: coding-with-omega-leverage
+description: Applies AI-first development patterns for 10-100x productivity through specification-driven generation and leverage multiplication. Use when developing features with AI assistance or optimizing development workflows.
+category: omega
+triggers:
+  - omega coding
+  - ai-first development
+  - ai assisted coding
+  - prompt driven
+  - leverage multiplication
 ---
 
-# Omega Coding Skill
+# Coding with Omega Leverage
 
-## Principles
+Master **AI-first development** patterns that multiply productivity 10-100x through specification-driven generation and systematic AI collaboration.
 
-### 1. AI-First Design
-Design for AI assistance:
-- Clear interfaces
-- Self-documenting code
-- Predictable patterns
+## Quick Start
+
+```yaml
+# 1. Write specification first
+Spec:
+  Component: "UserAuthService"
+  Requirements: ["register", "login", "logout", "password-reset"]
+  Interface: { input: "email, password", output: "Result<User, AuthError>" }
+
+# 2. Generate with iterative refinement
+Workflow:
+  - Generate: "Implement UserAuthService from spec"
+  - Test: "Run tests, check coverage"
+  - Refine: "Fix issues, add edge cases"
+  - Verify: "All tests pass, 80%+ coverage"
+
+# 3. Apply leverage multiplication
+Leverage:
+  Manual: "4 hours/feature"
+  AI-Assisted: "15 minutes/feature"
+  Multiplier: "16x"
+```
+
+## Features
+
+| Feature | Description | Guide |
+|---------|-------------|-------|
+| 7 Omega Principles | Core development philosophy | Apply to every coding decision |
+| Specification-Driven | Requirements before code | YAML/TypeScript specs |
+| Prompt Engineering | Effective AI prompts for code | Templates for generation |
+| Iterative Refinement | Generate, test, improve loop | Max 5 iterations to pass |
+| Leverage Tactics | 10x productivity techniques | Batch, template, transform |
+| Quality Patterns | Self-documenting, testable code | Types, pure functions, DI |
+| Transform, Not Recreate | Modify existing code with AI | Refactor at scale |
+
+## Common Patterns
+
+### The 7 Omega Principles in Code
 
-### 2. Prompt-Driven Development
-```markdown
-1. Write clear requirements
-2. Let AI generate first draft
-3. Review and refine
-4. Iterate with feedback
 ```
+1. LEVERAGE          - 1 developer + AI = 10-50 features/day
+2. ABSTRACTION       - Solve classes of problems, not instances
+3. AGENTIC           - Autonomous, specialist agent teams
+4. AUTONOMOUS        - Self-correcting, self-healing code
+5. ZERO-MARGINAL     - Build once, use infinitely
+6. RECURSIVE         - Code that improves itself
+7. EMERGENT          - Compose simple parts into powerful wholes
+```
+
+### Specification Template
+
+```yaml
+component:
+  name: UserAuthService
+  description: Authentication and session management
 
-### 3. Leverage Multiplication (Ω1)
+requirements:
+  functional:
+    - FR1: Register with email/password
+    - FR2: Login with credentials
+    - FR3: Logout and invalidate session
+  non_functional:
+    - NFR1: Response < 200ms
+    - NFR2: PCI-DSS compliant
+
+interface:
+  methods:
+    - name: register
+      input: { email: "string", password: "string (min 8 chars)" }
+      output: { success: boolean, userId?: string, error?: Error }
+    - name: login
+      input: { email: "string", password: "string" }
+      output: { success: boolean, token?: "JWT 24h", error?: Error }
+
+testing:
+  unit: [password validation, token generation]
+  integration: [registration flow, login flow]
+  edge_cases: [duplicate email, invalid credentials]
 ```
-Manual:    1 task = 1 hour
-AI-Assisted: 1 task = 5 minutes
-Leverage:  12x improvement
+
+### Iterative Refinement Loop
+
+```typescript
+async function omegaDevelopment(spec: Specification): Promise<Code> {
+  let code = await generateFromSpec(spec);
+  let iteration = 0;
+
+  while (iteration < 5) {
+    const results = await runTests(code);
+
+    if (results.allPassing && results.coverage >= 80) {
+      return code; // Done!
+    }
+
+    const issues = analyzeResults(results);
+    code = await refineCode(code, issues);
+    iteration++;
+  }
+
+  throw new Error('Max iterations reached');
+}
+
+// Iteration log example:
+// 1: 8/12 tests pass -> Fix null checks, date handling
+// 2: 11/12 tests pass -> Add empty input validation
+// 3: 12/12 tests, 85% coverage -> Complete!
 ```
 
-## Patterns
+### Prompt Templates
 
-### Specification First
 ```markdown
-## Spec: UserService
+## Component Generation
+Create a [TYPE] component named [NAME] with:
+
+Requirements:
+- [Req 1]
+- [Req 2]
+
+Interface:
+[Define inputs, outputs, methods]
+
+Constraints:
+- Language: TypeScript
+- Error handling: Return Result types
+- Include unit tests
 
-### Methods
-- createUser(email, password) → User
-- getUser(id) → User | null
+## Refactoring Request
+Refactor this code to:
+1. [Improvement 1]
+2. [Improvement 2]
 
-### Constraints
-- Email must be unique
-- Password hashed with bcrypt
+Current code: [paste]
 
-### Tests
-- Creates user successfully
-- Rejects duplicate email
+Preserve: functionality, API, types
+
+## Bug Fix Request
+Fix the bug in this code:
+
+Code: [paste]
+Bug: [description]
+Expected: [behavior]
+Actual: [behavior]
+
+Provide: root cause, fixed code, regression test
+```
+
+### Leverage Multiplication Tactics
+
+```typescript
+// Tactic 1: Generate, Don't Write
+// Schema -> API -> Controllers -> Services -> Tests
+// All generated, all consistent, all in minutes
+
+// Tactic 2: Transform, Don't Recreate
+// "Convert JavaScript to TypeScript with types"
+// "Add error handling to all async functions"
+
+// Tactic 3: Batch Operations
+// "Add JSDoc to all exports in src/utils/"
+// "Update all class components to functional"
+
+// Tactic 4: Template Once, Generate Many
+const template = {
+  components: ['route', 'validation', 'service', 'repository', 'tests']
+};
+const resources = ['users', 'products', 'orders'];
+// Result: 3 resources x 5 components = 15 files generated
+
+// Tactic 5: Test-First Specification
+describe('ShoppingCart', () => {
+  it('calculates total', () => {
+    const cart = new ShoppingCart();
+    cart.addItem({ price: 10, quantity: 2 });
+    expect(cart.total).toBe(20);
+  });
+});
+// Then: "Implement ShoppingCart to pass these tests"
 ```
 
-### Iterative Refinement
-1. Generate initial code
-2. Add tests
-3. Fix edge cases
-4. Optimize
-5. Document
+### Quality Code Patterns
+
+```typescript
+// 1. Self-documenting with branded types
+interface User {
+  id: UserId;           // Branded type
+  email: Email;         // Validated type
+  status: UserStatus;   // Union type
+}
+
+// 2. Pure functions where possible
+const calculateTotal = (items: LineItem[]): Money =>
+  items.reduce((sum, item) => sum.add(item.price.multiply(item.quantity)), Money.zero());
+
+// 3. Explicit error handling with Result types
+type Result<T, E = Error> = { success: true; value: T } | { success: false; error: E };
+
+async function findUser(id: UserId): Promise<Result<User, NotFoundError>> {
+  const user = await db.users.find(id);
+  if (!user) return { success: false, error: new NotFoundError('User', id) };
+  return { success: true, value: user };
+}
+
+// 4. Composable pipelines
+const processDocument = pipe(parseMarkdown, extractEntities, enrichWithContext, generateSummary);
+
+// 5. Dependency injection for testability
+class OrderService {
+  constructor(
+    private readonly repo: OrderRepository,
+    private readonly payment: PaymentGateway
+  ) {}
+}
+```
+
+### Abstraction Levels
+
+```typescript
+// Level 1: Solve one problem (avoid)
+function validateEmail(email: string): boolean {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+}
+
+// Level 2: Solve the class of problems (prefer)
+function createValidator<T>(rules: ValidationRule<T>[]): Validator<T> {
+  return (value: T) => {
+    const errors = rules.filter(r => !r.validate(value)).map(r => r.message);
+    return { valid: errors.length === 0, errors };
+  };
+}
+
+// Now email validation is just one instance:
+const validateEmail = createValidator([
+  { validate: v => v.includes('@'), message: 'Must contain @' },
+  { validate: v => v.length <= 254, message: 'Too long' }
+]);
+```
 
 ## Best Practices
-- Clear specifications
-- Incremental generation
-- Verification at each step
-- Learn from AI suggestions
+
+| Do | Avoid |
+|----|-------|
+| Write specifications before generating | Generating without clear requirements |
+| Use iterative refinement (generate, test, improve) | Trusting generated code without verification |
+| Leverage AI for repetitive tasks | Skipping tests for AI-generated code |
+| Verify generated code meets requirements | Using AI for security-critical code without review |
+| Maintain human oversight for critical logic | Losing the spec-code relationship |
+| Build reusable templates and patterns | Over-relying on AI for creative design |
+| Document prompts that work well | Using outdated AI models for complex tasks |
+| Combine AI strengths with human judgment | Forgetting to understand generated code |
+| Start simple, add complexity | Ignoring AI suggestions for improvement |
+| Keep specifications updated | Skipping code review for AI-generated code |