@sanity/ailf 0.1.0

package/canonical/grader-references/studio-setup.yaml

@@ -0,0 +1,275 @@
+# studio-setup.yaml — Human-graded reference samples for Studio Setup tasks
+#
+# Real LLM responses from eval runs, graded by a human expert.
+# Used by `pnpm grader-validate` to measure grader accuracy.
+
+- taskId: studio-blog-schema
+  area: studio-setup
+  response: |
+    To set up a Sanity Studio with a blog schema, here's a complete implementation:
+
+    ```typescript
+    // sanity.config.ts
+    import { defineConfig } from 'sanity'
+    import { structureTool } from 'sanity/structure'
+    import { schemaTypes } from './schemas'
+
+    export default defineConfig({
+      name: 'default',
+      title: 'My Blog',
+      projectId: '<your-project-id>',
+      dataset: 'production',
+      plugins: [structureTool()],
+      schema: {
+        types: schemaTypes,
+      },
+    })
+
+    // schemas/index.ts
+    import { post } from './post'
+    import { author } from './author'
+    import { category } from './category'
+
+    export const schemaTypes = [post, author, category]
+
+    // schemas/post.ts
+    import { defineType, defineField } from 'sanity'
+
+    export const post = defineType({
+      name: 'post',
+      title: 'Post',
+      type: 'document',
+      fields: [
+        defineField({
+          name: 'title',
+          title: 'Title',
+          type: 'string',
+          validation: (rule) => rule.required(),
+        }),
+        defineField({
+          name: 'slug',
+          title: 'Slug',
+          type: 'slug',
+          options: { source: 'title', maxLength: 96 },
+        }),
+        defineField({
+          name: 'author',
+          title: 'Author',
+          type: 'reference',
+          to: [{ type: 'author' }],
+        }),
+        defineField({
+          name: 'categories',
+          title: 'Categories',
+          type: 'array',
+          of: [{ type: 'reference', to: [{ type: 'category' }] }],
+        }),
+        defineField({
+          name: 'publishedAt',
+          title: 'Published at',
+          type: 'datetime',
+        }),
+        defineField({
+          name: 'body',
+          title: 'Body',
+          type: 'array',
+          of: [{ type: 'block' }],
+        }),
+      ],
+    })
+
+    // schemas/author.ts
+    import { defineType, defineField } from 'sanity'
+
+    export const author = defineType({
+      name: 'author',
+      title: 'Author',
+      type: 'document',
+      fields: [
+        defineField({
+          name: 'name',
+          title: 'Name',
+          type: 'string',
+          validation: (rule) => rule.required(),
+        }),
+        defineField({
+          name: 'bio',
+          title: 'Bio',
+          type: 'text',
+        }),
+        defineField({
+          name: 'image',
+          title: 'Image',
+          type: 'image',
+          options: { hotspot: true },
+        }),
+      ],
+    })
+
+    // schemas/category.ts
+    import { defineType, defineField } from 'sanity'
+
+    export const category = defineType({
+      name: 'category',
+      title: 'Category',
+      type: 'document',
+      fields: [
+        defineField({
+          name: 'title',
+          title: 'Title',
+          type: 'string',
+        }),
+        defineField({
+          name: 'description',
+          title: 'Description',
+          type: 'text',
+        }),
+      ],
+    })
+    ```
+  rubrics:
+    - dimension: task-completion
+      rubricText: |
+        Score task completion from 0 to 100:
+        - 0: Couldn't attempt — missing critical information
+        - 20: Attempted but fundamentally wrong approach
+        - 50: Partial implementation — major functional gaps
+        - 80: Mostly complete — minor issues or missing edge cases
+        - 100: Fully functional code — works as expected
+
+        Must demonstrate:
+        - Three document types: post, author, category
+        - Post includes Portable Text body (array of blocks)
+        - Post has reference to author
+        - Post has array of references to categories
+        - sanity.config.ts with defineConfig and schema registration
+
+        Return ONLY a JSON object: {"score": <number>, "reason": "<explanation>"}
+      humanScore: 95
+      notes:
+        "All criteria met. Clean separation of schema files, proper use of
+        defineType/defineField, correct reference patterns, Portable Text body."
+    - dimension: code-correctness
+      rubricText: |
+        Score code correctness from 0 to 100:
+        - 0: Broken code, syntax errors, or deprecated APIs
+        - 30: Works but uses anti-patterns or inefficient approaches
+        - 50: Works but not idiomatic
+        - 80: Follows most best practices
+        - 100: Follows all best practices, idiomatic implementation
+
+        Check for:
+        - Uses defineConfig, defineType, defineField (not deprecated createSchema)
+        - Correct reference syntax: type: 'reference', to: [{type: 'author'}]
+        - Portable Text as array of blocks: type: 'array', of: [{type: 'block'}]
+        - Proper validation rules
+        - Schema registered via schema.types in config
+
+        Return ONLY a JSON object: {"score": <number>, "reason": "<explanation>"}
+      humanScore: 90
+      notes:
+        "All modern APIs used correctly. defineConfig, defineType, defineField
+        all proper. Reference syntax correct. Validation on required fields.
+        Only minor: could add preview configuration."
+    - dimension: doc-coverage
+      rubricText: |
+        Score documentation coverage from 0 to 100:
+        - 0: Had to hallucinate/guess most implementation details
+        - 30: Significant gaps — filled with assumptions
+        - 50: Some gaps — inferred from partial information
+        - 80: Minor gaps — almost everything was documented
+        - 100: Complete coverage — all necessary info was in docs
+
+        Return ONLY a JSON object: {"score": <number>, "reason": "<explanation>"}
+      humanScore: 85
+      notes:
+        "All patterns match documented APIs. structureTool import, schema
+        registration, field types — all from docs. The slug options.source
+        pattern is documented."
+  gradedBy: "senior-engineer"
+  gradedAt: "2026-03-10"
+
+- taskId: studio-blog-schema
+  area: studio-setup
+  response: |
+    Here's a basic blog schema for Sanity:
+
+    ```javascript
+    // schema.js
+    export default createSchema({
+      name: 'default',
+      types: [
+        {
+          name: 'post',
+          type: 'document',
+          fields: [
+            { name: 'title', type: 'string' },
+            { name: 'body', type: 'text' },
+            { name: 'author', type: 'string' },
+          ]
+        }
+      ]
+    })
+    ```
+  rubrics:
+    - dimension: task-completion
+      rubricText: |
+        Score task completion from 0 to 100:
+        - 0: Couldn't attempt — missing critical information
+        - 20: Attempted but fundamentally wrong approach
+        - 50: Partial implementation — major functional gaps
+        - 80: Mostly complete — minor issues or missing edge cases
+        - 100: Fully functional code — works as expected
+
+        Must demonstrate:
+        - Three document types: post, author, category
+        - Post includes Portable Text body (array of blocks)
+        - Post has reference to author
+        - Post has array of references to categories
+        - sanity.config.ts with defineConfig and schema registration
+
+        Return ONLY a JSON object: {"score": <number>, "reason": "<explanation>"}
+      humanScore: 15
+      notes:
+        "Only post type defined (missing author, category). Body is plain text
+        not Portable Text. Author is a string not a reference. No categories.
+        Uses deprecated createSchema."
+    - dimension: code-correctness
+      rubricText: |
+        Score code correctness from 0 to 100:
+        - 0: Broken code, syntax errors, or deprecated APIs
+        - 30: Works but uses anti-patterns or inefficient approaches
+        - 50: Works but not idiomatic
+        - 80: Follows most best practices
+        - 100: Follows all best practices, idiomatic implementation
+
+        Check for:
+        - Uses defineConfig, defineType, defineField (not deprecated createSchema)
+        - Correct reference syntax: type: 'reference', to: [{type: 'author'}]
+        - Portable Text as array of blocks: type: 'array', of: [{type: 'block'}]
+        - Proper validation rules
+        - Schema registered via schema.types in config
+
+        Return ONLY a JSON object: {"score": <number>, "reason": "<explanation>"}
+      humanScore: 5
+      notes:
+        "Uses deprecated createSchema (removed in Sanity v3). No
+        defineType/defineField. Plain JavaScript instead of TypeScript. No
+        references, no Portable Text, no validation."
+    - dimension: doc-coverage
+      rubricText: |
+        Score documentation coverage from 0 to 100:
+        - 0: Had to hallucinate/guess most implementation details
+        - 30: Significant gaps — filled with assumptions
+        - 50: Some gaps — inferred from partial information
+        - 80: Minor gaps — almost everything was documented
+        - 100: Complete coverage — all necessary info was in docs
+
+        Return ONLY a JSON object: {"score": <number>, "reason": "<explanation>"}
+      humanScore: 5
+      notes:
+        "Entirely based on outdated v2 patterns. createSchema is deprecated.
+        None of the documented v3 APIs (defineConfig, defineType, structureTool)
+        are used."
+  gradedBy: "senior-engineer"
+  gradedAt: "2026-03-10"

package/canonical/reference-solutions/.gitkeep

@@ -0,0 +1 @@
+

package/canonical/reference-solutions/frameworks/nuxt.ts

@@ -0,0 +1,119 @@
+/**
+ * Reference Solution: Sanity Integration with Nuxt
+ *
+ * Demonstrates:
+ * - Installing and configuring @sanity/nuxt module
+ * - Setting up the Sanity module in nuxt.config.ts
+ * - Using useSanityQuery composable for data fetching
+ * - Rendering portable text content in Vue components
+ *
+ * Note: Vue template syntax is shown in comments since this is a .ts file.
+ */
+
+// === Part 1: Nuxt Configuration (nuxt.config.ts) ===
+
+export default defineNuxtConfig({
+  modules: ["@sanity/nuxt"],
+  sanity: {
+    projectId: "your-project-id",
+    dataset: "production",
+    apiVersion: "2024-01-01",
+    // useCdn: true is the default for production
+  },
+})
+
+// === Part 2: Posts List Page (pages/posts/index.vue) ===
+//
+// <template>
+//   <main>
+//     <h1>Blog Posts</h1>
+//     <ul v-if="data">
+//       <li v-for="post in data" :key="post._id">
+//         <NuxtLink :to="`/posts/${post.slug}`">
+//           <h2>{{ post.title }}</h2>
+//           <p>{{ post.excerpt }}</p>
+//         </NuxtLink>
+//       </li>
+//     </ul>
+//   </main>
+// </template>
+//
+// <script setup lang="ts">
+// import { groq } from "groq"
+//
+// const query = groq`*[_type == "post"] | order(publishedAt desc) {
+//   _id,
+//   title,
+//   "slug": slug.current,
+//   excerpt,
+// }`
+//
+// const { data } = useSanityQuery(query)
+// </script>
+
+// === Part 3: Individual Post Page (pages/posts/[slug].vue) ===
+//
+// <template>
+//   <article v-if="data">
+//     <h1>{{ data.title }}</h1>
+//     <time :datetime="data.publishedAt">
+//       {{ new Date(data.publishedAt).toLocaleDateString() }}
+//     </time>
+//     <SanityContent :blocks="data.body" />
+//   </article>
+// </template>
+//
+// <script setup lang="ts">
+// import { groq } from "groq"
+//
+// const route = useRoute()
+// const query = groq`*[_type == "post" && slug.current == $slug][0] {
+//   _id,
+//   title,
+//   body,
+//   publishedAt,
+// }`
+//
+// const { data } = useSanityQuery(query, { slug: route.params.slug })
+// </script>
+
+// === Part 4: Sanity Studio Embedded (nuxt.config.ts addition) ===
+
+// To embed Sanity Studio directly in the Nuxt app:
+export const studioConfig = defineNuxtConfig({
+  modules: ["@sanity/nuxt"],
+  sanity: {
+    projectId: "your-project-id",
+    dataset: "production",
+    apiVersion: "2024-01-01",
+    // Enable the embedded studio at /studio route
+    studio: {
+      studioHost: "your-studio-host",
+    },
+  },
+})
+
+// === Part 5: Server API Route (server/api/posts.ts) ===
+//
+// For server-side data fetching with full control:
+
+import { createClient } from "@sanity/client"
+
+const client = createClient({
+  projectId: "your-project-id",
+  dataset: "production",
+  apiVersion: "2024-01-01",
+  useCdn: true,
+})
+
+const POSTS_QUERY = `*[_type == "post"] | order(publishedAt desc) {
+  _id,
+  title,
+  "slug": slug.current,
+}`
+
+// In Nuxt server routes, export defineEventHandler
+export default defineEventHandler(async () => {
+  const posts = await client.fetch(POSTS_QUERY)
+  return posts
+})

package/canonical/reference-solutions/frameworks/remix.tsx

@@ -0,0 +1,100 @@
+/**
+ * Reference Solution: Sanity Integration with Remix
+ *
+ * Demonstrates:
+ * - Creating a Sanity client configured for Remix
+ * - Using GROQ queries in Remix loader functions
+ * - Fetching content with client.fetch() in loaders
+ * - Rendering content with useLoaderData
+ * - Portable text rendering with @portabletext/react
+ */
+
+// === Part 1: Sanity Client (app/sanity/client.ts) ===
+
+import { createClient } from "@sanity/client"
+
+export const client = createClient({
+  projectId: "your-project-id",
+  dataset: "production",
+  apiVersion: "2024-01-01",
+  // Use CDN for published content in production
+  useCdn: process.env.NODE_ENV === "production",
+})
+
+// === Part 2: Posts List Route (app/routes/posts._index.tsx) ===
+
+import type { LoaderFunctionArgs } from "@remix-run/node"
+import { useLoaderData, Link } from "@remix-run/react"
+
+const POSTS_QUERY = `*[_type == "post"] | order(publishedAt desc) {
+  _id,
+  title,
+  "slug": slug.current,
+  publishedAt,
+  excerpt,
+}`
+
+export async function loader({ request }: LoaderFunctionArgs) {
+  const posts = await client.fetch(POSTS_QUERY)
+  return { posts }
+}
+
+export default function PostsIndex() {
+  const { posts } = useLoaderData<typeof loader>()
+
+  return (
+    <main>
+      <h1>Blog Posts</h1>
+      <ul>
+        {posts.map((post) => (
+          <li key={post._id}>
+            <Link to={`/posts/${post.slug}`}>
+              <h2>{post.title}</h2>
+              <p>{post.excerpt}</p>
+              <time dateTime={post.publishedAt}>
+                {new Date(post.publishedAt).toLocaleDateString()}
+              </time>
+            </Link>
+          </li>
+        ))}
+      </ul>
+    </main>
+  )
+}
+
+// === Part 3: Individual Post Route (app/routes/posts.$slug.tsx) ===
+
+import { PortableText } from "@portabletext/react"
+
+const POST_QUERY = `*[_type == "post" && slug.current == $slug][0] {
+  _id,
+  title,
+  body,
+  publishedAt,
+  "author": author->name,
+}`
+
+export async function loader({ params }: LoaderFunctionArgs) {
+  const post = await client.fetch(POST_QUERY, { slug: params.slug })
+  if (!post) {
+    throw new Response("Post not found", { status: 404 })
+  }
+  return { post }
+}
+
+export default function PostDetail() {
+  const { post } = useLoaderData<typeof loader>()
+
+  return (
+    <article>
+      <h1>{post.title}</h1>
+      {post.author && <p>By {post.author}</p>}
+      <time dateTime={post.publishedAt}>
+        {new Date(post.publishedAt).toLocaleDateString()}
+      </time>
+      <div>
+        <PortableText value={post.body} />
+      </div>
+    </article>
+  )
+}

package/canonical/reference-solutions/functions/publish-webhook.ts

@@ -0,0 +1,60 @@
+// Sanity Function: Publish webhook handler
+// Demonstrates: defineFunction, document publish trigger, event handling, external API calls
+
+import { defineFunction } from "sanity/functions"
+
+// Define a function that triggers when a document is published
+export const onPublishWebhook = defineFunction({
+  name: "on-publish-webhook",
+  title: "Publish Webhook",
+  description: "Sends a webhook notification when a document is published",
+
+  // Trigger on document publish events
+  trigger: {
+    type: "document.publish",
+    // Optionally filter by document type
+    filter: {
+      types: ["post", "article"],
+    },
+  },
+
+  // The handler function receives the event context
+  async handler(event, context) {
+    const { document, previousDocument } = event
+    const { projectId, dataset } = context
+
+    // Build the webhook payload
+    const payload = {
+      event: "document.published",
+      projectId,
+      dataset,
+      documentId: document._id,
+      documentType: document._type,
+      title: document.title ?? document._id,
+      publishedAt: new Date().toISOString(),
+      isUpdate: !!previousDocument,
+    }
+
+    // Send to an external webhook URL (configured via environment/secrets)
+    const webhookUrl = process.env.WEBHOOK_URL
+    if (!webhookUrl) {
+      console.warn("WEBHOOK_URL not configured, skipping notification")
+      return { success: false, reason: "no webhook URL configured" }
+    }
+
+    const response = await fetch(webhookUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify(payload),
+    })
+
+    if (!response.ok) {
+      console.error(`Webhook failed: ${response.status} ${response.statusText}`)
+      return { success: false, status: response.status }
+    }
+
+    return { success: true, documentId: document._id }
+  },
+})