@hasna/skills 0.1.27 → 0.1.30

package/skills/generate-env/src/runtime.ts

@@ -0,0 +1,30 @@
+import { appendFileSync, existsSync, mkdirSync } from "fs";
+import { randomUUID } from "crypto";
+import { join } from "path";
+
+export const SKILL_NAME = "generate-env";
+export const SESSION_ID = randomUUID().slice(0, 8);
+export const SKILLS_OUTPUT_DIR = process.env.SKILLS_OUTPUT_DIR || join(process.cwd(), ".skills");
+export const LOGS_DIR = join(SKILLS_OUTPUT_DIR, "logs", SKILL_NAME);
+export const SESSION_TIMESTAMP = new Date().toISOString().replace(/[:.]/g, "_").slice(0, 19);
+
+export function ensureDir(dir: string) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+
+export function log(message: string, level: "info" | "error" | "success" | "warn" = "info") {
+  ensureDir(LOGS_DIR);
+  const timestamp = new Date().toISOString();
+  const logFile = join(LOGS_DIR, `log_${SESSION_TIMESTAMP}_${SESSION_ID}.log`);
+  const logEntry = `[${timestamp}] [${level.toUpperCase()}] ${message}\n`;
+  appendFileSync(logFile, logEntry);
+
+  const prefix = level === "error" ? "❌" : level === "success" ? "✅" : level === "warn" ? "⚠️" : "ℹ️";
+  if (level === "error") {
+    console.error(`${prefix} ${message}`);
+  } else {
+    console.log(`${prefix} ${message}`);
+  }
+}

package/skills/generate-env/src/types.ts

@@ -0,0 +1,32 @@
+// ============================================================================
+
+export interface EnvVariable {
+  name: string;
+  category: string;
+  description: string;
+  example?: string;
+  defaultValue?: string;
+  required: boolean;
+  sensitive: boolean;
+  format?: string;
+  validation?: string;
+}
+
+export interface GenerateOptions {
+  dir: string;
+  include: string[];
+  exclude: string[];
+  output: string;
+  envs: string[];
+  prefix: string;
+  generateSecrets: boolean;
+  secretLength: number;
+  withTypes: boolean;
+  withValidation: boolean;
+  templateOnly: boolean;
+  categories: string[];
+  autoCategorize: boolean;
+  format: 'inline' | 'block' | 'minimal';
+  includeExamples: boolean;
+  securityWarnings: boolean;
+}

package/skills/generate-favicon/package.json

@@ -11,7 +11,9 @@
     "build": "bun build src/index.ts --outdir dist --target node",
     "typecheck": "tsc --noEmit"
   },
-  "dependencies": {},
+  "dependencies": {
+    "sharp": "^0.33.5"
+  },
   "devDependencies": {
     "@types/bun": "latest",
     "typescript": "^5.7.0"

package/skills/generate-mock-data/package.json

@@ -11,7 +11,9 @@
     "build": "bun build src/index.ts --outdir dist --target node",
     "typecheck": "tsc --noEmit"
   },
-  "dependencies": {},
+  "dependencies": {
+    "openai": "^4.77.0"
+  },
   "devDependencies": {
     "@types/bun": "latest",
     "typescript": "^5.7.0"

package/skills/generate-mock-data/src/ai.ts

@@ -0,0 +1,102 @@
+import OpenAI from "openai";
+
+import { log } from "./logger";
+import type { Locale, SchemaField } from "./types";
+
+export async function generateDataAI(
+  schema: SchemaField,
+  count: number,
+  locale: Locale = "en-US"
+): Promise<any[]> {
+  const apiKey = process.env.OPENAI_API_KEY;
+  if (!apiKey) {
+    throw new Error("OPENAI_API_KEY environment variable is required for AI mode");
+  }
+
+  const openai = new OpenAI({ apiKey });
+
+  log(`Generating ${count} records using AI (GPT-4o-mini)...`);
+
+  const schemaDescription = Object.entries(schema)
+    .map(([field, type]) => `- ${field}: ${type}`)
+    .join("\n");
+
+  const prompt = `Generate ${count} realistic mock data records as a JSON array.
+
+Schema:
+${schemaDescription}
+
+Requirements:
+- Return ONLY a valid JSON array of objects
+- Each object must have all fields from the schema
+- Data should be realistic and diverse
+- Use ${locale} locale for localized data (names, addresses, phone numbers)
+- No explanations, just the JSON array
+
+Example format:
+[
+  { "field1": "value1", "field2": "value2" },
+  { "field1": "value3", "field2": "value4" }
+]`;
+
+  try {
+    // Split into batches if count > 50 to avoid token limits
+    const batchSize = Math.min(count, 50);
+    const batches = Math.ceil(count / batchSize);
+    const allData: any[] = [];
+
+    for (let batch = 0; batch < batches; batch++) {
+      const currentBatchSize = Math.min(batchSize, count - allData.length);
+
+      log(`Generating batch ${batch + 1}/${batches} (${currentBatchSize} records)...`);
+
+      const batchPrompt = prompt.replace(`Generate ${count}`, `Generate ${currentBatchSize}`);
+
+      const completion = await openai.chat.completions.create({
+        model: "gpt-4o-mini",
+        messages: [
+          {
+            role: "system",
+            content: "You are a data generator that returns only valid JSON arrays. No explanations, no markdown, just JSON.",
+          },
+          {
+            role: "user",
+            content: batchPrompt,
+          },
+        ],
+        temperature: 0.8,
+      });
+
+      const content = completion.choices[0].message.content || "[]";
+
+      // Clean up response (remove markdown code blocks if present)
+      const cleanContent = content
+        .replace(/```json\n?/g, "")
+        .replace(/```\n?/g, "")
+        .trim();
+
+      const batchData = JSON.parse(cleanContent);
+
+      if (!Array.isArray(batchData)) {
+        throw new Error("AI response is not a JSON array");
+      }
+
+      allData.push(...batchData);
+
+      // Log cost estimate
+      const inputTokens = completion.usage?.prompt_tokens || 0;
+      const outputTokens = completion.usage?.completion_tokens || 0;
+      const cost = (inputTokens * 0.00015 / 1000) + (outputTokens * 0.0006 / 1000);
+      log(`Batch ${batch + 1} cost: $${cost.toFixed(4)}`);
+    }
+
+    return allData.slice(0, count);
+  } catch (error) {
+    if (error instanceof Error) {
+      throw new Error(`AI generation failed: ${error.message}`);
+    }
+    throw error;
+  }
+}
+
+// Format data as JSON

package/skills/generate-mock-data/src/formatters.ts

@@ -0,0 +1,84 @@
+import { join } from "path";
+
+import { EXPORTS_DIR } from "./logger";
+import type { OutputFormat } from "./types";
+
+export function formatJSON(data: any[]): string {
+  return JSON.stringify(data, null, 2);
+}
+
+// Format data as CSV
+export function formatCSV(data: any[]): string {
+  if (data.length === 0) return "";
+
+  const headers = Object.keys(data[0]);
+  const rows = data.map(record =>
+    headers.map(header => {
+      const value = record[header];
+      // Escape quotes and wrap in quotes if contains comma or quote
+      if (typeof value === "string" && (value.includes(",") || value.includes('"') || value.includes("\n"))) {
+        return `"${value.replace(/"/g, '""')}"`;
+      }
+      return value;
+    }).join(",")
+  );
+
+  return [headers.join(","), ...rows].join("\n");
+}
+
+// Format data as SQL INSERT statements
+export function formatSQL(data: any[], tableName: string): string {
+  if (data.length === 0) return "";
+
+  const fields = Object.keys(data[0]);
+  const fieldList = fields.join(", ");
+
+  const values = data.map(record =>
+    `(${fields.map(field => {
+      const value = record[field];
+      if (value === null || value === undefined) {
+        return "NULL";
+      }
+      if (typeof value === "string") {
+        return `'${value.replace(/'/g, "''")}'`;
+      }
+      if (typeof value === "boolean") {
+        return value ? "TRUE" : "FALSE";
+      }
+      return value;
+    }).join(", ")})`
+  );
+
+  return `INSERT INTO ${tableName} (${fieldList}) VALUES\n${values.join(",\n")};`;
+}
+
+// Format data as TypeScript
+export function formatTypeScript(data: any[]): string {
+  if (data.length === 0) return "";
+
+  // Generate interface from first record
+  const sample = data[0];
+  const interfaceFields = Object.entries(sample)
+    .map(([key, value]) => {
+      let type: string = typeof value;
+      if (type === "object" && value === null) {
+        type = "any";
+      }
+      return `  ${key}: ${type};`;
+    })
+    .join("\n");
+
+  const interfaceCode = `interface MockData {\n${interfaceFields}\n}`;
+  const dataCode = `export const mockData: MockData[] = ${JSON.stringify(data, null, 2)};`;
+
+  return `${interfaceCode}\n\n${dataCode}`;
+}
+
+// Generate output filename
+export function generateOutputFilename(format: OutputFormat): string {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "_").replace(/-/g, "_").slice(0, 19).toLowerCase();
+  const extension = format === "typescript" ? "ts" : format;
+  return join(EXPORTS_DIR, `mock_data_${timestamp}.${extension}`);
+}
+
+// Main function

package/skills/generate-mock-data/src/generator.ts

@@ -0,0 +1,377 @@
+import { randomUUID } from "crypto";
+
+import type { Locale, SchemaField } from "./types";
+
+export class SeededRandom {
+  private seed: number;
+
+  constructor(seed: string) {
+    this.seed = this.hashCode(seed);
+  }
+
+  private hashCode(str: string): number {
+    let hash = 0;
+    for (let i = 0; i < str.length; i++) {
+      const char = str.charCodeAt(i);
+      hash = ((hash << 5) - hash) + char;
+      hash = hash & hash;
+    }
+    return Math.abs(hash);
+  }
+
+  next(): number {
+    this.seed = (this.seed * 9301 + 49297) % 233280;
+    return this.seed / 233280;
+  }
+
+  nextInt(min: number, max: number): number {
+    return Math.floor(this.next() * (max - min + 1)) + min;
+  }
+
+  choice<T>(array: T[]): T {
+    return array[this.nextInt(0, array.length - 1)];
+  }
+}
+
+// Built-in data generators
+export class DataGenerator {
+  private random: SeededRandom | null;
+  private locale: Locale;
+
+  constructor(seed?: string, locale: Locale = "en-US") {
+    this.random = seed ? new SeededRandom(seed) : null;
+    this.locale = locale;
+  }
+
+  private rand(): number {
+    return this.random ? this.random.next() : Math.random();
+  }
+
+  private randInt(min: number, max: number): number {
+    return this.random ? this.random.nextInt(min, max) : Math.floor(Math.random() * (max - min + 1)) + min;
+  }
+
+  private choice<T>(array: T[]): T {
+    return this.random ? this.random.choice(array) : array[Math.floor(Math.random() * array.length)];
+  }
+
+  // Locale-specific data
+  private getFirstNames(): string[] {
+    const names: Record<string, string[]> = {
+      "en-US": ["James", "John", "Robert", "Michael", "William", "David", "Richard", "Joseph", "Thomas", "Christopher", "Mary", "Patricia", "Jennifer", "Linda", "Elizabeth", "Barbara", "Susan", "Jessica", "Sarah", "Karen"],
+      "de-DE": ["Lukas", "Leon", "Tim", "Paul", "Felix", "Jonas", "Maximilian", "Luis", "Ben", "Noah", "Emma", "Mia", "Hannah", "Sofia", "Anna", "Lena", "Lea", "Marie", "Lina", "Emily"],
+      "ja-JP": ["Haruto", "Sota", "Yuto", "Yuki", "Kaito", "Takumi", "Riku", "Sora", "Hinata", "Yui", "Hina", "Sakura", "Yuna", "Aoi", "Miyu", "Rin", "Mei", "Mio", "Nanami", "Riko"],
+      "fr-FR": ["Gabriel", "Louis", "Raphael", "Arthur", "Lucas", "Jules", "Adam", "Hugo", "Nathan", "Tom", "Emma", "Louise", "Alice", "Chloe", "Lea", "Manon", "Rose", "Jade", "Clara", "Anna"],
+      "es-ES": ["Lucas", "Hugo", "Martin", "Mateo", "Leo", "Daniel", "Alejandro", "Pablo", "Manuel", "Adrian", "Lucia", "Maria", "Sofia", "Julia", "Paula", "Emma", "Martina", "Valeria", "Olivia", "Sara"],
+    };
+    return names[this.locale] || names["en-US"];
+  }
+
+  private getLastNames(): string[] {
+    const names: Record<string, string[]> = {
+      "en-US": ["Smith", "Johnson", "Williams", "Brown", "Jones", "Garcia", "Miller", "Davis", "Rodriguez", "Martinez", "Hernandez", "Lopez", "Gonzalez", "Wilson", "Anderson", "Thomas", "Taylor", "Moore", "Jackson", "Martin"],
+      "de-DE": ["Müller", "Schmidt", "Schneider", "Fischer", "Weber", "Meyer", "Wagner", "Becker", "Schulz", "Hoffmann", "Schäfer", "Koch", "Bauer", "Richter", "Klein", "Wolf", "Schröder", "Neumann", "Schwarz", "Zimmermann"],
+      "ja-JP": ["Sato", "Suzuki", "Takahashi", "Tanaka", "Watanabe", "Ito", "Yamamoto", "Nakamura", "Kobayashi", "Kato", "Yoshida", "Yamada", "Sasaki", "Yamaguchi", "Saito", "Matsumoto", "Inoue", "Kimura", "Hayashi", "Shimizu"],
+      "fr-FR": ["Martin", "Bernard", "Dubois", "Thomas", "Robert", "Richard", "Petit", "Durand", "Leroy", "Moreau", "Simon", "Laurent", "Lefebvre", "Michel", "Garcia", "David", "Bertrand", "Roux", "Vincent", "Fournier"],
+      "es-ES": ["García", "Rodríguez", "González", "Fernández", "López", "Martínez", "Sánchez", "Pérez", "Gómez", "Martín", "Jiménez", "Ruiz", "Hernández", "Díaz", "Moreno", "Muñoz", "Álvarez", "Romero", "Alonso", "Gutiérrez"],
+    };
+    return names[this.locale] || names["en-US"];
+  }
+
+  private getCities(): string[] {
+    const cities: Record<string, string[]> = {
+      "en-US": ["New York", "Los Angeles", "Chicago", "Houston", "Phoenix", "Philadelphia", "San Antonio", "San Diego", "Dallas", "San Jose"],
+      "de-DE": ["Berlin", "Hamburg", "München", "Köln", "Frankfurt", "Stuttgart", "Düsseldorf", "Dortmund", "Essen", "Leipzig"],
+      "ja-JP": ["Tokyo", "Osaka", "Nagoya", "Sapporo", "Fukuoka", "Kobe", "Kyoto", "Yokohama", "Kawasaki", "Saitama"],
+      "fr-FR": ["Paris", "Marseille", "Lyon", "Toulouse", "Nice", "Nantes", "Strasbourg", "Montpellier", "Bordeaux", "Lille"],
+      "es-ES": ["Madrid", "Barcelona", "Valencia", "Sevilla", "Zaragoza", "Málaga", "Murcia", "Palma", "Las Palmas", "Bilbao"],
+    };
+    return cities[this.locale] || cities["en-US"];
+  }
+
+  private getCountries(): string[] {
+    const countries: Record<string, string[]> = {
+      "en-US": ["United States", "Canada", "United Kingdom", "Australia", "New Zealand"],
+      "de-DE": ["Deutschland", "Österreich", "Schweiz", "Luxemburg", "Belgien"],
+      "ja-JP": ["日本", "アメリカ", "中国", "韓国", "オーストラリア"],
+      "fr-FR": ["France", "Belgique", "Suisse", "Canada", "Luxembourg"],
+      "es-ES": ["España", "México", "Argentina", "Colombia", "Chile"],
+    };
+    return countries[this.locale] || countries["en-US"];
+  }
+
+  uuid(): string {
+    return randomUUID();
+  }
+
+  string(length: number = 10): string {
+    const chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
+    let result = "";
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(this.randInt(0, chars.length - 1));
+    }
+    return result;
+  }
+
+  number(min: number = 0, max: number = 1000): number {
+    return this.randInt(min, max);
+  }
+
+  boolean(): boolean {
+    return this.rand() > 0.5;
+  }
+
+  email(firstName?: string, lastName?: string): string {
+    const first = firstName || this.firstName();
+    const last = lastName || this.lastName();
+    const domains = ["gmail.com", "yahoo.com", "outlook.com", "hotmail.com", "example.com"];
+    return `${first.toLowerCase()}.${last.toLowerCase()}@${this.choice(domains)}`;
+  }
+
+  phone(): string {
+    const formats: Record<string, () => string> = {
+      "en-US": () => `+1-${this.randInt(200, 999)}-${this.randInt(200, 999)}-${this.randInt(1000, 9999)}`,
+      "de-DE": () => `+49-${this.randInt(30, 89)}-${this.randInt(10000000, 99999999)}`,
+      "ja-JP": () => `+81-${this.randInt(3, 9)}-${this.randInt(1000, 9999)}-${this.randInt(1000, 9999)}`,
+      "fr-FR": () => `+33-${this.randInt(1, 9)}-${this.randInt(10, 99)}-${this.randInt(10, 99)}-${this.randInt(10, 99)}-${this.randInt(10, 99)}`,
+      "es-ES": () => `+34-${this.randInt(600, 799)}-${this.randInt(100, 999)}-${this.randInt(100, 999)}`,
+    };
+    const format = formats[this.locale] || formats["en-US"];
+    return format();
+  }
+
+  url(): string {
+    const protocols = ["https://"];
+    const domains = ["example.com", "test.com", "demo.com", "sample.org", "mock.io"];
+    return `${this.choice(protocols)}${this.choice(domains)}`;
+  }
+
+  date(): string {
+    const start = new Date(2020, 0, 1).getTime();
+    const end = new Date().getTime();
+    const randomTime = start + this.rand() * (end - start);
+    return new Date(randomTime).toISOString();
+  }
+
+  firstName(): string {
+    return this.choice(this.getFirstNames());
+  }
+
+  lastName(): string {
+    return this.choice(this.getLastNames());
+  }
+
+  name(): string {
+    return `${this.firstName()} ${this.lastName()}`;
+  }
+
+  username(): string {
+    return `${this.firstName().toLowerCase()}${this.randInt(100, 9999)}`;
+  }
+
+  address(): string {
+    return `${this.randInt(1, 9999)} ${this.choice(["Main", "Oak", "Pine", "Maple", "Cedar", "Elm", "Park", "Washington"])} ${this.choice(["St", "Ave", "Rd", "Blvd", "Dr", "Ln", "Way"])}`;
+  }
+
+  city(): string {
+    return this.choice(this.getCities());
+  }
+
+  state(): string {
+    const states = ["CA", "TX", "FL", "NY", "PA", "IL", "OH", "GA", "NC", "MI"];
+    return this.choice(states);
+  }
+
+  zipCode(): string {
+    return this.randInt(10000, 99999).toString();
+  }
+
+  country(): string {
+    return this.choice(this.getCountries());
+  }
+
+  company(): string {
+    const prefixes = ["Tech", "Global", "Digital", "Smart", "Dynamic", "Advanced", "Premier"];
+    const suffixes = ["Solutions", "Systems", "Corp", "Industries", "Group", "Enterprises", "Technologies"];
+    return `${this.choice(prefixes)} ${this.choice(suffixes)}`;
+  }
+
+  price(): string {
+    return (this.randInt(100, 999999) / 100).toFixed(2);
+  }
+
+  paragraph(): string {
+    const words = ["lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing", "elit", "sed", "do", "eiusmod", "tempor", "incididunt", "ut", "labore", "et", "dolore", "magna", "aliqua"];
+    const length = this.randInt(20, 50);
+    let paragraph = "";
+    for (let i = 0; i < length; i++) {
+      paragraph += this.choice(words) + " ";
+    }
+    return paragraph.trim().charAt(0).toUpperCase() + paragraph.trim().slice(1) + ".";
+  }
+
+  sentence(): string {
+    const words = ["lorem", "ipsum", "dolor", "sit", "amet", "consectetur", "adipiscing", "elit"];
+    const length = this.randInt(5, 12);
+    let sentence = "";
+    for (let i = 0; i < length; i++) {
+      sentence += this.choice(words) + " ";
+    }
+    return sentence.trim().charAt(0).toUpperCase() + sentence.trim().slice(1) + ".";
+  }
+
+  productName(): string {
+    const adjectives = ["Premium", "Deluxe", "Professional", "Advanced", "Ultimate", "Essential", "Classic"];
+    const products = ["Laptop", "Phone", "Tablet", "Monitor", "Keyboard", "Mouse", "Headphones", "Speaker", "Camera", "Watch"];
+    return `${this.choice(adjectives)} ${this.choice(products)}`;
+  }
+
+  category(): string {
+    return this.choice(["Electronics", "Clothing", "Food", "Books", "Sports", "Home", "Garden", "Toys", "Automotive", "Health"]);
+  }
+
+  sku(): string {
+    return `SKU-${this.randInt(10000, 99999)}`;
+  }
+
+  imageUrl(): string {
+    return `https://picsum.photos/seed/${this.randInt(1, 1000)}/800/600`;
+  }
+
+  avatarUrl(): string {
+    return `https://i.pravatar.cc/300?u=${this.randInt(1, 10000)}`;
+  }
+
+  rating(): number {
+    return this.randInt(1, 5);
+  }
+
+  orderItems(): string {
+    const count = this.randInt(1, 5);
+    const items = [];
+    for (let i = 0; i < count; i++) {
+      items.push(`${this.productName()} (qty: ${this.randInt(1, 3)})`);
+    }
+    return items.join(", ");
+  }
+
+  orderStatus(): string {
+    return this.choice(["pending", "processing", "shipped", "delivered", "cancelled"]);
+  }
+
+  trackingNumber(): string {
+    return `TRK${this.randInt(100000000, 999999999)}`;
+  }
+
+  industry(): string {
+    return this.choice(["Technology", "Healthcare", "Finance", "Retail", "Manufacturing", "Education", "Entertainment", "Hospitality", "Transportation", "Energy"]);
+  }
+
+  year(): number {
+    return this.randInt(1990, 2024);
+  }
+
+  title(): string {
+    const words = ["How to", "The Best", "Top 10", "Guide to", "Understanding", "Introduction to", "Mastering", "Essential"];
+    const topics = ["Technology", "Business", "Marketing", "Design", "Programming", "Leadership", "Innovation", "Strategy"];
+    return `${this.choice(words)} ${this.choice(topics)}`;
+  }
+
+  tags(): string {
+    const allTags = ["technology", "business", "marketing", "design", "development", "productivity", "innovation", "strategy", "leadership", "education"];
+    const count = this.randInt(2, 5);
+    const selected = [];
+    for (let i = 0; i < count; i++) {
+      selected.push(this.choice(allTags));
+    }
+    return selected.join(", ");
+  }
+
+  eventStatus(): string {
+    return this.choice(["upcoming", "ongoing", "completed", "cancelled"]);
+  }
+
+  currency(): string {
+    return this.choice(["USD", "EUR", "GBP", "JPY", "CAD", "AUD"]);
+  }
+
+  transactionType(): string {
+    return this.choice(["debit", "credit", "transfer", "payment", "refund"]);
+  }
+
+  accountNumber(): string {
+    return `${this.randInt(1000, 9999)}-${this.randInt(1000, 9999)}-${this.randInt(1000, 9999)}`;
+  }
+
+  transactionStatus(): string {
+    return this.choice(["pending", "completed", "failed", "cancelled"]);
+  }
+
+  generateField(fieldType: string): any {
+    switch (fieldType) {
+      case "string": return this.string();
+      case "number": return this.number();
+      case "boolean": return this.boolean();
+      case "email": return this.email();
+      case "phone": return this.phone();
+      case "url": return this.url();
+      case "date": return this.date();
+      case "uuid": return this.uuid();
+      case "name": return this.name();
+      case "firstName": return this.firstName();
+      case "lastName": return this.lastName();
+      case "username": return this.username();
+      case "address": return this.address();
+      case "city": return this.city();
+      case "state": return this.state();
+      case "zipCode": return this.zipCode();
+      case "country": return this.country();
+      case "company": return this.company();
+      case "price": return this.price();
+      case "paragraph": return this.paragraph();
+      case "sentence": return this.sentence();
+      case "productName": return this.productName();
+      case "category": return this.category();
+      case "sku": return this.sku();
+      case "imageUrl": return this.imageUrl();
+      case "avatarUrl": return this.avatarUrl();
+      case "rating": return this.rating();
+      case "orderItems": return this.orderItems();
+      case "orderStatus": return this.orderStatus();
+      case "trackingNumber": return this.trackingNumber();
+      case "industry": return this.industry();
+      case "year": return this.year();
+      case "title": return this.title();
+      case "tags": return this.tags();
+      case "eventStatus": return this.eventStatus();
+      case "currency": return this.currency();
+      case "transactionType": return this.transactionType();
+      case "accountNumber": return this.accountNumber();
+      case "transactionStatus": return this.transactionStatus();
+      default: return this.string();
+    }
+  }
+}
+
+// Generate data using built-in generators
+export async function generateDataBuiltin(
+  schema: SchemaField,
+  count: number,
+  seed?: string,
+  locale: Locale = "en-US"
+): Promise<any[]> {
+  const generator = new DataGenerator(seed, locale);
+  const data = [];
+
+  for (let i = 0; i < count; i++) {
+    const record: any = {};
+    for (const [field, type] of Object.entries(schema)) {
+      record[field] = generator.generateField(type);
+    }
+    data.push(record);
+  }
+
+  return data;
+}
+
+// Generate data using AI (OpenAI GPT-4o-mini)