@gallopsystems/agent-skills 1.6.1 → 1.8.0

package/plugins/kysely-postgres/skills/kysely-postgres/references/select-where.ts

@@ -121,6 +121,59 @@ const complexFilter = await db
   )
   .execute();
 
+// ============================================
+// BETWEEN — use eb.between(), NOT the "between" operator
+// ============================================
+
+// CORRECT: eb.between(col, lo, hi) / eb.betweenSymmetric(col, lo, hi)
+const midPriced = await db
+  .selectFrom("product")
+  .selectAll()
+  .where((eb) => eb.between("price", "50", "100"))
+  .execute();
+// SQL: where "price" between $1 and $2
+
+// betweenSymmetric handles bounds given in either order (swaps if lo > hi)
+const inRange = await db
+  .selectFrom("product")
+  .selectAll()
+  .where((eb) => eb.betweenSymmetric("price", "100", "50"))
+  .execute();
+// SQL: where "price" between symmetric $1 and $2
+
+// GOTCHA: the string-operator form generates INVALID SQL — do NOT use it.
+//   .where("price", "between", ["50", "100"])
+// compiles to:  "price" between ($1, $2)   -- a tuple, which is a Postgres
+// syntax error ("between (a, b)" is not "between a and b"). Always use
+// eb.between() / eb.betweenSymmetric() instead.
+
+// ============================================
+// ANY (array / subquery membership)
+// ============================================
+
+// value = ANY(array_column) — type-safe with eb.fn.any
+const taggedPremium = await db
+  .selectFrom("product")
+  .selectAll()
+  .where((eb) => eb(eb.val("premium"), "=", eb.fn.any("tags")))
+  .execute();
+// SQL: where $1 = any("tags")
+
+// value = ANY(subquery)
+const ownersOfDogs = await db
+  .selectFrom("user")
+  .selectAll()
+  .where((eb) =>
+    eb(
+      eb.val("dog"),
+      "=",
+      eb.fn.any(
+        eb.selectFrom("pet").select("species").whereRef("pet.owner_id", "=", "user.id")
+      )
+    )
+  )
+  .execute();
+
 // ============================================
 // KEY PATTERNS SUMMARY
 // ============================================
@@ -143,4 +196,10 @@ const complexFilter = await db
 4. eb() inside where callbacks
    - eb("column", "=", value) creates comparison
    - Returns Expression<SqlBool> for composability
+
+5. BETWEEN: use eb.between(col, lo, hi) / eb.betweenSymmetric(...)
+   - The "between" string operator emits invalid SQL ("between (a, b)") — avoid.
+
+6. ANY: eb(eb.val(x), "=", eb.fn.any("array_col" | subquery))
+   - Membership test against an array column or a subquery result.
 */

package/plugins/kysely-postgres/skills/kysely-postgres/references/set-operations.ts

@@ -0,0 +1,97 @@
+/**
+ * Set Operations (UNION / INTERSECT / EXCEPT)
+ * Combine the rows of two compatible queries.
+ *
+ *   .union(q) / .unionAll(q)         -> UNION / UNION ALL
+ *   .intersect(q) / .intersectAll(q) -> INTERSECT / INTERSECT ALL
+ *   .except(q) / .exceptAll(q)       -> EXCEPT / EXCEPT ALL
+ *
+ * The plain forms remove duplicates; the *All forms keep them (and are cheaper).
+ * Both sides must select the same number of columns with compatible types and
+ * matching output names — align them with `as` aliases when they differ.
+ */
+import { db } from "./db";
+
+// ============================================
+// UNION — distinct rows from both queries
+// ============================================
+
+// Align column names with aliases so both branches produce the same shape.
+const contacts = await db
+  .selectFrom("user")
+  .select(["id", "email as contact"])
+  .union(db.selectFrom("supplier").select(["id", "contact_email as contact"]))
+  .execute();
+// SQL: select "id", "email" as "contact" from "user"
+//      union select "id", "contact_email" as "contact" from "supplier"
+
+// UNION ALL — keep duplicates (faster; no dedup pass)
+const allEvents = await db
+  .selectFrom("order")
+  .select(["id", "created_at"])
+  .unionAll(db.selectFrom("review").select(["id", "created_at"]))
+  .execute();
+
+// ============================================
+// INTERSECT — rows present in BOTH queries
+// ============================================
+
+const usersWhoAreAlsoReviewers = await db
+  .selectFrom("order")
+  .select("user_id")
+  .intersect(db.selectFrom("review").select("user_id"))
+  .execute();
+
+// INTERSECT ALL keeps duplicate matches
+const repeated = await db
+  .selectFrom("order")
+  .select("user_id")
+  .intersectAll(db.selectFrom("review").select("user_id"))
+  .execute();
+
+// ============================================
+// EXCEPT — rows in the FIRST query but not the second
+// ============================================
+
+// Users who placed an order but never wrote a review.
+const ordersWithoutReviews = await db
+  .selectFrom("order")
+  .select("user_id")
+  .except(db.selectFrom("review").select("user_id"))
+  .execute();
+
+const ordersWithoutReviewsKeepDupes = await db
+  .selectFrom("order")
+  .select("user_id")
+  .exceptAll(db.selectFrom("review").select("user_id"))
+  .execute();
+
+// ============================================
+// ORDERING THE COMBINED RESULT
+// ============================================
+
+// orderBy/limit after a set op apply to the whole combined result.
+const recentCombined = await db
+  .selectFrom("order")
+  .select(["id", "created_at"])
+  .unionAll(db.selectFrom("review").select(["id", "created_at"]))
+  .orderBy("created_at", "desc")
+  .limit(20)
+  .execute();
+
+// ============================================
+// KEY PATTERNS SUMMARY
+// ============================================
+
+/*
+1. Both branches must select the same columns (count + compatible types) with
+   matching output names — use `as` to line them up.
+
+2. Plain forms dedupe; *All forms keep duplicates and skip the dedup pass.
+   Reach for unionAll/intersectAll/exceptAll unless you actually need DISTINCT.
+
+3. EXCEPT/INTERSECT are set-difference / set-intersection on whole rows.
+
+4. orderBy/limit chained after the set op apply to the combined result, not the
+   individual branches.
+*/

package/plugins/kysely-postgres/skills/kysely-postgres/references/window-functions.ts

@@ -0,0 +1,294 @@
+/**
+ * Window Functions
+ * Ranking, value, and aggregate functions over OVER() windows.
+ *
+ * Two builders cover almost everything:
+ *   - eb.fn.agg<T>("NAME", [args]).over(...)  for named window functions
+ *     (ROW_NUMBER, RANK, LAG, ...) that have no dedicated helper
+ *   - eb.fn.sum/count/avg/min/max(col).over(...)  for windowed aggregates
+ *
+ * The OVER() body is built with a callback: (ob) => ob.partitionBy(...).orderBy(...)
+ * Call .over() with no callback for an empty OVER ().
+ *
+ * The one thing the builder CANNOT express is a frame clause
+ * (ROWS/RANGE/GROUPS BETWEEN) — see WINDOW FRAMES below.
+ */
+import { db } from "./db";
+import { sql } from "kysely";
+
+// ============================================
+// RANKING FUNCTIONS
+// ============================================
+
+// ROW_NUMBER / RANK / DENSE_RANK — use eb.fn.agg (no dedicated helper)
+// Rank products by price within each category.
+const rankedProducts = await db
+  .selectFrom("product")
+  .select((eb) => [
+    "id",
+    "name",
+    "category_id",
+    eb.fn
+      .agg<number>("ROW_NUMBER")
+      .over((ob) => ob.partitionBy("category_id").orderBy("price", "desc"))
+      .as("row_num"),
+    eb.fn
+      .agg<number>("RANK")
+      .over((ob) => ob.partitionBy("category_id").orderBy("price", "desc"))
+      .as("price_rank"),
+    eb.fn
+      .agg<number>("DENSE_RANK")
+      .over((ob) => ob.partitionBy("category_id").orderBy("price", "desc"))
+      .as("dense_rank"),
+  ])
+  .execute();
+// SQL: ROW_NUMBER() over(partition by "category_id" order by "price" desc) as "row_num"
+
+// NTILE / PERCENT_RANK / CUME_DIST — NTILE takes an argument (use sql.lit)
+const productBuckets = await db
+  .selectFrom("product")
+  .select((eb) => [
+    "id",
+    eb.fn
+      .agg<number>("NTILE", [sql.lit(4)])
+      .over((ob) => ob.orderBy("price", "desc"))
+      .as("price_quartile"),
+    eb.fn
+      .agg<number>("PERCENT_RANK")
+      .over((ob) => ob.orderBy("price", "desc"))
+      .as("pct_rank"),
+  ])
+  .execute();
+// SQL: NTILE(4) over(order by "price" desc) as "price_quartile"
+
+// ============================================
+// VALUE FUNCTIONS (LAG / LEAD / FIRST_VALUE / NTH_VALUE)
+// ============================================
+
+// LAG / LEAD — args: (column, offset?, default?). Wrap literals in sql.lit().
+// Type the result yourself; nullable unless you supply a default.
+const orderTrends = await db
+  .selectFrom("order")
+  .select((eb) => [
+    "id",
+    "created_at",
+    "total_amount",
+    eb.fn
+      .agg<number | null>("LAG", ["total_amount", sql.lit(1)])
+      .over((ob) => ob.partitionBy("user_id").orderBy("created_at"))
+      .as("prev_amount"),
+    eb.fn
+      .agg<number | null>("LEAD", ["total_amount", sql.lit(1)])
+      .over((ob) => ob.partitionBy("user_id").orderBy("created_at"))
+      .as("next_amount"),
+    // With a default value (no nulls): LAG(total_amount, 1, 0)
+    eb.fn
+      .agg<number>("LAG", ["total_amount", sql.lit(1), sql.lit(0)])
+      .over((ob) => ob.partitionBy("user_id").orderBy("created_at"))
+      .as("prev_amount_or_zero"),
+  ])
+  .execute();
+// SQL: LAG("total_amount", 1, 0) over(partition by "user_id" order by "created_at") as "prev_amount_or_zero"
+
+// FIRST_VALUE / NTH_VALUE
+const categoryExtremes = await db
+  .selectFrom("product")
+  .select((eb) => [
+    "id",
+    "category_id",
+    eb.fn
+      .agg<number>("FIRST_VALUE", ["price"])
+      .over((ob) => ob.partitionBy("category_id").orderBy("price", "desc"))
+      .as("highest_in_category"),
+    eb.fn
+      .agg<number | null>("NTH_VALUE", ["price", sql.lit(2)])
+      .over((ob) => ob.partitionBy("category_id").orderBy("price", "desc"))
+      .as("second_highest"),
+  ])
+  .execute();
+
+// ============================================
+// AGGREGATE WINDOWS (sum/count/avg/min/max .over())
+// ============================================
+
+// Empty OVER () — aggregate over the whole result set, no collapsing of rows
+const withGrandTotal = await db
+  .selectFrom("order")
+  .select((eb) => [
+    "id",
+    "total_amount",
+    eb.fn.sum<number>("total_amount").over().as("grand_total"),
+  ])
+  .execute();
+// SQL: sum("total_amount") over() as "grand_total"
+
+// Running total — ORDER BY without a frame defaults to
+// "RANGE UNBOUNDED PRECEDING -> CURRENT ROW" (cumulative)
+const runningTotals = await db
+  .selectFrom("order")
+  .select((eb) => [
+    "id",
+    "created_at",
+    "total_amount",
+    eb.fn
+      .sum<number>("total_amount")
+      .over((ob) => ob.orderBy("created_at"))
+      .as("running_total"),
+  ])
+  .execute();
+// SQL: sum("total_amount") over(order by "created_at") as "running_total"
+
+// Partition total + percent-of-partition (mix a window into a raw expression)
+const sharePerCategory = await db
+  .selectFrom("product")
+  .select((eb) => [
+    "id",
+    "category_id",
+    "price",
+    eb.fn
+      .sum<number>("price")
+      .over((ob) => ob.partitionBy("category_id"))
+      .as("category_total"),
+    sql<number>`${eb.ref("price")} * 100.0 / ${eb.fn
+      .sum("price")
+      .over((ob) => ob.partitionBy("category_id"))}`.as("pct_of_category"),
+  ])
+  .execute();
+
+// ============================================
+// FILTER + DISTINCT IN WINDOWS (PostgreSQL)
+// ============================================
+
+// .filterWhere() composes with .over() — conditional windowed aggregation
+const activeCounts = await db
+  .selectFrom("order")
+  .select((eb) => [
+    "id",
+    "user_id",
+    eb.fn
+      .countAll<number>()
+      .filterWhere("status", "=", "completed")
+      .over((ob) => ob.partitionBy("user_id"))
+      .as("completed_orders_for_user"),
+  ])
+  .execute();
+// SQL: count(*) filter(where "status" = $1) over(partition by "user_id")
+
+// COUNT(DISTINCT ...) OVER (...)
+const distinctStatuses = await db
+  .selectFrom("order")
+  .select((eb) => [
+    "id",
+    "user_id",
+    eb.fn
+      .count<number>("status")
+      .distinct()
+      .over((ob) => ob.partitionBy("user_id"))
+      .as("distinct_statuses_for_user"),
+  ])
+  .execute();
+// SQL: count(distinct "status") over(partition by "user_id")
+
+// ============================================
+// WINDOW FRAMES (ROWS/RANGE BETWEEN) — RAW SQL REQUIRED
+// ============================================
+
+// Kysely's OverBuilder exposes ONLY partitionBy + orderBy. There is no frame
+// node in its AST at all (confirmed through 0.28, 0.29, and main), and
+// .over() rejects a raw sql argument. Frame support is the open feature
+// request kysely-org/kysely#505. So a frame clause must be written as raw SQL.
+//
+// You do NOT lose all type safety: interpolate eb.ref() for columns (validated)
+// and sql.lit() for bounds, and type the result with sql<T>. Only the function
+// name and the frame keywords are raw text.
+
+// Moving average over the last 3 rows
+const movingAverage = await db
+  .selectFrom("order")
+  .select((eb) => [
+    "id",
+    "created_at",
+    "total_amount",
+    sql<number>`avg(${eb.ref("total_amount")}) over (
+      order by ${eb.ref("created_at")}
+      rows between 2 preceding and current row
+    )`.as("moving_avg_3"),
+  ])
+  .execute();
+// SQL: avg("total_amount") over ( order by "created_at" rows between 2 preceding and current row )
+
+// Cumulative sum with an explicit frame
+const cumulative = await db
+  .selectFrom("order")
+  .select((eb) => [
+    "id",
+    sql<number>`sum(${eb.ref("total_amount")}) over (
+      partition by ${eb.ref("user_id")}
+      order by ${eb.ref("created_at")}
+      rows between unbounded preceding and current row
+    )`.as("cumulative_sum"),
+  ])
+  .execute();
+
+// ============================================
+// COMMON PATTERNS
+// ============================================
+
+// Top-N per group: rank in a CTE, then filter in the outer query.
+// (You can't filter on a window alias in the same SELECT's WHERE — windows are
+// computed after WHERE — so the CTE/subquery wrapper is required.)
+const top3ProductsPerCategory = await db
+  .with("ranked", (db) =>
+    db
+      .selectFrom("product")
+      .select((eb) => [
+        "id",
+        "name",
+        "category_id",
+        "price",
+        eb.fn
+          .agg<number>("ROW_NUMBER")
+          .over((ob) => ob.partitionBy("category_id").orderBy("price", "desc"))
+          .as("rn"),
+      ])
+  )
+  .selectFrom("ranked")
+  .selectAll()
+  .where("rn", "<=", 3)
+  .execute();
+
+// Percent of total (empty OVER () as the denominator)
+const pctOfTotal = await db
+  .selectFrom("product")
+  .select((eb) => [
+    "id",
+    "price",
+    sql<number>`round(${eb.ref("price")} * 100.0 / ${eb.fn
+      .sum("price")
+      .over()}, 2)`.as("pct_of_total"),
+  ])
+  .execute();
+
+// ============================================
+// KEY PATTERNS SUMMARY
+// ============================================
+
+/*
+1. Named window functions: eb.fn.agg<T>("ROW_NUMBER").over((ob) => ...)
+   - ROW_NUMBER, RANK, DENSE_RANK, NTILE, PERCENT_RANK, CUME_DIST
+   - LAG, LEAD, FIRST_VALUE, LAST_VALUE, NTH_VALUE
+   - Function arguments go in the array; wrap literals in sql.lit().
+
+2. Windowed aggregates: eb.fn.sum/count/avg/min/max(col).over((ob) => ...)
+   - .over() with no callback => OVER () over the whole result set.
+   - .filterWhere(...) and .distinct() compose with .over().
+
+3. OVER body: (ob) => ob.partitionBy(col | [cols]).orderBy(col, "desc")
+
+4. Frames (ROWS/RANGE BETWEEN) are NOT supported by the builder (issue #505).
+   Write the window as raw sql, keeping eb.ref() for columns and sql<T> for the
+   result type. Only the function name + frame keywords are raw.
+
+5. Filtering on a window result (e.g. row_number = 1) needs a CTE/subquery:
+   windows are computed after WHERE, so wrap and filter in the outer query.
+*/

package/plugins/nuxt-nitro-api/skills/nuxt-nitro-api/SKILL.md

@@ -76,7 +76,7 @@ From nuxt-auth-utils:
 - `hashPassword`, `verifyPassword`
 - `defineOAuth*EventHandler` (Google, GitHub, etc.)
 
-**Need to import:** `z` from "zod", `fromZodError` from "zod-validation-error"
+**Need to import:** `z` from "zod" (zod 4 — error formatting is built in via `z.prettifyError()`; no `zod-validation-error` needed)
 
 ### Client-side
 
@@ -104,7 +104,7 @@ const query = await getValidatedQuery(event, z.object({
 }));
 
 const body = await readValidatedBody(event, z.object({
-  email: z.string().email(),
+  email: z.email(), // Zod 4: top-level, not z.string().email()
   name: z.string().min(1),
 }));
 ```

package/plugins/nuxt-nitro-api/skills/nuxt-nitro-api/nitro-tasks.md

@@ -33,7 +33,7 @@ Tasks live in `server/tasks/`. Directory structure = task name with colons:
 import { z } from "zod";
 
 const PayloadSchema = z.object({
-  to: z.string().email(),
+  to: z.email(), // Zod 4: top-level, not z.string().email()
   subject: z.string(),
   body: z.string(),
 });

package/plugins/nuxt-nitro-api/skills/nuxt-nitro-api/validation.md

@@ -43,25 +43,28 @@ const query = await getValidatedQuery(event, (data) => querySchema.parse(data));
 
 ## Pattern 3: safeParse for Better Errors
 
+Zod 4 has a built-in `z.prettifyError()` — no `zod-validation-error` dependency needed:
+
 ```typescript
-import { fromZodError } from "zod-validation-error";
+import { z } from "zod";
 
 const rawQuery = getQuery(event);
 const result = querySchema.safeParse(rawQuery);
 
 if (!result.success) {
-  console.error("Validation error:", result.error);  // Dev log
-  const userError = fromZodError(result.error);      // User-friendly
+  console.error("Validation error:", z.treeifyError(result.error)); // structured dev log
   throw createError({
     statusCode: 400,
     statusMessage: "Bad Request",
-    message: userError.message,
+    message: z.prettifyError(result.error), // human-readable, e.g. "✖ Invalid email address\n  → at email"
   });
 }
 
 return result.data;
 ```
 
+`z.prettifyError(err)` returns a readable multi-line string; `z.treeifyError(err)` returns a nested object keyed by field (the replacement for the deprecated `.format()`). Use `z.flattenError(err)` for a flat `{ formErrors, fieldErrors }` shape.
+
 ## Common Zod Patterns
 
 ### Query Parameters
@@ -90,7 +93,7 @@ const querySchema = z.object({
 
 ```typescript
 const createUserSchema = z.object({
-  email: z.string().email(),
+  email: z.email(), // Zod 4: top-level, NOT z.string().email()
   name: z.string().min(1).max(100),
   role: z.enum(["admin", "user"]).default("user"),
   metadata: z.record(z.string(), z.any()).optional(),
@@ -117,7 +120,7 @@ Export schemas for client-side type reuse:
 import { z } from "zod";
 
 export const CreateUserSchema = z.object({
-  email: z.string().email(),
+  email: z.email(),
   name: z.string().min(1),
 });
 
@@ -129,3 +132,17 @@ const body: CreateUserInput = { email: "test@example.com", name: "Test" };
 ```
 
 **Note:** Nitro auto-generates response types, but NOT input types from Zod schemas.
+
+## Zod 4 Notes (this stack pins zod ^4)
+
+The model's prior is mostly Zod 3 — these are the idioms that changed. Get them right.
+
+- **String formats are top-level functions, not `z.string()` methods.** Use `z.email()`, `z.url()`, `z.uuid()`, `z.ipv4()`, `z.iso.datetime()`. The chained forms (`z.string().email()`) are deprecated.
+- **Error customization is one `error` param.** `message`, `invalid_type_error`, `required_error`, and `errorMap` are gone:
+  ```typescript
+  z.string().min(5, { error: "Too short." });
+  z.string({ error: (iss) => iss.input === undefined ? "Required" : "Must be a string" });
+  ```
+- **Format errors with the built-ins**, not `zod-validation-error`: `z.prettifyError()` (human string), `z.treeifyError()` (nested, replaces deprecated `.format()`), `z.flattenError()` (replaces deprecated `.flatten()`).
+- **`.default()` applies to the *output* type** and short-circuits parsing when input is `undefined`. For the old "run the default through the schema" behavior, use `.prefault()`.
+- **`z.coerce.*` input type is now `unknown`** (not the output type) — fine for h3 query/body parsing, but affects schemas you consume elsewhere.

package/plugins/tailwind-v4/.claude-plugin/plugin.json

@@ -0,0 +1,8 @@
+{
+  "name": "tailwind-v4",
+  "description": "Tailwind CSS v4 (CSS-first): @import/@theme/@source config, the no-tailwind.config.js model, prefers-color-scheme dark mode, and the v3->v4 traps an LLM trained on v3 falls into",
+  "version": "1.0.0",
+  "author": {
+    "name": "yeedle"
+  }
+}