omgkit 2.2.0 → 2.3.1

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

@@ -1,6 +1,6 @@
 ---
-name: omega-coding
-description: AI-first development patterns with prompt engineering, specification-driven generation, and leverage multiplication
+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
@@ -8,651 +8,260 @@ triggers:
   - ai assisted coding
   - prompt driven
   - leverage multiplication
-  - ai development
 ---
 
-# Omega Coding
+# Coding with Omega Leverage
 
-Master **AI-first development** patterns that multiply your productivity 10-100x. This skill teaches specification-driven code generation, strategic prompt engineering, and systematic leverage of AI capabilities.
+Master **AI-first development** patterns that multiply productivity 10-100x through specification-driven generation and systematic AI collaboration.
 
-## Purpose
-
-Transform development velocity through AI-human collaboration:
-
-- Design specifications that generate perfect code
-- Leverage AI for 10-100x productivity gains
-- Build iterative refinement workflows
-- Maintain quality through systematic verification
-- Scale individual capabilities exponentially
-- Apply the Omega principles to development
-
-## Features
-
-### 1. The Omega Principles in Code
-
-```markdown
-## The 7 Omega Principles Applied to Development
-
-### Ω1: Leverage Multiplication
-```
-Traditional:  1 developer = 1 feature/day
-Omega:        1 developer + AI = 10-50 features/day
-
-Leverage calculation:
-- Manual coding: 4 hours/feature
-- AI-assisted: 15 minutes/feature
-- Leverage multiplier: 16x
-```
-
-**Application:**
-- Use AI for repetitive code generation
-- Automate boilerplate creation
-- Generate tests from implementations
-- Create documentation automatically
-
-### Ω2: Transcendent Abstraction
-Instead of solving one problem, solve the class of problems.
-
-```typescript
-// Level 1: Solve one problem
-function validateEmail(email: string): boolean {
-  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
-}
-
-// Level 2: Solve the class (Omega approach)
-function createValidator<T>(
-  rules: ValidationRule<T>[]
-): (value: T) => ValidationResult {
-  return (value: T) => {
-    const errors = rules
-      .filter(rule => !rule.validate(value))
-      .map(rule => rule.message);
-    return { valid: errors.length === 0, errors };
-  };
-}
-
-// Now email validation is just one instance:
-const validateEmail = createValidator([
-  { validate: v => typeof v === 'string', message: 'Must be string' },
-  { validate: v => v.includes('@'), message: 'Must contain @' },
-  { validate: v => v.length <= 254, message: 'Too long' },
-]);
-```
-
-### Ω3: Agentic Decomposition
-Break work into autonomous, specialist agents.
+## Quick Start
 
 ```yaml
-# Omega development workflow
-agents:
-  architect:
-    role: Design system structure
-    output: Architecture document
-
-  implementer:
-    role: Write production code
-    input: Architecture + specs
-    output: Implementation
-
-  tester:
-    role: Write and run tests
-    input: Implementation
-    output: Test results + coverage
-
-  reviewer:
-    role: Code review and quality
-    input: Implementation + tests
-    output: Review comments
-
-  documenter:
-    role: Generate documentation
-    input: Implementation
-    output: API docs + guides
-```
-
-### Ω4: Autonomous Operation
-Systems should self-correct and self-improve.
-
-```typescript
-// Self-healing code pattern
-async function withRetryAndFallback<T>(
-  primary: () => Promise<T>,
-  fallback: () => Promise<T>,
-  options: { maxRetries: number; backoff: number }
-): Promise<T> {
-  for (let i = 0; i < options.maxRetries; i++) {
-    try {
-      return await primary();
-    } catch (error) {
-      await delay(options.backoff * Math.pow(2, i));
-    }
-  }
-  return fallback();
-}
-```
-
-### Ω5: Zero-Marginal-Cost Scaling
-Once built, serving N+1 costs nothing extra.
-
-```typescript
-// Build reusable, scalable components
-const ComponentLibrary = {
-  Button: createReusableComponent('Button'),
-  Input: createReusableComponent('Input'),
-  Modal: createReusableComponent('Modal'),
-  // Each component: built once, used infinite times
-};
+# 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"
 ```
 
-### Ω6: Recursive Self-Improvement
-Code that improves itself.
+## Features
 
-```typescript
-// Self-optimizing query builder
-class QueryOptimizer {
-  private performanceHistory: QueryPerformance[] = [];
-
-  async executeQuery(query: string): Promise<Result> {
-    const startTime = Date.now();
-    const result = await this.db.query(query);
-    const duration = Date.now() - startTime;
-
-    // Learn from execution
-    this.performanceHistory.push({ query, duration });
-
-    // Suggest optimizations
-    if (duration > 100) {
-      const suggestions = this.analyzeAndSuggest(query);
-      console.log('Optimization suggestions:', suggestions);
-    }
+| 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 |
 
-    return result;
-  }
-}
-```
+## Common Patterns
 
-### Ω7: Emergent Capabilities
-Combined systems exceed sum of parts.
+### The 7 Omega Principles in Code
 
-```typescript
-// Compose simple functions into powerful pipelines
-const processDocument = pipe(
-  parseMarkdown,      // Simple parsing
-  extractEntities,    // Simple extraction
-  enrichWithContext,  // Simple enrichment
-  generateSummary,    // Simple summary
-  // Together: powerful document understanding
-);
 ```
+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
 ```
 
-### 2. Specification-Driven Development
+### Specification Template
 
-```markdown
-## The Perfect Specification Format
-
-### Component Specification Template
 ```yaml
 component:
   name: UserAuthService
-  description: Handles user authentication and session management
-  version: 1.0.0
+  description: Authentication and session management
 
 requirements:
   functional:
-    - FR1: Users can register with email and password
-    - FR2: Users can login with credentials
-    - FR3: Users can logout and invalidate session
-    - FR4: Sessions expire after 24 hours
-    - FR5: Support password reset via email
-
+    - FR1: Register with email/password
+    - FR2: Login with credentials
+    - FR3: Logout and invalidate session
   non_functional:
-    - NFR1: Response time < 200ms
-    - NFR2: Support 10,000 concurrent users
-    - NFR3: 99.9% uptime
-    - NFR4: PCI-DSS compliant password handling
+    - NFR1: Response < 200ms
+    - NFR2: PCI-DSS compliant
 
 interface:
   methods:
     - name: register
-      input:
-        email: string (valid email format)
-        password: string (min 8 chars, 1 uppercase, 1 number)
-      output:
-        success: boolean
-        userId?: string
-        error?: { code: string, message: string }
-
+      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?: string (JWT, expires 24h)
-        error?: { code: string, message: string }
-
-    - name: logout
-      input:
-        token: string
-      output:
-        success: boolean
-
-dependencies:
-  - Database: PostgreSQL (users table)
-  - Cache: Redis (sessions)
-  - Email: SendGrid (password reset)
-
-security:
-  - Passwords hashed with bcrypt (cost factor 12)
-  - JWT signed with RS256
-  - Rate limiting: 5 attempts per minute
-  - Secrets in environment variables
+      input: { email: "string", password: "string" }
+      output: { success: boolean, token?: "JWT 24h", error?: Error }
 
 testing:
-  unit:
-    - Test password validation rules
-    - Test token generation
-    - Test session expiry
-  integration:
-    - Test registration flow
-    - Test login/logout flow
-    - Test password reset flow
-  edge_cases:
-    - Duplicate email registration
-    - Invalid credentials
-    - Expired session
-    - Concurrent login attempts
+  unit: [password validation, token generation]
+  integration: [registration flow, login flow]
+  edge_cases: [duplicate email, invalid credentials]
 ```
 
-### Specification-to-Code Workflow
+### Iterative Refinement Loop
 
-```markdown
-## Step 1: Write Specification
-Create complete spec with all requirements.
+```typescript
+async function omegaDevelopment(spec: Specification): Promise<Code> {
+  let code = await generateFromSpec(spec);
+  let iteration = 0;
 
-## Step 2: Generate Interface
-Prompt: "Generate TypeScript interface from this spec: [spec]"
+  while (iteration < 5) {
+    const results = await runTests(code);
 
-## Step 3: Generate Implementation
-Prompt: "Implement [component] following this interface and spec: [spec]"
+    if (results.allPassing && results.coverage >= 80) {
+      return code; // Done!
+    }
 
-## Step 4: Generate Tests
-Prompt: "Generate comprehensive tests for [component] covering: [test requirements]"
+    const issues = analyzeResults(results);
+    code = await refineCode(code, issues);
+    iteration++;
+  }
 
-## Step 5: Verify and Iterate
-- Run tests
-- Fix any issues
-- Add edge cases
-- Document
-```
+  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!
 ```
 
-### 3. Prompt Engineering for Code
+### Prompt Templates
 
 ```markdown
-## Effective Code Prompts
-
-### Template: Component Generation
-```
-Create a [COMPONENT_TYPE] component named [NAME] with the following:
+## Component Generation
+Create a [TYPE] component named [NAME] with:
 
 Requirements:
-- [Requirement 1]
-- [Requirement 2]
-- [Requirement 3]
+- [Req 1]
+- [Req 2]
 
 Interface:
 [Define inputs, outputs, methods]
 
 Constraints:
 - Language: TypeScript
-- Style: Functional programming preferred
 - Error handling: Return Result types
-- Testing: Include unit tests
-
-Example usage:
-[Show how it should be called]
-
-Do not:
-- Use any deprecated APIs
-- Include console.log in production code
-- Hardcode configuration values
-```
+- Include unit tests
 
-### Template: Refactoring Request
-```
-Refactor the following code to:
+## Refactoring Request
+Refactor this code to:
 1. [Improvement 1]
 2. [Improvement 2]
 
-Current code:
-[paste code]
+Current code: [paste]
 
-Preserve:
-- Existing functionality
-- API compatibility
-- Type signatures
+Preserve: functionality, API, types
 
-Output:
-- Refactored code
-- Explanation of changes
-- Any breaking changes (should be none)
-```
-
-### Template: Bug Fix Request
-```
+## Bug Fix Request
 Fix the bug in this code:
 
-Code:
-[paste code]
-
-Bug description:
-[describe the issue]
-
-Expected behavior:
-[what should happen]
-
-Actual behavior:
-[what actually happens]
-
-Provide:
-1. Root cause analysis
-2. Fixed code
-3. Test to prevent regression
-```
+Code: [paste]
+Bug: [description]
+Expected: [behavior]
+Actual: [behavior]
 
-### Template: Test Generation
+Provide: root cause, fixed code, regression test
 ```
-Generate comprehensive tests for:
 
-Code:
-[paste code]
-
-Test framework: [Jest/Vitest/pytest]
-
-Cover:
-- Happy path scenarios
-- Edge cases: [list specific]
-- Error conditions: [list specific]
-- Boundary conditions
-
-Include:
-- Descriptive test names
-- Arrange-Act-Assert structure
-- Mocks for external dependencies
-```
-```
-
-### 4. Iterative Refinement Pattern
+### Leverage Multiplication Tactics
 
 ```typescript
-// The Omega refinement loop
-interface RefinementCycle {
-  generate: () => Code;
-  test: (code: Code) => TestResults;
-  analyze: (results: TestResults) => Issues[];
-  refine: (code: Code, issues: Issues[]) => Code;
-}
+// Tactic 1: Generate, Don't Write
+// Schema -> API -> Controllers -> Services -> Tests
+// All generated, all consistent, all in minutes
 
-async function omegaDevelopment(spec: Specification): Promise<Code> {
-  // Initial generation
-  let code = await generateFromSpec(spec);
-  let iteration = 0;
-  const maxIterations = 5;
+// Tactic 2: Transform, Don't Recreate
+// "Convert JavaScript to TypeScript with types"
+// "Add error handling to all async functions"
 
-  while (iteration < maxIterations) {
-    // Test the code
-    const results = await runTests(code);
+// Tactic 3: Batch Operations
+// "Add JSDoc to all exports in src/utils/"
+// "Update all class components to functional"
 
-    if (results.allPassing && results.coverage >= 80) {
-      console.log(`✓ Code complete after ${iteration + 1} iterations`);
-      return code;
-    }
-
-    // Analyze failures
-    const issues = analyzeResults(results);
-
-    // Refine code
-    code = await refineCode(code, issues);
-    iteration++;
-  }
-
-  throw new Error('Max iterations reached without passing tests');
-}
+// 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
 
-// Example iteration log:
-/*
-Iteration 1:
-  - Generated: UserService with 5 methods
-  - Tests: 8/12 passing
-  - Issues: Missing null checks, incorrect date handling
-  - Refinement: Added null guards, fixed Date parsing
-
-Iteration 2:
-  - Tests: 11/12 passing
-  - Issues: Edge case for empty input
-  - Refinement: Added empty input validation
-
-Iteration 3:
-  - Tests: 12/12 passing
-  - Coverage: 85%
-  - Complete!
-*/
+// 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"
 ```
 
-### 5. Code Quality Patterns
+### Quality Code Patterns
 
 ```typescript
-// Omega-quality code characteristics
-
-// 1. Self-documenting with clear types
+// 1. Self-documenting with branded types
 interface User {
-  id: UserId;           // Branded type for type safety
-  email: Email;         // Validated email type
-  createdAt: Timestamp; // Unix timestamp
-  status: UserStatus;   // 'active' | 'suspended' | 'deleted'
+  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()
-  );
+  items.reduce((sum, item) => sum.add(item.price.multiply(item.quantity)), Money.zero());
 
-// 3. Explicit error handling
-type Result<T, E = Error> =
-  | { success: true; value: T }
-  | { success: false; error: E };
+// 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) };
-  }
+  if (!user) return { success: false, error: new NotFoundError('User', id) };
   return { success: true, value: user };
 }
 
-// 4. Composable building blocks
-const pipeline = pipe(
-  validate,
-  transform,
-  enrich,
-  persist,
-  notify
-);
+// 4. Composable pipelines
+const processDocument = pipe(parseMarkdown, extractEntities, enrichWithContext, generateSummary);
 
-// 5. Testable by design
+// 5. Dependency injection for testability
 class OrderService {
   constructor(
-    private readonly repo: OrderRepository,  // Injected
-    private readonly payment: PaymentGateway, // Injected
-    private readonly notifier: Notifier       // Injected
+    private readonly repo: OrderRepository,
+    private readonly payment: PaymentGateway
   ) {}
-
-  // Each dependency can be mocked in tests
 }
 ```
 
-### 6. Leverage Multiplication Tactics
-
-```markdown
-## 10x Productivity Tactics
-
-### Tactic 1: Generate, Don't Write
-```
-Instead of: Writing CRUD operations manually
-Do: Generate from schema
-
-Schema → API endpoints → Controllers → Services → Tests
-All generated, all consistent, all in minutes.
-```
-
-### Tactic 2: Transform, Don't Recreate
-```
-Instead of: Building from scratch
-Do: Transform existing code
-
-"Convert this JavaScript to TypeScript with proper types"
-"Add error handling to all async functions"
-"Extract repeated code into reusable utilities"
-```
-
-### Tactic 3: Batch Operations
-```
-Instead of: One file at a time
-Do: Process multiple files
+### Abstraction Levels
 
-"Add JSDoc comments to all exported functions in src/utils/"
-"Update all React class components to functional components"
-"Add input validation to all API route handlers"
-```
-
-### Tactic 4: Template Once, Generate Many
-```yaml
-# Define template once
-template: api_endpoint
-components:
-  - route_handler
-  - validation_schema
-  - service_method
-  - repository_method
-  - unit_tests
-  - integration_test
-
-# Generate for each resource
-resources:
-  - users
-  - products
-  - orders
-  - payments
-
-# Result: 4 resources × 6 components = 24 files generated
-```
-
-### Tactic 5: Test-First Specification
 ```typescript
-// Write the test first as a specification
-describe('ShoppingCart', () => {
-  it('should add items and calculate total', () => {
-    const cart = new ShoppingCart();
-    cart.addItem({ id: '1', name: 'Widget', price: 10, quantity: 2 });
-    cart.addItem({ id: '2', name: 'Gadget', price: 25, quantity: 1 });
-
-    expect(cart.itemCount).toBe(3);
-    expect(cart.total).toBe(45);
-  });
-
-  it('should apply percentage discount', () => {
-    const cart = new ShoppingCart();
-    cart.addItem({ id: '1', name: 'Widget', price: 100, quantity: 1 });
-    cart.applyDiscount({ type: 'percentage', value: 10 });
-
-    expect(cart.total).toBe(90);
-  });
-});
-
-// Then generate implementation from tests
-// "Implement ShoppingCart class to pass these tests"
-```
-```
-
-## Use Cases
-
-### Full Feature Development
-
-```markdown
-## Example: Building Authentication System
-
-### Step 1: Specification
-```yaml
-feature: User Authentication
-scope:
-  - Registration with email/password
-  - Login with JWT tokens
-  - Password reset flow
-  - Session management
-```
-
-### Step 2: Generate Architecture
-Prompt: "Design a scalable authentication system architecture..."
-Output: Component diagram, data flow, technology choices
-
-### Step 3: Generate Data Models
-Prompt: "Generate Prisma schema for auth system..."
-Output: User, Session, PasswordReset models
-
-### Step 4: Generate Services
-Prompt: "Implement AuthService with registration, login, logout..."
-Output: Complete service implementation
-
-### Step 5: Generate API Routes
-Prompt: "Create Express routes for auth endpoints..."
-Output: Route handlers with validation
-
-### Step 6: Generate Tests
-Prompt: "Generate comprehensive tests for AuthService..."
-Output: Unit and integration tests
+// Level 1: Solve one problem (avoid)
+function validateEmail(email: string): boolean {
+  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
+}
 
-### Step 7: Generate Documentation
-Prompt: "Create OpenAPI spec for auth endpoints..."
-Output: API documentation
+// 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 };
+  };
+}
 
-Total time: 2 hours (vs. 2-3 days traditional)
+// 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
 
-### Do's
-
-- Write clear specifications before generating code
-- Use iterative refinement (generate, test, improve)
-- Leverage AI for repetitive tasks
-- Verify generated code meets requirements
-- Maintain human oversight for critical logic
-- Build reusable templates and patterns
-- Document prompts that work well
-- Combine AI strengths with human judgment
-- Start simple and add complexity
-- Keep specifications updated
-
-### Don'ts
-
-- Don't trust generated code without verification
-- Don't skip testing generated code
-- Don't use AI for security-critical code without expert review
-- Don't generate without clear requirements
-- Don't ignore AI suggestions for improvement
-- Don't lose the specification-code relationship
-- Don't over-rely on AI for creative design
-- Don't skip code review for AI-generated code
-- Don't use outdated AI models for complex tasks
-- Don't forget to understand generated code
-
-## References
-
-- [GitHub Copilot Best Practices](https://github.blog/2023-06-20-how-to-write-better-prompts-for-github-copilot/)
-- [Prompt Engineering Guide](https://www.promptingguide.ai/)
-- [AI-Assisted Software Development](https://arxiv.org/abs/2303.17580)
-- [The Pragmatic Programmer](https://pragprog.com/titles/tpp20/the-pragmatic-programmer-20th-anniversary-edition/)
+| 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 |