@monoes/monomindcli 2.16.1 → 2.16.3

package/org-skills/database-migration/SKILL.md

@@ -1,337 +0,0 @@
----
-name: database-migration
-description: "Execute database migrations across ORMs and platforms with zero-downtime strategies, data transformation, and rollback procedures. Use when migrating databases, changing schemas, performing data transformations, or implementing zero-downtime deployment strategies."
-tags: ["data","backend"]
-tools: ["monograph_query","monograph_impact"]
-license: MIT
-source: https://github.com/wshobson/agents
-source_path: "plugins/framework-migration/skills/database-migration"
-source_commit: 4236bb91f8395b0435f1d8b8baf9e8e4c69a8620
----
-# Database Migration
-
-Master database schema and data migrations across ORMs (Sequelize, TypeORM, Prisma), including rollback strategies and zero-downtime deployments.
-
-## When to Use This Skill
-
-- Migrating between different ORMs
-- Performing schema transformations
-- Moving data between databases
-- Implementing rollback procedures
-- Zero-downtime deployments
-- Database version upgrades
-- Data model refactoring
-
-## ORM Migrations
-
-### Sequelize Migrations
-
-```javascript
-// migrations/20231201-create-users.js
-module.exports = {
-  up: async (queryInterface, Sequelize) => {
-    await queryInterface.createTable("users", {
-      id: {
-        type: Sequelize.INTEGER,
-        primaryKey: true,
-        autoIncrement: true,
-      },
-      email: {
-        type: Sequelize.STRING,
-        unique: true,
-        allowNull: false,
-      },
-      createdAt: Sequelize.DATE,
-      updatedAt: Sequelize.DATE,
-    });
-  },
-
-  down: async (queryInterface, Sequelize) => {
-    await queryInterface.dropTable("users");
-  },
-};
-
-// Run: npx sequelize-cli db:migrate
-// Rollback: npx sequelize-cli db:migrate:undo
-```
-
-### TypeORM Migrations
-
-```typescript
-// migrations/1701234567-CreateUsers.ts
-import { MigrationInterface, QueryRunner, Table } from "typeorm";
-
-export class CreateUsers1701234567 implements MigrationInterface {
-  public async up(queryRunner: QueryRunner): Promise<void> {
-    await queryRunner.createTable(
-      new Table({
-        name: "users",
-        columns: [
-          {
-            name: "id",
-            type: "int",
-            isPrimary: true,
-            isGenerated: true,
-            generationStrategy: "increment",
-          },
-          {
-            name: "email",
-            type: "varchar",
-            isUnique: true,
-          },
-          {
-            name: "created_at",
-            type: "timestamp",
-            default: "CURRENT_TIMESTAMP",
-          },
-        ],
-      }),
-    );
-  }
-
-  public async down(queryRunner: QueryRunner): Promise<void> {
-    await queryRunner.dropTable("users");
-  }
-}
-
-// Run: npm run typeorm migration:run
-// Rollback: npm run typeorm migration:revert
-```
-
-### Prisma Migrations
-
-```prisma
-// schema.prisma
-model User {
-  id        Int      @id @default(autoincrement())
-  email     String   @unique
-  createdAt DateTime @default(now())
-}
-
-// Generate migration: npx prisma migrate dev --name create_users
-// Apply: npx prisma migrate deploy
-```
-
-## Schema Transformations
-
-### Adding Columns with Defaults
-
-```javascript
-// Safe migration: add column with default
-module.exports = {
-  up: async (queryInterface, Sequelize) => {
-    await queryInterface.addColumn("users", "status", {
-      type: Sequelize.STRING,
-      defaultValue: "active",
-      allowNull: false,
-    });
-  },
-
-  down: async (queryInterface) => {
-    await queryInterface.removeColumn("users", "status");
-  },
-};
-```
-
-### Renaming Columns (Zero Downtime)
-
-```javascript
-// Step 1: Add new column
-module.exports = {
-  up: async (queryInterface, Sequelize) => {
-    await queryInterface.addColumn("users", "full_name", {
-      type: Sequelize.STRING,
-    });
-
-    // Copy data from old column
-    await queryInterface.sequelize.query("UPDATE users SET full_name = name");
-  },
-
-  down: async (queryInterface) => {
-    await queryInterface.removeColumn("users", "full_name");
-  },
-};
-
-// Step 2: Update application to use new column
-
-// Step 3: Remove old column
-module.exports = {
-  up: async (queryInterface) => {
-    await queryInterface.removeColumn("users", "name");
-  },
-
-  down: async (queryInterface, Sequelize) => {
-    await queryInterface.addColumn("users", "name", {
-      type: Sequelize.STRING,
-    });
-  },
-};
-```
-
-### Changing Column Types
-
-```javascript
-module.exports = {
-  up: async (queryInterface, Sequelize) => {
-    // For large tables, use multi-step approach
-
-    // 1. Add new column
-    await queryInterface.addColumn("users", "age_new", {
-      type: Sequelize.INTEGER,
-    });
-
-    // 2. Copy and transform data
-    await queryInterface.sequelize.query(`
-      UPDATE users
-      SET age_new = CAST(age AS INTEGER)
-      WHERE age IS NOT NULL
-    `);
-
-    // 3. Drop old column
-    await queryInterface.removeColumn("users", "age");
-
-    // 4. Rename new column
-    await queryInterface.renameColumn("users", "age_new", "age");
-  },
-
-  down: async (queryInterface, Sequelize) => {
-    await queryInterface.changeColumn("users", "age", {
-      type: Sequelize.STRING,
-    });
-  },
-};
-```
-
-## Data Transformations
-
-### Complex Data Migration
-
-```javascript
-module.exports = {
-  up: async (queryInterface, Sequelize) => {
-    // Get all records
-    const [users] = await queryInterface.sequelize.query(
-      "SELECT id, address_string FROM users",
-    );
-
-    // Transform each record
-    for (const user of users) {
-      const addressParts = user.address_string.split(",");
-
-      await queryInterface.sequelize.query(
-        `UPDATE users
-         SET street = :street,
-             city = :city,
-             state = :state
-         WHERE id = :id`,
-        {
-          replacements: {
-            id: user.id,
-            street: addressParts[0]?.trim(),
-            city: addressParts[1]?.trim(),
-            state: addressParts[2]?.trim(),
-          },
-        },
-      );
-    }
-
-    // Drop old column
-    await queryInterface.removeColumn("users", "address_string");
-  },
-
-  down: async (queryInterface, Sequelize) => {
-    // Reconstruct original column
-    await queryInterface.addColumn("users", "address_string", {
-      type: Sequelize.STRING,
-    });
-
-    await queryInterface.sequelize.query(`
-      UPDATE users
-      SET address_string = CONCAT(street, ', ', city, ', ', state)
-    `);
-
-    await queryInterface.removeColumn("users", "street");
-    await queryInterface.removeColumn("users", "city");
-    await queryInterface.removeColumn("users", "state");
-  },
-};
-```
-
-## Rollback Strategies
-
-### Transaction-Based Migrations
-
-```javascript
-module.exports = {
-  up: async (queryInterface, Sequelize) => {
-    const transaction = await queryInterface.sequelize.transaction();
-
-    try {
-      await queryInterface.addColumn(
-        "users",
-        "verified",
-        { type: Sequelize.BOOLEAN, defaultValue: false },
-        { transaction },
-      );
-
-      await queryInterface.sequelize.query(
-        "UPDATE users SET verified = true WHERE email_verified_at IS NOT NULL",
-        { transaction },
-      );
-
-      await transaction.commit();
-    } catch (error) {
-      await transaction.rollback();
-      throw error;
-    }
-  },
-
-  down: async (queryInterface) => {
-    await queryInterface.removeColumn("users", "verified");
-  },
-};
-```
-
-### Checkpoint-Based Rollback
-
-```javascript
-module.exports = {
-  up: async (queryInterface, Sequelize) => {
-    // Create backup table
-    await queryInterface.sequelize.query(
-      "CREATE TABLE users_backup AS SELECT * FROM users",
-    );
-
-    try {
-      // Perform migration
-      await queryInterface.addColumn("users", "new_field", {
-        type: Sequelize.STRING,
-      });
-
-      // Verify migration
-      const [result] = await queryInterface.sequelize.query(
-        "SELECT COUNT(*) as count FROM users WHERE new_field IS NULL",
-      );
-
-      if (result[0].count > 0) {
-        throw new Error("Migration verification failed");
-      }
-
-      // Drop backup
-      await queryInterface.dropTable("users_backup");
-    } catch (error) {
-      // Restore from backup
-      await queryInterface.sequelize.query("DROP TABLE users");
-      await queryInterface.sequelize.query(
-        "CREATE TABLE users AS SELECT * FROM users_backup",
-      );
-      await queryInterface.dropTable("users_backup");
-      throw error;
-    }
-  },
-};
-```
-
-## Additional patterns and templates
-
-More detailed templates and worked examples live in `references/details.md`. Read that file for the full pattern library.

package/org-skills/database-migration/references/details.md

@@ -1,76 +0,0 @@
-# database-migration — additional patterns and templates
-
-## Zero-Downtime Migrations
-
-### Blue-Green Deployment Strategy
-
-```javascript
-// Phase 1: Make changes backward compatible
-module.exports = {
-  up: async (queryInterface, Sequelize) => {
-    // Add new column (both old and new code can work)
-    await queryInterface.addColumn("users", "email_new", {
-      type: Sequelize.STRING,
-    });
-  },
-};
-
-// Phase 2: Deploy code that writes to both columns
-
-// Phase 3: Backfill data
-module.exports = {
-  up: async (queryInterface) => {
-    await queryInterface.sequelize.query(`
-      UPDATE users
-      SET email_new = email
-      WHERE email_new IS NULL
-    `);
-  },
-};
-
-// Phase 4: Deploy code that reads from new column
-
-// Phase 5: Remove old column
-module.exports = {
-  up: async (queryInterface) => {
-    await queryInterface.removeColumn("users", "email");
-  },
-};
-```
-
-## Cross-Database Migrations
-
-### PostgreSQL to MySQL
-
-```javascript
-// Handle differences
-module.exports = {
-  up: async (queryInterface, Sequelize) => {
-    const dialectName = queryInterface.sequelize.getDialect();
-
-    if (dialectName === "mysql") {
-      await queryInterface.createTable("users", {
-        id: {
-          type: Sequelize.INTEGER,
-          primaryKey: true,
-          autoIncrement: true,
-        },
-        data: {
-          type: Sequelize.JSON, // MySQL JSON type
-        },
-      });
-    } else if (dialectName === "postgres") {
-      await queryInterface.createTable("users", {
-        id: {
-          type: Sequelize.INTEGER,
-          primaryKey: true,
-          autoIncrement: true,
-        },
-        data: {
-          type: Sequelize.JSONB, // PostgreSQL JSONB type
-        },
-      });
-    }
-  },
-};
-```

package/org-skills/error-handling-patterns/LICENSE.txt

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Seth Hobson
-
-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. 

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

@@ -1,126 +0,0 @@
----
-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