regexcronsql-validator

Ejecuta un patrón de expresión regular (motor nativo de JavaScript) contra una lista de strings de prueba y devuelve, para cada uno, si hizo match, el match completo y los grupos capturados. Usa RegExp real, no una suposición del modelo sobre qué haría el patrón. Cuesta $0.02 USDC (Base) por llamada.

{
  "type": "object",
  "properties": {
    "pattern": {
      "type": "string",
      "description": "El patrón de la expresión regular, sin delimitadores de barra (ej: \"^[0-9]{3}-[0-9]{4}$\", no \"/^[0-9]{3}-[0-9]{4}$/\")."
    },
    "flags": {
      "description": "Flags de RegExp de JavaScript a aplicar (ej: \"gi\" para global + case-insensitive). Vacío por defecto.",
      "type": "string"
    },
    "test_strings": {
      "minItems": 1,
      "maxItems": 50,
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 2000
      },
      "description": "Lista de strings a evaluar contra el patrón, uno por uno. Máximo 50 strings, 2000 caracteres cada uno."
    }
  },
  "required": [
    "pattern",
    "test_strings"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

{
  "type": "object",
  "properties": {
    "valid_pattern": {
      "type": "boolean",
      "description": "false si el patrón no es una expresión regular válida en JS."
    },
    "error": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "description": "Mensaje de error si valid_pattern es false; null si es válido."
    },
    "results": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "test_string": {
            "type": "string"
          },
          "matched": {
            "type": "boolean"
          },
          "full_match": {
            "anyOf": [
              {
                "type": "string"
              },
              {
                "type": "null"
              }
            ]
          },
          "groups": {
            "anyOf": [
              {
                "type": "array",
                "items": {
                  "anyOf": [
                    {
                      "type": "string"
                    },
                    {
                      "type": "null"
                    }
                  ]
                }
              },
              {
                "type": "null"
              }
            ]
          }
        },
        "required": [
          "test_string",
          "matched",
          "full_match",
          "groups"
        ],
        "additionalProperties": false
      },
      "description": "Un resultado por cada test_string, en el mismo orden en que se recibieron."
    }
  },
  "required": [
    "valid_pattern",
    "error",
    "results"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false
}

Calcula las próximas ejecuciones reales de una expresión cron usando cron-parser (no una suposición del modelo sobre cuándo dispararía). Interpreta los campos en UTC para que el resultado no dependa de la zona horaria del servidor que corre la tool. Cuesta $0.02 USDC (Base) por llamada.

{
  "type": "object",
  "properties": {
    "cron_expression": {
      "type": "string",
      "description": "Expresión cron estándar de 5 campos (minuto hora día-mes mes día-semana), 6 con segundos, o un atajo como \"@daily\". Ej: \"0 9 * * 1-5\" = 9am de lunes a viernes."
    },
    "from_date": {
      "description": "Fecha ISO 8601 desde la cual calcular las próximas ejecuciones (ej: \"2026-08-07T00:00:00Z\"). Si se omite, se usa el momento actual.",
      "type": "string"
    },
    "count": {
      "description": "Cantidad de próximas ejecuciones a devolver. Default 5, máximo 20.",
      "type": "integer",
      "minimum": 1,
      "maximum": 20
    }
  },
  "required": [
    "cron_expression"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

{
  "type": "object",
  "properties": {
    "valid_expression": {
      "type": "boolean",
      "description": "false si la expresión cron no es válida."
    },
    "error": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "description": "Mensaje de error si valid_expression es false; null si es válida."
    },
    "next_executions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Fechas ISO 8601 en UTC de las próximas ejecuciones, en orden cronológico."
    }
  },
  "required": [
    "valid_expression",
    "error",
    "next_executions"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false
}

Ejecuta una consulta SQL (dialecto Postgres, motor pg-mem en memoria) contra tablas de prueba opcionales y devuelve las filas reales resultantes. Usa un motor SQL real, no una suposición del modelo sobre qué devolvería la query. Sin base de datos persistente: las tablas se crean desde cero en cada llamada y se descartan al terminar. Cuesta $0.04 USDC (Base) por llamada.

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "maxLength": 5000,
      "description": "La consulta SQL a ejecutar (ej: \"SELECT nombre FROM clientes WHERE activo = true\"). Máximo 5000 caracteres."
    },
    "tables": {
      "description": "Tablas de prueba a crear antes de correr la query. Omitir si la query no referencia ninguna tabla. Máximo 5 tablas.",
      "maxItems": 5,
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string",
            "description": "Nombre de la tabla, tal como aparece en la query."
          },
          "rows": {
            "minItems": 1,
            "maxItems": 200,
            "type": "array",
            "items": {
              "type": "object",
              "propertyNames": {
                "type": "string"
              },
              "additionalProperties": {}
            },
            "description": "Filas de prueba como objetos JSON (clave = columna). El tipo de cada columna se infiere del primer valor no nulo encontrado. Máximo 200 filas."
          }
        },
        "required": [
          "name",
          "rows"
        ]
      }
    }
  },
  "required": [
    "query"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema"
}

{
  "type": "object",
  "properties": {
    "valid_query": {
      "type": "boolean",
      "description": "false si la query tiene un error de sintaxis o de ejecución (ej: tabla inexistente)."
    },
    "error": {
      "anyOf": [
        {
          "type": "string"
        },
        {
          "type": "null"
        }
      ],
      "description": "Mensaje de error si valid_query es false; null si es válida."
    },
    "rows": {
      "type": "array",
      "items": {
        "type": "object",
        "propertyNames": {
          "type": "string"
        },
        "additionalProperties": {}
      },
      "description": "Filas resultantes de la ejecución real de la query, hasta un máximo de 500."
    },
    "truncated": {
      "type": "boolean",
      "description": "true si el resultado real tenía más de 500 filas y se cortó."
    }
  },
  "required": [
    "valid_query",
    "error",
    "rows",
    "truncated"
  ],
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "additionalProperties": false
}