@monoes/monomindcli 2.15.3 → 2.15.4

package/org-skills/error-handling-patterns/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: error-handling-patterns
+description: "Master error handling patterns across languages including exceptions, Result types, error propagation, and graceful degradation to build resilient applications. Use when implementing error handling, designing APIs, or improving application reliability."
+tags: ["engineering"]
+tools: ["monograph_query","monograph_context"]
+license: MIT
+source: https://github.com/wshobson/agents
+source_path: "plugins/developer-essentials/skills/error-handling-patterns"
+source_commit: 4236bb91f8395b0435f1d8b8baf9e8e4c69a8620
+---
+# Error Handling Patterns
+
+Build resilient applications with robust error handling strategies that gracefully handle failures and provide excellent debugging experiences.
+
+## When to Use This Skill
+
+- Implementing error handling in new features
+- Designing error-resilient APIs
+- Debugging production issues
+- Improving application reliability
+- Creating better error messages for users and developers
+- Implementing retry and circuit breaker patterns
+- Handling async/concurrent errors
+- Building fault-tolerant distributed systems
+
+## Core Concepts
+
+### 1. Error Handling Philosophies
+
+**Exceptions vs Result Types:**
+
+- **Exceptions**: Traditional try-catch, disrupts control flow
+- **Result Types**: Explicit success/failure, functional approach
+- **Error Codes**: C-style, requires discipline
+- **Option/Maybe Types**: For nullable values
+
+**When to Use Each:**
+
+- Exceptions: Unexpected errors, exceptional conditions
+- Result Types: Expected errors, validation failures
+- Panics/Crashes: Unrecoverable errors, programming bugs
+
+### 2. Error Categories
+
+**Recoverable Errors:**
+
+- Network timeouts
+- Missing files
+- Invalid user input
+- API rate limits
+
+**Unrecoverable Errors:**
+
+- Out of memory
+- Stack overflow
+- Programming bugs (null pointer, etc.)
+
+## Detailed patterns and worked examples
+
+Detailed pattern documentation lives in `references/details.md`. Read that file when the navigation tier above is insufficient.
+
+## Best Practices
+
+1. **Fail Fast**: Validate input early, fail quickly
+2. **Preserve Context**: Include stack traces, metadata, timestamps
+3. **Meaningful Messages**: Explain what happened and how to fix it
+4. **Log Appropriately**: Error = log, expected failure = don't spam logs
+5. **Handle at Right Level**: Catch where you can meaningfully handle
+6. **Clean Up Resources**: Use try-finally, context managers, defer
+7. **Don't Swallow Errors**: Log or re-throw, don't silently ignore
+8. **Type-Safe Errors**: Use typed errors when possible
+
+```python
+# Good error handling example
+def process_order(order_id: str) -> Order:
+    """Process order with comprehensive error handling."""
+    try:
+        # Validate input
+        if not order_id:
+            raise ValidationError("Order ID is required")
+
+        # Fetch order
+        order = db.get_order(order_id)
+        if not order:
+            raise NotFoundError("Order", order_id)
+
+        # Process payment
+        try:
+            payment_result = payment_service.charge(order.total)
+        except PaymentServiceError as e:
+            # Log and wrap external service error
+            logger.error(f"Payment failed for order {order_id}: {e}")
+            raise ExternalServiceError(
+                f"Payment processing failed",
+                service="payment_service",
+                details={"order_id": order_id, "amount": order.total}
+            ) from e
+
+        # Update order
+        order.status = "completed"
+        order.payment_id = payment_result.id
+        db.save(order)
+
+        return order
+
+    except ApplicationError:
+        # Re-raise known application errors
+        raise
+    except Exception as e:
+        # Log unexpected errors
+        logger.exception(f"Unexpected error processing order {order_id}")
+        raise ApplicationError(
+            "Order processing failed",
+            code="INTERNAL_ERROR"
+        ) from e
+```
+
+## Common Pitfalls
+
+- **Catching Too Broadly**: `except Exception` hides bugs
+- **Empty Catch Blocks**: Silently swallowing errors
+- **Logging and Re-throwing**: Creates duplicate log entries
+- **Not Cleaning Up**: Forgetting to close files, connections
+- **Poor Error Messages**: "Error occurred" is not helpful
+- **Returning Error Codes**: Use exceptions or Result types
+- **Ignoring Async Errors**: Unhandled promise rejections

package/org-skills/error-handling-patterns/references/details.md

@@ -0,0 +1,516 @@
+# error-handling-patterns — detailed patterns and worked examples
+
+## Language-Specific Patterns
+
+### Python Error Handling
+
+**Custom Exception Hierarchy:**
+
+```python
+class ApplicationError(Exception):
+    """Base exception for all application errors."""
+    def __init__(self, message: str, code: str = None, details: dict = None):
+        super().__init__(message)
+        self.code = code
+        self.details = details or {}
+        self.timestamp = datetime.utcnow()
+
+class ValidationError(ApplicationError):
+    """Raised when validation fails."""
+    pass
+
+class NotFoundError(ApplicationError):
+    """Raised when resource not found."""
+    pass
+
+class ExternalServiceError(ApplicationError):
+    """Raised when external service fails."""
+    def __init__(self, message: str, service: str, **kwargs):
+        super().__init__(message, **kwargs)
+        self.service = service
+
+# Usage
+def get_user(user_id: str) -> User:
+    user = db.query(User).filter_by(id=user_id).first()
+    if not user:
+        raise NotFoundError(
+            f"User not found",
+            code="USER_NOT_FOUND",
+            details={"user_id": user_id}
+        )
+    return user
+```
+
+**Context Managers for Cleanup:**
+
+```python
+from contextlib import contextmanager
+
+@contextmanager
+def database_transaction(session):
+    """Ensure transaction is committed or rolled back."""
+    try:
+        yield session
+        session.commit()
+    except Exception as e:
+        session.rollback()
+        raise
+    finally:
+        session.close()
+
+# Usage
+with database_transaction(db.session) as session:
+    user = User(name="Alice")
+    session.add(user)
+    # Automatic commit or rollback
+```
+
+**Retry with Exponential Backoff:**
+
+```python
+import time
+from functools import wraps
+from typing import TypeVar, Callable
+
+T = TypeVar('T')
+
+def retry(
+    max_attempts: int = 3,
+    backoff_factor: float = 2.0,
+    exceptions: tuple = (Exception,)
+):
+    """Retry decorator with exponential backoff."""
+    def decorator(func: Callable[..., T]) -> Callable[..., T]:
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> T:
+            last_exception = None
+            for attempt in range(max_attempts):
+                try:
+                    return func(*args, **kwargs)
+                except exceptions as e:
+                    last_exception = e
+                    if attempt < max_attempts - 1:
+                        sleep_time = backoff_factor ** attempt
+                        time.sleep(sleep_time)
+                        continue
+                    raise
+            raise last_exception
+        return wrapper
+    return decorator
+
+# Usage
+@retry(max_attempts=3, exceptions=(NetworkError,))
+def fetch_data(url: str) -> dict:
+    response = requests.get(url, timeout=5)
+    response.raise_for_status()
+    return response.json()
+```
+
+### TypeScript/JavaScript Error Handling
+
+**Custom Error Classes:**
+
+```typescript
+// Custom error classes
+class ApplicationError extends Error {
+  constructor(
+    message: string,
+    public code: string,
+    public statusCode: number = 500,
+    public details?: Record<string, any>,
+  ) {
+    super(message);
+    this.name = this.constructor.name;
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+class ValidationError extends ApplicationError {
+  constructor(message: string, details?: Record<string, any>) {
+    super(message, "VALIDATION_ERROR", 400, details);
+  }
+}
+
+class NotFoundError extends ApplicationError {
+  constructor(resource: string, id: string) {
+    super(`${resource} not found`, "NOT_FOUND", 404, { resource, id });
+  }
+}
+
+// Usage
+function getUser(id: string): User {
+  const user = users.find((u) => u.id === id);
+  if (!user) {
+    throw new NotFoundError("User", id);
+  }
+  return user;
+}
+```
+
+**Result Type Pattern:**
+
+```typescript
+// Result type for explicit error handling
+type Result<T, E = Error> = { ok: true; value: T } | { ok: false; error: E };
+
+// Helper functions
+function Ok<T>(value: T): Result<T, never> {
+  return { ok: true, value };
+}
+
+function Err<E>(error: E): Result<never, E> {
+  return { ok: false, error };
+}
+
+// Usage
+function parseJSON<T>(json: string): Result<T, SyntaxError> {
+  try {
+    const value = JSON.parse(json) as T;
+    return Ok(value);
+  } catch (error) {
+    return Err(error as SyntaxError);
+  }
+}
+
+// Consuming Result
+const result = parseJSON<User>(userJson);
+if (result.ok) {
+  console.log(result.value.name);
+} else {
+  console.error("Parse failed:", result.error.message);
+}
+
+// Chaining Results
+function chain<T, U, E>(
+  result: Result<T, E>,
+  fn: (value: T) => Result<U, E>,
+): Result<U, E> {
+  return result.ok ? fn(result.value) : result;
+}
+```
+
+**Async Error Handling:**
+
+```typescript
+// Async/await with proper error handling
+async function fetchUserOrders(userId: string): Promise<Order[]> {
+  try {
+    const user = await getUser(userId);
+    const orders = await getOrders(user.id);
+    return orders;
+  } catch (error) {
+    if (error instanceof NotFoundError) {
+      return []; // Return empty array for not found
+    }
+    if (error instanceof NetworkError) {
+      // Retry logic
+      return retryFetchOrders(userId);
+    }
+    // Re-throw unexpected errors
+    throw error;
+  }
+}
+
+// Promise error handling
+function fetchData(url: string): Promise<Data> {
+  return fetch(url)
+    .then((response) => {
+      if (!response.ok) {
+        throw new NetworkError(`HTTP ${response.status}`);
+      }
+      return response.json();
+    })
+    .catch((error) => {
+      console.error("Fetch failed:", error);
+      throw error;
+    });
+}
+```
+
+### Rust Error Handling
+
+**Result and Option Types:**
+
+```rust
+use std::fs::File;
+use std::io::{self, Read};
+
+// Result type for operations that can fail
+fn read_file(path: &str) -> Result<String, io::Error> {
+    let mut file = File::open(path)?;  // ? operator propagates errors
+    let mut contents = String::new();
+    file.read_to_string(&mut contents)?;
+    Ok(contents)
+}
+
+// Custom error types
+#[derive(Debug)]
+enum AppError {
+    Io(io::Error),
+    Parse(std::num::ParseIntError),
+    NotFound(String),
+    Validation(String),
+}
+
+impl From<io::Error> for AppError {
+    fn from(error: io::Error) -> Self {
+        AppError::Io(error)
+    }
+}
+
+// Using custom error type
+fn read_number_from_file(path: &str) -> Result<i32, AppError> {
+    let contents = read_file(path)?;  // Auto-converts io::Error
+    let number = contents.trim().parse()
+        .map_err(AppError::Parse)?;   // Explicitly convert ParseIntError
+    Ok(number)
+}
+
+// Option for nullable values
+fn find_user(id: &str) -> Option<User> {
+    users.iter().find(|u| u.id == id).cloned()
+}
+
+// Combining Option and Result
+fn get_user_age(id: &str) -> Result<u32, AppError> {
+    find_user(id)
+        .ok_or_else(|| AppError::NotFound(id.to_string()))
+        .map(|user| user.age)
+}
+```
+
+### Go Error Handling
+
+**Explicit Error Returns:**
+
+```go
+// Basic error handling
+func getUser(id string) (*User, error) {
+    user, err := db.QueryUser(id)
+    if err != nil {
+        return nil, fmt.Errorf("failed to query user: %w", err)
+    }
+    if user == nil {
+        return nil, errors.New("user not found")
+    }
+    return user, nil
+}
+
+// Custom error types
+type ValidationError struct {
+    Field   string
+    Message string
+}
+
+func (e *ValidationError) Error() string {
+    return fmt.Sprintf("validation failed for %s: %s", e.Field, e.Message)
+}
+
+// Sentinel errors for comparison
+var (
+    ErrNotFound     = errors.New("not found")
+    ErrUnauthorized = errors.New("unauthorized")
+    ErrInvalidInput = errors.New("invalid input")
+)
+
+// Error checking
+user, err := getUser("123")
+if err != nil {
+    if errors.Is(err, ErrNotFound) {
+        // Handle not found
+    } else {
+        // Handle other errors
+    }
+}
+
+// Error wrapping and unwrapping
+func processUser(id string) error {
+    user, err := getUser(id)
+    if err != nil {
+        return fmt.Errorf("process user failed: %w", err)
+    }
+    // Process user
+    return nil
+}
+
+// Unwrap errors
+err := processUser("123")
+if err != nil {
+    var valErr *ValidationError
+    if errors.As(err, &valErr) {
+        fmt.Printf("Validation error: %s\n", valErr.Field)
+    }
+}
+```
+
+## Universal Patterns
+
+### Pattern 1: Circuit Breaker
+
+Prevent cascading failures in distributed systems.
+
+```python
+from enum import Enum
+from datetime import datetime, timedelta
+from typing import Callable, TypeVar
+
+T = TypeVar('T')
+
+class CircuitState(Enum):
+    CLOSED = "closed"       # Normal operation
+    OPEN = "open"          # Failing, reject requests
+    HALF_OPEN = "half_open"  # Testing if recovered
+
+class CircuitBreaker:
+    def __init__(
+        self,
+        failure_threshold: int = 5,
+        timeout: timedelta = timedelta(seconds=60),
+        success_threshold: int = 2
+    ):
+        self.failure_threshold = failure_threshold
+        self.timeout = timeout
+        self.success_threshold = success_threshold
+        self.failure_count = 0
+        self.success_count = 0
+        self.state = CircuitState.CLOSED
+        self.last_failure_time = None
+
+    def call(self, func: Callable[[], T]) -> T:
+        if self.state == CircuitState.OPEN:
+            if datetime.now() - self.last_failure_time > self.timeout:
+                self.state = CircuitState.HALF_OPEN
+                self.success_count = 0
+            else:
+                raise Exception("Circuit breaker is OPEN")
+
+        try:
+            result = func()
+            self.on_success()
+            return result
+        except Exception as e:
+            self.on_failure()
+            raise
+
+    def on_success(self):
+        self.failure_count = 0
+        if self.state == CircuitState.HALF_OPEN:
+            self.success_count += 1
+            if self.success_count >= self.success_threshold:
+                self.state = CircuitState.CLOSED
+                self.success_count = 0
+
+    def on_failure(self):
+        self.failure_count += 1
+        self.last_failure_time = datetime.now()
+        if self.failure_count >= self.failure_threshold:
+            self.state = CircuitState.OPEN
+
+# Usage
+circuit_breaker = CircuitBreaker()
+
+def fetch_data():
+    return circuit_breaker.call(lambda: external_api.get_data())
+```
+
+### Pattern 2: Error Aggregation
+
+Collect multiple errors instead of failing on first error.
+
+```typescript
+class ErrorCollector {
+  private errors: Error[] = [];
+
+  add(error: Error): void {
+    this.errors.push(error);
+  }
+
+  hasErrors(): boolean {
+    return this.errors.length > 0;
+  }
+
+  getErrors(): Error[] {
+    return [...this.errors];
+  }
+
+  throw(): never {
+    if (this.errors.length === 1) {
+      throw this.errors[0];
+    }
+    throw new AggregateError(
+      this.errors,
+      `${this.errors.length} errors occurred`,
+    );
+  }
+}
+
+// Usage: Validate multiple fields
+function validateUser(data: any): User {
+  const errors = new ErrorCollector();
+
+  if (!data.email) {
+    errors.add(new ValidationError("Email is required"));
+  } else if (!isValidEmail(data.email)) {
+    errors.add(new ValidationError("Email is invalid"));
+  }
+
+  if (!data.name || data.name.length < 2) {
+    errors.add(new ValidationError("Name must be at least 2 characters"));
+  }
+
+  if (!data.age || data.age < 18) {
+    errors.add(new ValidationError("Age must be 18 or older"));
+  }
+
+  if (errors.hasErrors()) {
+    errors.throw();
+  }
+
+  return data as User;
+}
+```
+
+### Pattern 3: Graceful Degradation
+
+Provide fallback functionality when errors occur.
+
+```python
+from typing import Optional, Callable, TypeVar
+
+T = TypeVar('T')
+
+def with_fallback(
+    primary: Callable[[], T],
+    fallback: Callable[[], T],
+    log_error: bool = True
+) -> T:
+    """Try primary function, fall back to fallback on error."""
+    try:
+        return primary()
+    except Exception as e:
+        if log_error:
+            logger.error(f"Primary function failed: {e}")
+        return fallback()
+
+# Usage
+def get_user_profile(user_id: str) -> UserProfile:
+    return with_fallback(
+        primary=lambda: fetch_from_cache(user_id),
+        fallback=lambda: fetch_from_database(user_id)
+    )
+
+# Multiple fallbacks
+def get_exchange_rate(currency: str) -> float:
+    return (
+        try_function(lambda: api_provider_1.get_rate(currency))
+        or try_function(lambda: api_provider_2.get_rate(currency))
+        or try_function(lambda: cache.get_rate(currency))
+        or DEFAULT_RATE
+    )
+
+def try_function(func: Callable[[], Optional[T]]) -> Optional[T]:
+    try:
+        return func()
+    except Exception:
+        return None
+```

package/org-skills/event-marketing/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Corey Haines
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.