@upstart.gg/sdk 0.0.135 → 0.0.137

package/src/shared/sitemap.ts

@@ -1,61 +1,12 @@
 import { Type, type Static } from "@sinclair/typebox";
 import { StringEnum } from "./utils/string-enum";
 import { pageSchema } from "./page";
-import { toLLMSchema } from "./utils/llm";
-
-export const sitemapPageEntry = Type.Pick(pageSchema, ["id", "label", "path", "attributes"]);
-export type SitemapPageEntry = Static<typeof sitemapPageEntry>;
-
-export const sectionsPlanSchema = Type.Array(
-  Type.Object(
-    {
-      id: Type.String({
-        title: "Section ID",
-        examples: ["header-section", "hero-section", "features-section"],
-        format: "slug",
-      }),
-      name: Type.String({ title: "Section name", examples: ["Header", "Hero", "Features"] }),
-      description: Type.String({
-        title: "A long description of the section",
-        description: `You must elaborate a clear and detailled plan that describes:
-- The section purpose in the page, in detail.
-- The section structure, look & feel, and structural/design organization, in detail
-- the types of bricks (e.g. "container", "text", "video", "carousel", etc) that will be used and their purpose, in detail
-
-IMPORTANT: be very descriptive and precise in your plan. The more details you provide, the better the generated page will be.`,
-
-        examples: [
-          "This section contains a `hero` and a call-to-action `button`. All of theme aligned horizontally. The section should market a coffee shop.",
-          "This section should contain a `hero` text and an `image`.",
-        ],
-      }),
-    },
-    { additionalProperties: false },
-  ),
-  {
-    title: "Sections plan",
-    description: "A plan for the sections of the page. Used to generate the page content.",
-    examples: [
-      [
-        {
-          id: "header-section",
-          name: "Header",
-          description: "This section only contains a header brick",
-        },
-        {
-          id: "hero-section",
-          name: "Hero",
-          description:
-            "This is the hero section of the page. It should display a marketing message using a hero brick, as well as a button (CTA). The section should center bricks horizontally.",
-        },
-      ],
-    ],
-  },
-);
+import { pageAttributesSchema } from "./attributes";
 
 export const sitemapEntry = Type.Composite(
   [
-    sitemapPageEntry,
+    Type.Pick(pageSchema, ["id", "label"]),
+    Type.Pick(pageAttributesSchema, ["path", "tags"]),
     Type.Object({
       status: Type.Optional(
         StringEnum(["draft", "published"], {
@@ -65,30 +16,14 @@ export const sitemapEntry = Type.Composite(
           "ai:hidden": true,
           description:
             "The status of the page. Can be draft or published. [AI instructions: Dont generate this.]",
-          "ai:instructions": "Upsie: Never generate this optional field.",
         }),
       ),
     }),
   ],
   {
     description: "Pages map. The complete list of site pages & their metadata",
-    additionalProperties: false,
   },
 );
 
 export const sitemapSchema = Type.Array(sitemapEntry);
 export type Sitemap = Static<typeof sitemapSchema>;
-
-export const sitemapSchemaLLM = toLLMSchema(
-  Type.Array(
-    Type.Composite([
-      sitemapEntry,
-      Type.Object({
-        // Sections plan helps agents to the structure and content of the page
-        sectionsPlan: sectionsPlanSchema,
-      }),
-    ]),
-  ),
-);
-
-export const sitemapSchemaNoPlansLLM = toLLMSchema(sitemapSchema);

package/src/shared/tests/attributes.test.ts

@@ -16,6 +16,8 @@ describe("Attributes test suite", () => {
         title: "Untitled",
         description: "",
         keywords: "",
+        queries: [],
+        tags: [],
       });
     });
   });

package/src/shared/theme.ts

@@ -36,7 +36,6 @@ const headingFont = Type.Object(
   {
     title: "Headings font",
     description: "Used for titles and headings",
-    additionalProperties: false,
   },
 );
 
@@ -54,111 +53,97 @@ const bodyFont = Type.Object(
   {
     title: "Body font",
     description: "Used for paragraphs and body text",
-    additionalProperties: false,
   },
 );
 
-export const themeSchema = Type.Object(
-  {
-    id: Type.String({ title: "ID", description: "The unique identifier of the theme" }),
-    name: Type.String({ title: "Name", description: "The name of the theme" }),
-    description: Type.String({ title: "Description", description: "The description of the theme" }),
-    tags: Type.Array(Type.String({ title: "Tag" }), { title: "Tags", description: "The tags of the theme" }),
-    browserColorScheme: StringEnum(["light", "dark"], {
-      title: "Browser scheme",
-      description: "Color of browser-provided UI. Either 'light' or 'dark'",
-    }),
-    // Define the theme colors
-    colors: Type.Object(
-      {
-        primary: Type.String({
-          title: "Primary",
-          description: "The brand's primary color.",
-          "ai:instructions": "Use oklch() css notation.",
-          examples: ["oklch(0.62 0.241 354.308)"],
-        }),
-        secondary: Type.String({
-          title: "Secondary",
-          description: "The brand's second most used color",
-          "ai:instructions": "Use oklch() css notation.",
-          examples: ["oklch(0.65 0.22 185)"],
-        }),
-        accent: Type.String({
-          title: "Accent",
-          description: "The brand's least used color",
-          "ai:instructions": "Use oklch() css notation.",
-          examples: ["oklch(0.82 0.18 85)"],
-        }),
-        neutral: Type.String({
-          title: "Neutral",
-          description: "The base neutral color",
-          "ai:instructions": "Use oklch() css notation.",
-          examples: ["oklch(0.38 0.08 280)"],
-        }),
-        base100: Type.String({
-          title: "Base",
-          description:
-            "Base surface color of page, used for blank backgrounds. Should be white or near-white for light color-schemes, and black or near-black for dark color-schemes.",
-          "ai:instructions": "Use oklab() css notation.",
-          examples: ["oklch(0.99 0.008 92)"],
-        }),
-        base200: Type.String({
-          title: "Base 2",
-          description:
-            "Should be darker than base 100 but still light for light color-schemes, and lighter but still dark for dark color-schemes.",
-          "ai:instructions": "Use oklab() css notation.",
-          examples: ["oklch(0.97 0.01 85)"],
-        }),
-        base300: Type.String({
-          title: "Base 3",
-          description:
-            "3rd base color, should be darker than base 200 for light color-schemes, and lighter than base 200 for dark color-schemes.",
-          "ai:instructions": "Use oklab() css notation.",
-          examples: ["oklch(0.95 0.02 80)"],
-        }),
-      },
-      {
-        title: "Theme base colors",
-        description: "The base colors of the theme. Each theme must declare all these colors",
-        additionalProperties: false,
-      },
-    ),
+export const themeSchema = Type.Object({
+  id: Type.String({ title: "ID", description: "The unique identifier of the theme" }),
+  name: Type.String({ title: "Name", description: "The name of the theme" }),
+  description: Type.String({ title: "Description", description: "The description of the theme" }),
+  tags: Type.Array(Type.String({ title: "Tag" }), { title: "Tags", description: "The tags of the theme" }),
+  browserColorScheme: StringEnum(["light", "dark"], {
+    title: "Browser scheme",
+    description: "Color of browser-provided UI. Either 'light' or 'dark'",
+  }),
+  // Define the theme colors
+  colors: Type.Object(
+    {
+      primary: Type.String({
+        title: "Primary",
+        description: "The brand's primary color.",
+        "ai:instructions": "Use oklch() css notation.",
+        examples: ["oklch(0.62 0.241 354.308)"],
+      }),
+      secondary: Type.String({
+        title: "Secondary",
+        description: "The brand's second most used color",
+        "ai:instructions": "Use oklch() css notation.",
+        examples: ["oklch(0.65 0.22 185)"],
+      }),
+      accent: Type.String({
+        title: "Accent",
+        description: "The brand's least used color",
+        "ai:instructions": "Use oklch() css notation.",
+        examples: ["oklch(0.82 0.18 85)"],
+      }),
+      neutral: Type.String({
+        title: "Neutral",
+        description: "The base neutral color",
+        "ai:instructions": "Use oklch() css notation.",
+        examples: ["oklch(0.38 0.08 280)"],
+      }),
+      base100: Type.String({
+        title: "Base",
+        description:
+          "Base surface color of page, used for blank backgrounds. Should be white or near-white for light color-schemes, and black or near-black for dark color-schemes.",
+        "ai:instructions": "Use oklab() css notation.",
+        examples: ["oklch(0.99 0.008 92)"],
+      }),
+      base200: Type.String({
+        title: "Base 2",
+        description:
+          "Should be darker than base 100 but still light for light color-schemes, and lighter but still dark for dark color-schemes.",
+        "ai:instructions": "Use oklab() css notation.",
+        examples: ["oklch(0.97 0.01 85)"],
+      }),
+      base300: Type.String({
+        title: "Base 3",
+        description:
+          "3rd base color, should be darker than base 200 for light color-schemes, and lighter than base 200 for dark color-schemes.",
+        "ai:instructions": "Use oklab() css notation.",
+        examples: ["oklch(0.95 0.02 80)"],
+      }),
+    },
+    {
+      title: "Theme base colors",
+      description: "The base colors of the theme. Each theme must declare all these colors",
+    },
+  ),
 
-    // Define the theme typography
-    typography: Type.Object(
-      {
-        base: Type.Number({
-          title: "Base font size",
-          description: "The base font size in pixels. It is safe to keep it as is.",
-          "ai:instructions": "A safe value is 16.",
-        }),
-        heading: headingFont,
+  // Define the theme typography
+  typography: Type.Object({
+    base: Type.Number({
+      title: "Base font size",
+      description: "The base font size in pixels. It is safe to keep it as is.",
+      "ai:instructions": "A safe value is 16.",
+    }),
+    heading: headingFont,
+    body: bodyFont,
+    alternatives: Type.Array(
+      Type.Object({
         body: bodyFont,
-        alternatives: Type.Array(
-          Type.Object(
-            {
-              body: bodyFont,
-              heading: headingFont,
-            },
-            { additionalProperties: false },
-          ),
-          {
-            title: "Alternative fonts",
-            description: "Alternative fonts that can be suggested to the user. Takes the same shape",
-          },
-        ),
+        heading: headingFont,
+      }),
+      {
+        title: "Alternative fonts",
+        description: "Alternative fonts that can be suggested to the user. Takes the same shape",
       },
-      { additionalProperties: false },
     ),
-  },
-  {
-    additionalProperties: false,
-  },
-);
+  }),
+});
 
 export type Theme = Static<typeof themeSchema>;
 export const themesArray = Type.Array(themeSchema);
-export const themesArrayLLM = toLLMSchema(themesArray);
 
 export type ThemesArray = Static<typeof themesArray>;
 export type FontType = Theme["typography"]["body"];

package/src/shared/utils/llm.ts

@@ -1,7 +1,4 @@
-import type { TObject, TSchema } from "@sinclair/typebox";
-import { createAJVInstance } from "../ajv";
-import { cloneDeep } from "lodash-es";
-import { schemaRegistry } from "./schema-registry";
+import { Kind, type TObject, type TSchema } from "@sinclair/typebox";
 
 /**
  * Clean all properties from custom metadata recursively. Custom metadata are key that:
@@ -10,7 +7,7 @@ import { schemaRegistry } from "./schema-registry";
  * Also removes properties that have "ai:hidden" set to true
  */
 export function toLLMSchema<T extends TSchema = TObject>(schema: T): T {
-  return cleanSchemaRecursive(inlineSchemaRefs(schema)) as T;
+  return cleanSchemaRecursive(schema) as T;
 }
 
 /**
@@ -18,7 +15,9 @@ export function toLLMSchema<T extends TSchema = TObject>(schema: T): T {
  */
 function cleanSchemaRecursive(schema: TSchema): TSchema {
   // Create a new object without custom metadata properties
-  const cleaned: Record<string, unknown> = {};
+  const cleaned: Record<string, unknown> = {
+    [Kind]: schema[Kind],
+  };
 
   for (const [key, value] of Object.entries(schema)) {
     // Skip metadata properties and ui: properties
@@ -96,188 +95,3 @@ function isSchemaLike(obj: unknown): boolean {
   ];
   return schemaKeys.some((key) => key in obj);
 }
-
-interface SchemaWithDefs extends TSchema {
-  $defs?: Record<string, TSchema>;
-}
-
-/**
- * Inlines referenced schemas from AJV into the schema's $defs section
- * @param schema - The schema containing $ref references
- * @param ajv - The AJV instance containing the referenced schemas
- * @returns A new schema with references inlined in $defs
- */
-export function inlineSchemaRefs<T extends TSchema>(schema: T) {
-  //
-  const inlinedSchema = cloneDeep(schema) as T & SchemaWithDefs;
-  // const inlinedSchema = JSON.parse(JSON.stringify(schema)) as T & SchemaWithDefs;
-  const collectedRefs = new Set<string>();
-
-  // Initialize $defs if it doesn't exist
-  if (!inlinedSchema.$defs) {
-    inlinedSchema.$defs = {};
-  }
-
-  /**
-   * Recursively traverse the schema to find all $ref references
-   */
-  function collectRefs(obj: unknown): void {
-    if (typeof obj !== "object" || obj === null) return;
-
-    if (Array.isArray(obj)) {
-      obj.forEach(collectRefs);
-      return;
-    }
-
-    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
-      if (key === "$ref" && typeof value === "string") {
-        // Extract the schema ID from the reference
-        if (!value.startsWith("#/")) {
-          collectedRefs.add(value);
-        }
-      } else {
-        collectRefs(value);
-      }
-    }
-  }
-
-  /**
-   * Convert external $ref to local $defs reference
-   */
-  function convertRefsToLocal(obj: unknown, refMap: Map<string, string>): unknown {
-    if (typeof obj !== "object" || obj === null) return obj;
-
-    if (Array.isArray(obj)) {
-      return obj.map((item) => convertRefsToLocal(item, refMap));
-    }
-
-    const result: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
-      if (key === "$ref" && typeof value === "string") {
-        const localRef = refMap.get(value);
-        result[key] = localRef || value;
-      } else {
-        result[key] = convertRefsToLocal(value, refMap);
-      }
-    }
-    return result;
-  }
-
-  // Collect all references in the schema
-  collectRefs(inlinedSchema);
-
-  // Map to track original ref -> local def reference
-  const refToLocalMap = new Map<string, string>();
-
-  // Process each collected reference
-  for (const refId of collectedRefs) {
-    // Get the schema from the registry
-    const referencedSchema = schemaRegistry.get(refId);
-
-    if (!referencedSchema) {
-      // console.error(`Schema with ID "${refId}" not found in schema registry`, { referencedSchema });
-      // throw new Error(`Schema with ID "${refId}" not found in schema registry`);
-      continue;
-    }
-
-    // Create a safe key for $defs (remove special characters, use last part of URI)
-    const defKey =
-      refId.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/^_+|_+$/g, "") ||
-      refId
-        .split("/")
-        .pop()
-        ?.replace(/[^a-zA-Z0-9_-]/g, "_") ||
-      `ref_${Object.keys(inlinedSchema.$defs!).length}`;
-
-    // Ensure unique key
-    let uniqueDefKey = defKey;
-    let counter = 1;
-    while (inlinedSchema.$defs![uniqueDefKey]) {
-      uniqueDefKey = `${defKey}_${counter}`;
-      counter++;
-    }
-
-    // Add to $defs
-    const { $id, ...schemaWithoutId } = referencedSchema;
-    inlinedSchema.$defs![uniqueDefKey] = schemaWithoutId;
-
-    // Map original reference to local reference
-    refToLocalMap.set(refId, `#/$defs/${uniqueDefKey}`);
-  }
-
-  // Convert all external references to local $defs references
-  const finalSchema = convertRefsToLocal(inlinedSchema, refToLocalMap) as T & SchemaWithDefs;
-
-  // Recursively inline references in the newly added $defs schemas
-  if (finalSchema.$defs) {
-    // Keep processing until no new references are found
-    let foundNewRefs = true;
-    while (foundNewRefs) {
-      foundNewRefs = false;
-      const newRefsFound = new Set<string>();
-
-      // Check each $defs schema for new references
-      for (const [defKey, defSchema] of Object.entries(finalSchema.$defs)) {
-        const defCollectedRefs = new Set<string>();
-
-        // Collect refs specifically for this schema
-        function collectDefsRefs(obj: unknown): void {
-          if (typeof obj !== "object" || obj === null) return;
-
-          if (Array.isArray(obj)) {
-            obj.forEach(collectDefsRefs);
-            return;
-          }
-
-          for (const [key, value] of Object.entries(obj as Record<string, unknown>)) {
-            if (key === "$ref" && typeof value === "string") {
-              const refId = value.startsWith("#/") ? value : value;
-              if (!refId.startsWith("#/")) {
-                defCollectedRefs.add(refId);
-              }
-            } else {
-              collectDefsRefs(value);
-            }
-          }
-        }
-
-        collectDefsRefs(defSchema);
-
-        // Process any new references found in this $defs schema
-        for (const refId of defCollectedRefs) {
-          if (!refToLocalMap.has(refId)) {
-            newRefsFound.add(refId);
-            foundNewRefs = true;
-          }
-        }
-      }
-
-      // Add all newly found references to $defs
-      for (const refId of newRefsFound) {
-        const referencedSchema = schemaRegistry.get(refId);
-        if (referencedSchema) {
-          const newDefKey =
-            refId.replace(/[^a-zA-Z0-9_-]/g, "_").replace(/^_+|_+$/g, "") ||
-            `ref_${Object.keys(finalSchema.$defs).length}`;
-
-          let uniqueNewDefKey = newDefKey;
-          let counter = 1;
-          while (finalSchema.$defs[uniqueNewDefKey]) {
-            uniqueNewDefKey = `${newDefKey}_${counter}`;
-            counter++;
-          }
-
-          finalSchema.$defs[uniqueNewDefKey] = referencedSchema;
-          refToLocalMap.set(refId, `#/$defs/${uniqueNewDefKey}`);
-        }
-      }
-    }
-
-    // Finally, update all $defs schemas with converted references
-    for (const [defKey, defSchema] of Object.entries(finalSchema.$defs)) {
-      finalSchema.$defs[defKey] = convertRefsToLocal(defSchema, refToLocalMap) as TSchema;
-    }
-  }
-
-  return finalSchema as T & { $defs: Record<string, TSchema> };
-}