make-mp-data 2.0.19 → 2.0.22

package/lib/templates/instructions.txt

@@ -0,0 +1,78 @@
+You are an AI assistant that generates a structured JavaScript object ("Dungeon") that defines a synthetic analytics dataset designed to simulate realistic user behavior, based on a prompt describing a business or product use case.
+
+the spec you are building is a javascript object... the high level spec looks like this:
+
+--------------
+
+const my_dungeon = {
+	funnels: [],
+    events: [],
+    superProps: {},
+    userProps: {},
+    scdProps: {},
+    groupKeys: [],
+    groupProps: {},
+    lookupTables: [],
+};
+
+--------------
+
+
+here's the full typescript definition for each of the properties in the entire spec; we call the specs 'DUNGEONS' and each dungeon is a javascript object:
+
+--------------
+//types.d.ts
+
+<TYPES>
+
+--------------
+
+here is now an implementation of the dungeon spec which shows how these above features work together to create a data set that tells a story!
+
+Pay close attention to how function calls like weighNumRange(...) and chance.company() are written directly into the object without quotes. 
+
+Your output must follow this exact format:
+
+--------------
+
+//my-dungeon.js
+/** @type {import('../../types.js').Dungeon} */
+
+<VERBOSE_SCHEMA>
+
+--------------
+
+Final Instructions & Rules:
+
+Your job is to build a dungeon based on the analytics use case described in the prompt. Your only output will be a single, valid JavaScript object literal.
+
+Core Requirements:
+
+	1. Output Format: Your output must be a valid JavaScript object literal, NOT JSON. This is crucial. Your entire response should start with { and end with } and contain nothing else.
+
+	2. Mandatory Fields: You MUST create funnels, events, superProps, and userProps for every dungeon. They should be directly related to the analytics use cases stated in the prompt.
+
+	3. Optional Fields: You should include scdProps, groupKeys, groupProps, and lookupTables only if they are clearly relevant based on the use case prompt.
+		- Use groups if the prompt involves B2B, teams, companies, or organizations.
+		- Use SCD if user or group traits change over time (e.g., subscription tier).
+		- Use lookup tables if events reference external entities with their own attributes (e.g., product_id, video_id).
+		- Use funnel conditions when different user segments or cohorts should have different behavioral patterns (e.g., premium vs free users, students vs teachers, rider vs driver, doctor vs patient).
+
+	4. Available Functions: You have access to these built-in functions: date, weighNumRange, range, and the chance library.
+
+❌ Critical Rules to Follow:
+
+	- Do NOT wrap function calls in quotes.
+
+		Correct: amount: weighNumRange(5, 500)
+		Incorrect: amount: "weighNumRange(5, 500)"
+
+	- Do NOT output comments, explanations, or any text outside of the JavaScript object.
+
+	- Do NOT generate vague or placeholder values like "value1", "example", or "random_string".
+
+	- Do NOT leave required arrays empty (funnels, events, etc.).
+
+Your only task is to generate a single JavaScript object that follows this structure based on the user's request.
+=================
+

package/lib/templates/scratch-dungeon-template.js

@@ -0,0 +1,116 @@
+/**
+ * this file is NOT currently used
+ */
+
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc.js";
+dayjs.extend(utc);
+import "dotenv/config";
+import { weighNumRange, range, date, initChance, exhaust, choose, integer, decimal, odds } from "../utils/utils.js";
+const { NODE_ENV = "unknown" } = process.env;
+
+
+
+/**
+ * Dungeon template for AI-generated configurations
+ * This template provides the structure and standard configuration
+ * AI-generated content will be injected into the placeholders
+ */
+
+export function createDungeonTemplate({
+    seed = "ai-generated-seed",
+    numUsers = 1000,
+    numDays = 100,
+    events = [],
+    funnels = [],
+    superProps = {},
+    userProps = {},
+    scdProps = {},
+    mirrorProps = {},
+    groupKeys = [],
+    groupProps = {},
+    lookupTables = [],
+    hookFunction = null
+}) {
+    const chance = u.initChance(seed);
+    const numEvents = numUsers * 100;
+
+    /** @typedef  {import("../../types.js").Dungeon} Config */
+
+    /** @type {Config} */
+    const config = {
+        token: "",
+        seed: seed,
+        numDays: numDays, 
+        numEvents: numEvents, 
+        numUsers: numUsers, 
+        hasAnonIds: false, 
+        hasSessionIds: false, 
+        format: "json",
+        alsoInferFunnels: true,
+        hasLocation: true,
+        hasAndroidDevices: true,
+        hasIOSDevices: true,
+        hasDesktopDevices: true,
+        hasBrowser: true,
+        hasCampaigns: true,
+        isAnonymous: false,
+        hasAdSpend: true,
+        
+        hasAvatar: true,
+        makeChart: false,
+
+        batchSize: 1_500_000,
+        concurrency: 1,
+        writeToDisk: false,
+        
+        // AI-generated content will be injected here
+        funnels: funnels,
+        events: events,
+        superProps: superProps,
+        userProps: userProps,
+        scdProps: scdProps,
+        mirrorProps: mirrorProps,
+        groupKeys: groupKeys,
+        groupProps: groupProps,
+        lookupTables: lookupTables,
+        
+        hook: hookFunction || function (record, type, meta) {
+            // const NOW = dayjs();
+
+			// CALLED AFTER EACH EVENT IS CREATED
+            if (type === "event") {
+                // const EVENT_TIME = dayjs(record.time);
+            }
+
+			// CALLED ONCE FOR EACH USER AND DEFINES THEIR PROPS
+            if (type === "user") {
+
+            }
+
+			// CALLED AFTER FUNNELS EVENTS ARE CHOSEN
+            if (type === "funnel-post") {
+                
+            }
+
+			// CALLED BEFORE FUNNELS EVENTS ARE CHOSEN
+            if (type === "funnel-pre") {
+
+            }
+
+			// CALLED BEFORE SCD EVENTS ARE CHOSEN
+            if (type === "scd-pre") {
+
+            }
+
+			// CALLED AT THE END WHEN A USERS ENTIRE HISTORY EXISTS
+            if (type === "everything") {
+            
+            }
+
+            return record;
+        }
+    };
+
+    return config;
+}

package/lib/templates/verbose-schema.js

@@ -0,0 +1,338 @@
+/**
+ * @fileoverview this is a highly verbose schema for a dungeon that shows all the options available
+ * and how they might be implemented with extensive comments so an AI can understand it
+ * it is not meant to be used as a template, but rather as a reference for how to create a dungeon
+ * it is also used as a test for the AI to see if it can generate a dungeon with the same structure
+ */
+
+
+
+import Chance from "chance";
+const chance = new Chance();
+import dayjs from "dayjs";
+import utc from "dayjs/plugin/utc.js";
+dayjs.extend(utc);
+import "dotenv/config";
+import { weighNumRange, range, date, initChance, exhaust, choose, integer, decimal, odds } from "../../lib/utils/utils.js";
+const { NODE_ENV = "unknown" } = process.env;
+
+
+/** @type {import("../../types.js").Dungeon} */
+//SPLIT HERE
+const DUNGEON = {
+
+	/**
+	 * events are the core building blocks of the dungeon
+	 * each event has a name, a weight, and properties
+	 * the weight determines how often the event occurs relative to other events
+	 * properties are the data associated with the event
+	 * they can be simple values or functions that return a value
+	 * we have a few built-in functions to help you generate data
+	 * you MUST create events for every dungeon
+	 */
+	events: [
+		{
+			event: "checkout",
+			weight: 2,
+			properties: {
+				amount: weighNumRange(5, 500, .25), // this is ok if you need to pick a number from a range; params are min, max, skew (opt), and size (size of pool, also opt)
+				currency: ["USD", "CAD", "EUR", "BTC", "ETH", "JPY"],
+				coupon: ["none", "none", "none", "none", "10%OFF", "20%OFF", "10%OFF", "20%OFF", "30%OFF", "40%OFF", "50%OFF"],
+				numItems: weighNumRange(1, 10),
+
+			}
+		},
+		{
+			event: "add to cart",
+			weight: 4,
+			properties: {
+				amount: weighNumRange(5, 500, .25),
+				rating: weighNumRange(1, 5),
+				reviews: weighNumRange(0, 35),
+				isFeaturedItem: [true, false, false],
+				itemCategory: ["Books", "Movies", "Music", "Games", "Electronics", "Computers", "Smart Home", "Home", "Garden", "Pet", "Beauty", "Health", "Toys", "Kids", "Baby", "Handmade", "Sports", "Outdoors", "Automotive", "Industrial", "Entertainment", "Art", "Food", "Appliances", "Office", "Wedding", "Software"],
+				dateItemListed: date(30, true, "YYYY-MM-DD") // this is ok if you need to pick a date from a range; params are intheLastDays, isPast, format
+			}
+		},
+		{
+			event: "page view",
+			weight: 10,
+			properties: {
+				page: ["/", "/", "/help", "/account", "/watch", "/listen", "/product", "/people", "/peace"],
+				utm_source: ["$organic", "$organic", "$organic", "$organic", "google", "google", "google", "facebook", "facebook", "twitter", "linkedin"],
+			}
+		},
+		{
+			event: "watch video",
+			weight: 8,
+			properties: {
+				videoCategory: ["funny", "educational", "inspirational", "music", "news", "sports", "cooking", "DIY", "travel", "gaming"],
+				isFeaturedItem: [true, false, false],
+				watchTimeSec: weighNumRange(10, 600, .25),
+				quality: ["2160p", "1440p", "1080p", "720p", "480p", "360p", "240p"],
+				format: ["mp4", "avi", "mov", "mpg"],
+				uploader_id: chance.guid.bind(chance), // You have access to the chance.js library for generating random data. You can assign a chance function directly to a property, like name: chance.company or uploader_id: chance.guid.
+				video_id: range(1, 1000) // SEE LOOKUP TABLES BELOW
+
+			}
+		},
+		{
+			event: "view item",
+			weight: 8,
+			properties: {
+				isFeaturedItem: [true, false, false],
+				itemCategory: ["Books", "Movies", "Music", "Games", "Electronics", "Computers", "Smart Home", "Home", "Garden", "Pet", "Beauty", "Health", "Toys", "Kids", "Baby", "Handmade", "Sports", "Outdoors", "Automotive", "Industrial", "Entertainment", "Art", "Food", "Appliances", "Office", "Wedding", "Software"],
+				dateItemListed: date(30, true, "YYYY-MM-DD"),
+				product_id: range(1, 1000) // SEE LOOKUP TABLES BELOW
+			}
+		},
+		{
+			event: "save item",
+			weight: 5,
+			properties: {
+				isFeaturedItem: [true, false, false],
+				itemCategory: ["Books", "Movies", "Music", "Games", "Electronics", "Computers", "Smart Home", "Home", "Garden", "Pet", "Beauty", "Health", "Toys", "Kids", "Baby", "Handmade", "Sports", "Outdoors", "Automotive", "Industrial", "Entertainment", "Art", "Food", "Appliances", "Office", "Wedding", "Software"],
+				dateItemListed: date(30, true, "YYYY-MM-DD"),
+			}
+		},
+		{
+			event: "sign up",
+			isFirstEvent: true,
+			weight: 0,
+			properties: {
+				variants: ["A", "B", "C", "Control"],
+				flows: ["new", "existing", "loyal", "churned"],
+				flags: ["on", "off"],
+				experiment_ids: ["1234", "5678", "9012", "3456", "7890"],
+				multiVariate: [true, false]
+			}
+		}
+	],
+	/**
+	 * superProps are properties that are attached to every event
+	 * they are selected randomly each time an event is generated
+	 * they can be simple values or functions that return a value
+	 * you will LIKELY create superProps for every dungeon
+	 */
+	superProps: {
+		theme: ["light", "dark", "custom", "light", "dark"],
+	},
+	/**
+	 * user properties work the same as event properties during the generation phase
+	 * except each user has a single set of user properties
+	 * these are properties that are attached to the user profile
+	 * they can be simple values or functions that return a value
+	 * you MUST create userProps for every dungeon
+	 */
+	userProps: {
+		title: ["Mr.", "Ms.", "Mrs.", "Dr.", "Prof.", "Sir", "Madam", "Lord", "Lady", "Dame", "Baron", "Baroness", "Count", "Countess", "Viscount", "Viscountess", "Marquis", "Marchioness"],
+		role: ["basic", "basic", "basic", "premium", "admin"], // role property that can be used in funnel conditions
+		luckyNumber: weighNumRange(42, 420, .3),
+		spiritAnimal: ["duck", "dog", "otter", "penguin", "cat", "elephant", "lion", "cheetah", "giraffe", "zebra", "rhino", "hippo", "whale", "dolphin", "shark", "octopus", "squid", "jellyfish", "starfish", "seahorse", "crab", "lobster", "shrimp", "clam", "snail", "slug", "butterfly", "moth", "bee", "wasp", "ant", "beetle", "ladybug", "caterpillar", "centipede", "millipede", "scorpion", "spider", "tarantula", "tick", "mite", "mosquito", "fly", "dragonfly", "damselfly", "grasshopper", "cricket", "locust", "mantis", "cockroach", "termite", "praying mantis", "walking stick", "stick bug", "leaf insect", "lacewing", "aphid", "cicada", "thrips", "psyllid", "scale insect", "whitefly", "mealybug", "planthopper", "leafhopper", "treehopper", "flea", "louse", "bedbug", "flea beetle", "weevil", "longhorn beetle", "leaf beetle", "tiger beetle", "ground beetle", "lady beetle", "firefly", "click beetle", "rove beetle", "scarab beetle", "dung beetle", "stag beetle", "rhinoceus beetle", "hercules beetle", "goliath beetle", "jewel beetle", "tortoise beetle"]
+	},
+	/**
+	 * Funnels represent intentional user journeys (e.g., sign-up, checkout), 
+	 * composed of a sequence of events. 
+	 * You should design at least one first-time funnel (e.g., onboarding) 
+	 * and one recurring funnel (e.g., purchases or content browsing) 
+	 * unless otherwise specified in the prompt.
+	 * Funnels are the primary mechanism used to generate the example data, and it's critical sequences match events in the events array.
+	 * there are many different options for the funnels like: 
+	 * 	isFirstFunnel, conversionRate, isChurnFunnel, order, props, requireRepeats, timeToConvert, weight, conditions
+	 * 
+	 * isFirstFunnel are funnels a user will only go through once (like a sign up)
+	 * non isFirstFunnel are funnels a user will go through multiple times (like a purchase)
+	 * 
+	 * conditions are used to filter which users are eligible for a specific funnel based on their user properties
+	 * this is useful when different user segments should have different behavioral patterns
+	 * for example: premium users might have access to advanced features, students vs teachers have different workflows
+	 *
+	 */
+	funnels: [
+		{
+			name: "sign up funnel",
+			description: "journey for users signing up",
+			sequence: ["page view", "page view", "sign up"],
+			isFirstFunnel: true,
+			conversionRate: 50, // 50% of users will convert		
+			order: "sequential", // events must occur in order
+			requireRepeats: false, // users can repeat events in the funnel
+			props: {}, // you can add properties to the funnel
+			timeToConvert: 1, // time to convert in hours	
+		},
+		{
+			name: "purchase funnel",
+			description: "how users purchase items",
+			sequence: ["page view", "view item", "add to cart", "checkout"],
+			isFirstFunnel: false,
+			conversionRate: 10,
+			timeToConvert: 24,
+			requireRepeats: true, // users can repeat events in the funnel
+			order: "first-and-last-fixed"
+		},
+		{
+			name: "browsing funnel",
+			description: "how users browse items",
+			sequence: ["page view", "view item", "watch video", "save item"],
+			isFirstFunnel: false,
+			conversionRate: 65,
+			timeToConvert: 2,
+			requireRepeats: true, // users can repeat events in the funnel
+			order: "random",
+			props: {
+				"browsing type": ["casual", "intentional", "exploratory"] // you can add properties to the funnel
+			}
+		},
+		{
+			name: "premium user workflow",
+			description: "advanced features only available to premium users",
+			sequence: ["page view", "view item", "save item", "checkout"],
+			isFirstFunnel: false,
+			conversionRate: 85,
+			timeToConvert: 3,
+			conditions: {
+				role: "premium" // only users with role "premium" are eligible for this funnel
+			},
+			order: "sequential",
+			props: {
+				"feature_tier": "premium"
+			}
+		}
+	],
+	/**
+	 * scdProps are used for to represent slowly changing dimensions (at both a user and group level)
+	 * these are properties that change over time, but not frequently
+	 * and importantly we care about behaviors (events) during different epochs of SCD state
+	 * you do NOT need to make SCD properties for every dungeon; only the ones with a use case for them
+	 */
+	scdProps: {
+		role: {
+			type: "user",
+			frequency: "week",
+			values: ["admin", "collaborator", "user", "view only", "no access"],
+			timing: "fuzzy",
+			max: 10
+		},
+		NPS: {
+			type: "user",
+			frequency: "day",
+			values: weighNumRange(1, 10, 2, 150),
+			timing: "fuzzy",
+			max: 10
+		},
+		MRR: {
+			type: "company_id",
+			frequency: "month",
+			values: weighNumRange(0, 10000, .15),
+			timing: "fixed",
+			max: 10
+		},
+		AccountHealthScore: {
+			type: "company_id",
+			frequency: "week",
+			values: weighNumRange(1, 10, .15),
+			timing: "fixed",
+			max: 40
+		},
+		plan: {
+			type: "company_id",
+			frequency: "month",
+			values: ["free", "basic", "premium", "enterprise"],
+			timing: "fixed",
+			max: 10
+		}
+	},
+
+
+	/**
+	 * groupKeys are used to represent entities for custom uniqueBy analysis
+	 * they are an array of arrays, where each inner array is a pair of group_key and the number of profiles for that key
+	 * this is useful for group analysis, where you want to analyze data by groups of users (by company, institution, school, etc...)
+	 * groups have props too (they can also have events) ... but there can be more than one "group entity"
+	 * you do NOT need to make groupKeys for every dungeon; only the ones with a use case for them
+	 */
+	groupKeys: [
+		["company_id", 500, []],
+		["room_id", 10000, ["save video", "comment", "watch video"]]
+	],
+	groupProps: {
+		company_id: {
+			name: () => { return chance.company(); }, // YOU CAN USE CHANCE IT"S BUILT IN!
+			email: () => { return `CSM: ${chance.pickone(["AK", "Jessica", "Michelle", "Dana", "Brian", "Dave"])}`; },
+			"# of employees": weighNumRange(3, 10000),
+			"industry": ["tech", "finance", "healthcare", "education", "government", "non-profit"],
+			"segment": ["enterprise", "SMB", "mid-market"],
+			"products": [["core"], ["core"], ["core", "add-ons"], ["core", "pro-serve"], ["core", "add-ons", "pro-serve"], ["core", "BAA", "enterprise"], ["free"], ["free"], ["free", "addons"]],
+		},
+		room_id: {
+			name: () => { return `#${chance.word({ length: integer(4, 24), capitalize: true })}`; },
+			email: ["public", "private"],
+			"room provider": ["partner", "core", "core", "core"],
+			"room capacity": weighNumRange(3, 1000000),
+			"isPublic": [true, false, false, false, false],
+			"country": chance.country.bind(chance),
+			"isVerified": [true, true, false, false, false],
+		}
+	},
+
+	/**
+	 * groupEvents are used to represent events that are associated with a group that occur
+	 * regularly (like a card charged, or a subscription renewed)
+	 * they are generally NOT attributed to a user, but rather to a group entity
+	 * you do NOT need to make groupEvents for every dungeon; only the ones with a use case for them
+	 */
+	groupEvents: [
+		{
+			attribute_to_user: false,
+			event: "card charged",
+			weight: 1,
+
+			frequency: 30,
+			group_key: "company_id",
+			group_size: 500,
+			properties: {
+				amount: weighNumRange(5, 500, .25),
+				currency: ["USD", "USD", "USD", "CAD", "EUR", "EUR", "BTC", "BTC", "ETH", "JPY"],
+				plan: ["basic", "premium", "enterprise"],
+				"payment method": []
+			}
+		}],
+
+	/**
+	 * lookupTables are used to represent static data that can be used in events
+	 * they are an array of objects, where each object is a key-value pair
+	 * this is useful for representing static data that can be used in events
+	 * like product information, user information, etc...
+	 * you do NOT need to make lookupTables for every dungeon; only the ones with a use case for them
+	 * if you DO make a lookupTable, you MUST provide a key in some events whose value will be numerical
+	 */
+	lookupTables: [{
+		key: "product_id",
+		entries: 1000,
+		attributes: {
+			category: [
+				"Books", "Movies", "Music", "Games", "Electronics", "Computers", "Smart Home", "Home", "Garden & Tools", "Pet Supplies", "Food & Grocery", "Beauty", "Health", "Toys", "Kids", "Baby", "Handmade", "Sports", "Outdoors", "Automotive", "Industrial", "Entertainment", "Art"
+			],
+			"demand": ["high", "medium", "medium", "low"],
+			"supply": ["high", "medium", "medium", "low"],
+			"manufacturer": chance.company.bind(chance),
+			"price": weighNumRange(5, 500, .25),
+			"rating": weighNumRange(1, 5),
+			"reviews": weighNumRange(0, 35)
+		}
+
+	},
+	{
+		key: "video_id",
+		entries: 50000,
+		attributes: {
+			isFlagged: [true, false, false, false, false],
+			copyright: ["all rights reserved", "creative commons", "creative commons", "public domain", "fair use"],
+			uploader_id: chance.guid.bind(chance),
+			"uploader influence": ["low", "low", "low", "medium", "medium", "high"],
+			thumbs: weighNumRange(0, 35),
+			rating: ["G", "PG", "PG-13", "R", "NC-17", "PG-13", "R", "NC-17", "R", "PG", "PG"]
+		}
+
+	}],
+};

package/lib/utils/ai.js

@@ -1,89 +1,67 @@
-import { GoogleGenerativeAI } from "@google/generative-ai";
-import * as u from "ak-tools";
 
-import 'dotenv/config';
+/** @typedef {import('../../types.js').Dungeon} Dungeon */
+/** @typedef {import('../../types.js').EventConfig} EventConfig */
 
+import * as u from "ak-tools";
+import 'dotenv/config';
 const { GEMINI_API_KEY: API_KEY, NODE_ENV = "unknown" } = process.env;
 if (!API_KEY) throw new Error("Please provide a Gemini API key");
+import AITransformer from 'ak-gemini';
 
-async function generateSchema(userInput) {
-	const gemini = new GoogleGenerativeAI(API_KEY);
-	const model = gemini.getGenerativeModel({ model: "gemini-2.0-flash" });
-	const PROOMPTY = await u.load("./components/prompt.txt");
-	const prompt = `
-Given the following information about a website or app:
-
-${userInput}
-
-${PROOMPTY}
+let CURRENT_PROMPT = ``;
+CURRENT_PROMPT = `build me a dungeon stream with these events and structure
 
-REMEMBER, YOUR INPUT IS:
+{ "event": "impression", "carousel": [{"product": "big mac"}] }
+{ "event": "viewed", "product_viewed": "big mac" }
+{ "event": "add to basket", "product_added": "big mac" }
+{ "event": "customized", "product_customized": "big mac" }
+{ "event": "checked out", "cart": [{"item": "big mac"}] }
 
-${userInput}
-`.trim();
 
-	let schema;
-	let schemaIsValid = false;
-	let attempts = 0;
-	do {
-		attempts++;
-		const result = await model.generateContent(prompt);
-		const response = await result.response;
-		const text = response.text();
-		schema = processResponse(text);
-		schemaIsValid = validator(schema);
-	} while (!schemaIsValid);
+but use all the different mcdonalds products as a possible values`;
+CURRENT_PROMPT = ``;
 
-	return schema;
-}
-
-function processResponse(text) {
-	let json;
-	// check for ```json
-	const start = text.indexOf("```json");
-	const end = text.indexOf("```", start + 1);
-
-	if (start === -1 || end === -1) {
-		const start = text.indexOf("{");
-		const end = text.lastIndexOf("}");
-		json = text.slice(start, end + 1).trim();
-	}
 
-	json = text.slice(start + 7, end).trim();
 
-	try {
-		return JSON.parse(json);
-	}
-	catch (e) {
-		return null;
-	}
-
-
-}
+async function main(params) {
+	const { prompt } = params;
+	if (!prompt) throw new Error("Please provide a prompt");
+	let INSTRUCTIONS = await u.load('./lib/templates/instructions.txt', false);
+	const TYPES = await u.load('./lib/templates/abbreviated.d.ts', false);
+	const VERBOSE_SCHEMA_FILE = await u.load('./lib/templates/verbose-schema.js', false);
+	const VERBOSE_SCHEMA = VERBOSE_SCHEMA_FILE.split(`//SPLIT HERE`).pop()?.trim() || ``;
+	INSTRUCTIONS = INSTRUCTIONS
+		.replace(/<TYPES>/g, TYPES)
+		.replace(/<VERBOSE_SCHEMA>/g, VERBOSE_SCHEMA);
 
-function validator(schema) {
-	let valid = true;
+	const ai = new AITransformer({
+		apiKey: API_KEY,
+		onlyJSON: false,
+		systemInstructions: INSTRUCTIONS?.trim(),
+		modelName: "gemini-2.5-pro",
 
-	//null schema are always invalid
-	if (!schema) valid = false;
 
-	//must have 3 or more events
-	if (schema?.events?.length < 3) valid = false;
+	});
+	await ai.init();
+	const response = await ai.message(prompt);
 
-	//must have 2 or more superProps
-	if (Object.keys(schema.superProps).length < 2) valid = false;
+	// if (NODE_ENV === "dev") {
+	// 	debugger;
+	// }
 
-	//must have 2 or more userProps
-	if (Object.keys(schema.userProps).length < 2) valid = false;
+	return response;
 
-	return valid;
 }
 
 
-export { generateSchema };
+export default main;
 
 if (import.meta.url === `file://${process.argv[1]}`) {
-	generateSchema(`metube, a video streaming company like youutube, where users watch videos, search, like, comment, subscribe, share, create playlists, etc...`)
+	main(
+		{
+			prompt: CURRENT_PROMPT || "Generate a dungeon spec for a simple e-commerce site with checkout and add to cart events."
+		}
+	)
 		.then((result) => {
 			if (NODE_ENV === "dev") debugger;
 		})

package/lib/utils/chart.js

@@ -1,3 +1,7 @@
+/** @typedef {import('../../types.js').EventSchema} EventSchema */
+/** @typedef {import('../../types.js').Result} Result */
+/** @typedef {import('../../types.js').Context} Context */
+
 import { ChartJSNodeCanvas } from 'chartjs-node-canvas';
 import fs from 'fs';
 import * as u from 'ak-tools';
@@ -179,6 +183,7 @@ async function generateLineChart(rawData, signupEvents = ["sign up"], fileName)
 	const imageBuffer = await chartJSNodeCanvas.renderToBuffer(configuration);
 	const filePath = path.join(tempDir, `${fileName}.png`);
 	const removed = await u.rm(filePath);
+	// @ts-ignore - imageBuffer is a Buffer but touch accepts it
 	const file = await u.touch(filePath, imageBuffer);
 
 	console.log(`Chart saved as ${fileName}.png`);