schemock 0.0.4-alpha.2 → 0.0.4-alpha.3

package/dist/cli/index.js

@@ -4272,6 +4272,307 @@ function generateEntityHooks(code, schema) {
   code.line();
 }
 
+// src/cli/generators/form-schemas.ts
+function generateFormSchemas(schemas) {
+  const code = new CodeBuilder();
+  code.line();
+  code.comment("=".repeat(70));
+  code.comment("FORM SCHEMAS - Zod validation, defaults, and column metadata");
+  code.comment("=".repeat(70));
+  code.line();
+  code.line("import { z } from 'zod';");
+  code.line();
+  for (const schema of schemas) {
+    if (schema.isJunctionTable) continue;
+    generateEntityFormSchemas(code, schema);
+  }
+  generateColumnTypes(code);
+  return code.toString();
+}
+function generateEntityFormSchemas(code, schema) {
+  const { pascalName, fields } = schema;
+  const formFields = fields.filter((f) => f.name !== "id" && !f.readOnly && !f.isComputed);
+  code.multiDocComment([
+    `Zod validation schema for ${pascalName} forms`,
+    "",
+    "Use with react-hook-form:",
+    "```typescript",
+    "import { useForm } from 'react-hook-form';",
+    "import { zodResolver } from '@hookform/resolvers/zod';",
+    "",
+    "const form = useForm({",
+    `  resolver: zodResolver(${pascalName}FormSchema),`,
+    `  defaultValues: ${pascalName}FormDefaults,`,
+    "});",
+    "```"
+  ]);
+  code.block(`export const ${pascalName}FormSchema = z.object({`, () => {
+    for (const field of formFields) {
+      const zodType = fieldToZodType(field);
+      code.line(`${field.name}: ${zodType},`);
+    }
+  }, "});");
+  code.line();
+  code.docComment(`Default values for ${pascalName} form initialization`);
+  code.block(`export const ${pascalName}FormDefaults: z.input<typeof ${pascalName}FormSchema> = {`, () => {
+    for (const field of formFields) {
+      const defaultValue = getFieldDefault(field);
+      code.line(`${field.name}: ${defaultValue},`);
+    }
+  }, "};");
+  code.line();
+  code.docComment(`Inferred type from ${pascalName}FormSchema`);
+  code.line(`export type ${pascalName}FormData = z.infer<typeof ${pascalName}FormSchema>;`);
+  code.line();
+  const tableFields = fields.filter((f) => !f.isComputed || f.name === "id");
+  code.docComment(`Table column definitions for ${pascalName}`);
+  code.block(`export const ${pascalName}TableColumns: ColumnDef[] = [`, () => {
+    for (const field of tableFields) {
+      const columnDef = fieldToColumnDef(field);
+      code.line(`${columnDef},`);
+    }
+  }, "];");
+  code.line();
+  const columnKeys = tableFields.map((f) => `'${f.name}'`).join(" | ");
+  code.docComment(`Valid column keys for ${pascalName} table`);
+  code.line(`export type ${pascalName}ColumnKey = ${columnKeys};`);
+  code.line();
+}
+function fieldToZodType(field) {
+  let zodType;
+  if (field.isEnum && field.enumValues && field.enumValues.length > 0) {
+    const enumLiterals = field.enumValues.map((v) => `'${v}'`).join(", ");
+    zodType = `z.enum([${enumLiterals}])`;
+  } else if (field.isArray && field.itemType) {
+    const itemZod = fieldToZodType(field.itemType);
+    zodType = `z.array(${itemZod})`;
+  } else if (field.isObject && field.shape) {
+    const shapeFields = Object.entries(field.shape).map(([key, f]) => `${key}: ${fieldToZodType(f)}`).join(", ");
+    zodType = `z.object({ ${shapeFields} })`;
+  } else if (field.isRef) {
+    zodType = "z.string().uuid()";
+  } else {
+    zodType = baseTypeToZod(field.type, field);
+  }
+  zodType = applyConstraints(zodType, field);
+  if (field.nullable) {
+    zodType = `${zodType}.nullable()`;
+  }
+  if (field.hasDefault) {
+    zodType = `${zodType}.optional()`;
+  }
+  return zodType;
+}
+function baseTypeToZod(type, field) {
+  const lowerType = type.toLowerCase();
+  if (["string", "text", "varchar", "char", "uuid", "citext"].includes(lowerType) || lowerType.startsWith("varchar")) {
+    if (lowerType === "uuid") {
+      return "z.string().uuid()";
+    }
+    return "z.string()";
+  }
+  if (lowerType === "email" || field.type.includes("email")) {
+    return "z.string().email()";
+  }
+  if (lowerType === "url" || field.type.includes("url")) {
+    return "z.string().url()";
+  }
+  if (["int", "integer", "smallint", "serial", "smallserial"].includes(lowerType)) {
+    return "z.number().int()";
+  }
+  if (["bigint", "bigserial"].includes(lowerType)) {
+    return "z.bigint()";
+  }
+  if (["float", "double", "real", "double precision"].includes(lowerType)) {
+    return "z.number()";
+  }
+  if (["decimal", "numeric", "money"].includes(lowerType)) {
+    return 'z.string().regex(/^-?\\d+(\\.\\d+)?$/, "Must be a valid decimal number")';
+  }
+  if (["boolean", "bool"].includes(lowerType)) {
+    return "z.boolean()";
+  }
+  if (["date", "datetime", "timestamp", "timestamptz"].includes(lowerType)) {
+    return "z.coerce.date()";
+  }
+  if (["time", "timetz", "interval"].includes(lowerType)) {
+    return "z.string()";
+  }
+  if (["json", "jsonb"].includes(lowerType)) {
+    return "z.unknown()";
+  }
+  switch (field.tsType) {
+    case "string":
+      return "z.string()";
+    case "number":
+      return "z.number()";
+    case "boolean":
+      return "z.boolean()";
+    case "Date":
+      return "z.coerce.date()";
+    case "bigint":
+      return "z.bigint()";
+    default:
+      return "z.unknown()";
+  }
+}
+function applyConstraints(zodType, field) {
+  const constraints = [];
+  if (field.tsType === "string" || field.type === "string" || field.type === "text") {
+    if (field.min !== void 0) {
+      constraints.push(`.min(${field.min})`);
+    }
+    if (field.max !== void 0) {
+      constraints.push(`.max(${field.max})`);
+    }
+    if (field.pattern) {
+      const escapedPattern = field.pattern.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+      constraints.push(`.regex(/${escapedPattern}/)`);
+    }
+  }
+  if (field.tsType === "number" || field.type === "number" || field.type === "int") {
+    if (field.min !== void 0) {
+      constraints.push(`.min(${field.min})`);
+    }
+    if (field.max !== void 0) {
+      constraints.push(`.max(${field.max})`);
+    }
+  }
+  if (!field.nullable && !field.hasDefault) {
+    if ((field.tsType === "string" || field.type === "string") && field.min === void 0 && !zodType.includes(".email()") && !zodType.includes(".url()") && !zodType.includes(".uuid()")) {
+      constraints.push(`.min(1, '${formatFieldName(field.name)} is required')`);
+    }
+  }
+  return zodType + constraints.join("");
+}
+function getFieldDefault(field) {
+  if (field.hasDefault && field.defaultValue !== void 0) {
+    return formatDefaultValue2(field.defaultValue);
+  }
+  if (field.isEnum && field.enumValues && field.enumValues.length > 0) {
+    return `'${field.enumValues[0]}'`;
+  }
+  if (field.isArray) {
+    return "[]";
+  }
+  if (field.isObject && field.shape) {
+    const shapeDefaults = Object.entries(field.shape).map(([key, f]) => `${key}: ${getFieldDefault(f)}`).join(", ");
+    return `{ ${shapeDefaults} }`;
+  }
+  if (field.isRef) {
+    return "''";
+  }
+  if (field.nullable) {
+    return "null";
+  }
+  switch (field.tsType) {
+    case "string":
+      return "''";
+    case "number":
+      return "0";
+    case "boolean":
+      return "false";
+    case "Date":
+      return "new Date()";
+    case "bigint":
+      return "BigInt(0)";
+    default:
+      return "undefined";
+  }
+}
+function formatDefaultValue2(value, field) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (typeof value === "string") {
+    return `'${value.replace(/'/g, "\\'")}'`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (typeof value === "bigint") {
+    return `BigInt(${value})`;
+  }
+  if (value instanceof Date) {
+    return `new Date('${value.toISOString()}')`;
+  }
+  if (Array.isArray(value)) {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "object") {
+    return JSON.stringify(value);
+  }
+  return "undefined";
+}
+function fieldToColumnDef(field) {
+  const parts = [];
+  parts.push(`key: '${field.name}'`);
+  parts.push(`label: '${formatFieldName(field.name)}'`);
+  const columnType = getColumnType(field);
+  parts.push(`type: '${columnType}'`);
+  const sortable = !field.isComputed && !field.isObject && !field.isArray;
+  parts.push(`sortable: ${sortable}`);
+  const filterable = !field.isComputed && !field.isObject;
+  parts.push(`filterable: ${filterable}`);
+  const hidden = field.name === "id" || field.name.endsWith("Id") || field.name === "createdAt" || field.name === "updatedAt";
+  if (hidden) {
+    parts.push(`hidden: true`);
+  }
+  return `{ ${parts.join(", ")} }`;
+}
+function getColumnType(field) {
+  if (field.isEnum) return "enum";
+  if (field.isArray) return "array";
+  if (field.isObject) return "object";
+  if (field.isRef) return "ref";
+  const lowerType = field.type.toLowerCase();
+  if (["boolean", "bool"].includes(lowerType)) return "boolean";
+  if (["date", "datetime", "timestamp", "timestamptz"].includes(lowerType)) return "date";
+  if (["time", "timetz"].includes(lowerType)) return "time";
+  if (["number", "int", "integer", "float", "double", "decimal", "numeric", "money", "bigint"].includes(
+    lowerType
+  ))
+    return "number";
+  if (field.tsType === "number") return "number";
+  if (lowerType === "email" || field.type.includes("email")) return "email";
+  if (lowerType === "url" || field.type.includes("url")) return "url";
+  if (lowerType === "uuid") return "id";
+  return "text";
+}
+function formatFieldName(name) {
+  return name.replace(/([A-Z])/g, " $1").replace(/^./, (str) => str.toUpperCase()).trim();
+}
+function generateColumnTypes(code) {
+  code.comment("=".repeat(70));
+  code.comment("COLUMN TYPES");
+  code.comment("=".repeat(70));
+  code.line();
+  code.docComment("Column type for table rendering and behavior");
+  code.line(
+    "export type ColumnType = 'text' | 'number' | 'boolean' | 'date' | 'time' | 'email' | 'url' | 'id' | 'enum' | 'ref' | 'array' | 'object';"
+  );
+  code.line();
+  code.docComment("Table column definition");
+  code.block("export interface ColumnDef {", () => {
+    code.line("/** Field key in the data object */");
+    code.line("key: string;");
+    code.line("/** Display label for column header */");
+    code.line("label: string;");
+    code.line("/** Column type for rendering and alignment */");
+    code.line("type: ColumnType;");
+    code.line("/** Whether column is sortable */");
+    code.line("sortable: boolean;");
+    code.line("/** Whether column is filterable */");
+    code.line("filterable: boolean;");
+    code.line("/** Whether column is hidden by default */");
+    code.line("hidden?: boolean;");
+    code.line("/** Custom width (CSS value) */");
+    code.line("width?: string;");
+    code.line("/** Custom render function name */");
+    code.line("render?: string;");
+  });
+  code.line();
+}
+
 // src/cli/generators/nextjs-api/route-template.ts
 function generateRouteFile(schema, target, _config) {
   const hasAuth = target.middleware?.auth !== void 0;
@@ -6298,10 +6599,14 @@ async function generate(options) {
   if (analyzedEndpoints.length > 0) {
     typesCode += generateEndpointTypes(analyzedEndpoints);
   }
+  if (options.withFormSchemas) {
+    typesCode += generateFormSchemas(analyzed);
+  }
   await writeOutput4(path.join(outputDir, "types.ts"), typesCode, options.dryRun);
   const entityCount = analyzed.filter((s) => !s.isJunctionTable).length;
   const endpointInfo = analyzedEndpoints.length > 0 ? ` + ${analyzedEndpoints.length} endpoint types` : "";
-  console.log(`   \u2713 types.ts (${entityCount} entities + Create/Update/Filter types${endpointInfo})
+  const formSchemaInfo = options.withFormSchemas ? " + form schemas" : "";
+  console.log(`   \u2713 types.ts (${entityCount} entities + Create/Update/Filter types${endpointInfo}${formSchemaInfo})
 `);
   console.log(`\u{1F50C} Generating ${adapter} adapter...`);
   switch (adapter) {
@@ -6446,6 +6751,319 @@ async function writeOutput4(path, content, dryRun) {
   await promises.writeFile(path, content, "utf-8");
 }
 
+// src/cli/generators/claude-md.ts
+var SECTION_START_MARKER = "<!-- SCHEMOCK:START - AI instructions for Schemock. Do not remove this marker -->";
+var SECTION_END_MARKER = "<!-- SCHEMOCK:END -->";
+function generateSchemockSection(config) {
+  const lines = [];
+  lines.push(SECTION_START_MARKER);
+  lines.push("");
+  lines.push("## Schemock - AI Instructions");
+  lines.push("");
+  lines.push("This project uses [Schemock](https://github.com/prajyot-tote/schemock) for schema-first code generation.");
+  lines.push("");
+  lines.push("### Generated Files - DO NOT MODIFY");
+  lines.push("");
+  lines.push("The following directories contain auto-generated code. **NEVER edit these files directly.**");
+  lines.push("Changes will be overwritten on next `npx schemock generate`.");
+  lines.push("");
+  const outputDirs = getOutputDirectories(config);
+  for (const dir of outputDirs) {
+    lines.push(`- \`${dir}/**/*\``);
+  }
+  lines.push("");
+  lines.push("### How to Make Changes");
+  lines.push("");
+  lines.push("To modify generated types, hooks, or clients:");
+  lines.push("");
+  lines.push(`1. **Edit schema files** in \`${config.schemas.replace("/**/*.ts", "/")}\``);
+  lines.push("2. **Run generation**: `npx schemock generate`");
+  lines.push("3. **Import from generated directory**");
+  lines.push("");
+  lines.push("### Schema DSL Quick Reference");
+  lines.push("");
+  lines.push("```typescript");
+  lines.push("import { defineData, field, hasMany, belongsTo } from 'schemock/schema';");
+  lines.push("");
+  lines.push("export const userSchema = defineData('user', {");
+  lines.push("  id: field.uuid(),");
+  lines.push("  email: field.email().unique(),");
+  lines.push("  name: field.string(),");
+  lines.push("  role: field.enum(['admin', 'user']).default('user'),");
+  lines.push("  avatar: field.url().nullable(),");
+  lines.push("  createdAt: field.timestamp().default(new Date()),");
+  lines.push("});");
+  lines.push("");
+  lines.push("export const postSchema = defineData('post', {");
+  lines.push("  id: field.uuid(),");
+  lines.push("  title: field.string(),");
+  lines.push("  content: field.text(),");
+  lines.push("  authorId: field.ref('user'),");
+  lines.push("}, {");
+  lines.push("  relations: {");
+  lines.push("    author: belongsTo('user', 'authorId'),");
+  lines.push("  },");
+  lines.push("});");
+  lines.push("```");
+  lines.push("");
+  lines.push("### Available Field Types");
+  lines.push("");
+  lines.push("| Type | Description | Example |");
+  lines.push("|------|-------------|---------|");
+  lines.push("| `field.uuid()` | UUID primary key | `id: field.uuid()` |");
+  lines.push("| `field.string()` | Text string | `name: field.string()` |");
+  lines.push("| `field.text()` | Long text | `content: field.text()` |");
+  lines.push("| `field.email()` | Email address | `email: field.email()` |");
+  lines.push("| `field.url()` | URL string | `avatar: field.url()` |");
+  lines.push("| `field.int()` | Integer number | `age: field.int()` |");
+  lines.push("| `field.float()` | Decimal number | `price: field.float()` |");
+  lines.push("| `field.boolean()` | True/false | `active: field.boolean()` |");
+  lines.push("| `field.enum([...])` | Enum values | `status: field.enum(['draft', 'published'])` |");
+  lines.push("| `field.timestamp()` | Date/time | `createdAt: field.timestamp()` |");
+  lines.push("| `field.date()` | Date only | `birthDate: field.date()` |");
+  lines.push("| `field.ref('entity')` | Foreign key | `authorId: field.ref('user')` |");
+  lines.push("| `field.json()` | JSON object | `metadata: field.json()` |");
+  lines.push("");
+  lines.push("### Field Modifiers");
+  lines.push("");
+  lines.push("- `.nullable()` - Field can be null");
+  lines.push("- `.default(value)` - Default value");
+  lines.push("- `.unique()` - Must be unique");
+  lines.push("- `.index()` - Create database index");
+  lines.push("");
+  lines.push("### Relations");
+  lines.push("");
+  lines.push("```typescript");
+  lines.push("import { hasMany, belongsTo, hasOne, manyToMany } from 'schemock/schema';");
+  lines.push("");
+  lines.push("// One-to-many: User has many Posts");
+  lines.push("hasMany('post', 'authorId')");
+  lines.push("");
+  lines.push("// Many-to-one: Post belongs to User");
+  lines.push("belongsTo('user', 'authorId')");
+  lines.push("");
+  lines.push("// One-to-one: User has one Profile");
+  lines.push("hasOne('profile', 'userId')");
+  lines.push("");
+  lines.push("// Many-to-many: Post has many Tags");
+  lines.push("manyToMany('tag', 'post_tags')");
+  lines.push("```");
+  lines.push("");
+  lines.push("### Common Tasks");
+  lines.push("");
+  lines.push("| Task | What to do |");
+  lines.push("|------|------------|");
+  lines.push("| Add new entity | Create new schema file in `src/schemas/`, run `npx schemock generate` |");
+  lines.push("| Add field | Edit schema file, run `npx schemock generate` |");
+  lines.push("| Add relation | Add to schema `relations` object, run `npx schemock generate` |");
+  lines.push("| Change field type | Edit schema file, run `npx schemock generate` |");
+  lines.push("| Fix generated code bug | Report issue, don't edit generated files |");
+  lines.push("");
+  lines.push("### CLI Commands");
+  lines.push("");
+  lines.push("```bash");
+  lines.push("# Generate all code from schemas");
+  lines.push("npx schemock generate");
+  lines.push("");
+  lines.push("# Generate for specific adapter");
+  lines.push("npx schemock generate --adapter supabase");
+  lines.push("");
+  lines.push("# Generate SQL migrations");
+  lines.push("npx schemock generate:sql");
+  lines.push("");
+  lines.push("# Dry run (show what would be generated)");
+  lines.push("npx schemock generate --dry-run");
+  lines.push("```");
+  lines.push("");
+  lines.push(SECTION_END_MARKER);
+  return lines.join("\n");
+}
+function getOutputDirectories(config) {
+  const dirs = /* @__PURE__ */ new Set();
+  if (config.output) {
+    dirs.add(normalizeOutputPath(config.output));
+  }
+  if (config.targets && config.targets.length > 0) {
+    for (const target of config.targets) {
+      dirs.add(normalizeOutputPath(target.output));
+    }
+  }
+  if (dirs.size === 0) {
+    dirs.add("./src/generated");
+  }
+  return Array.from(dirs).sort();
+}
+function normalizeOutputPath(path) {
+  if (!path.startsWith("./") && !path.startsWith("/")) {
+    return `./${path}`;
+  }
+  return path;
+}
+function mergeClaudeMdContent(existingContent, schemockSection) {
+  const startIndex = existingContent.indexOf(SECTION_START_MARKER);
+  const endIndex = existingContent.indexOf(SECTION_END_MARKER);
+  if (startIndex !== -1 && endIndex !== -1 && endIndex > startIndex) {
+    const before = existingContent.substring(0, startIndex);
+    const after = existingContent.substring(endIndex + SECTION_END_MARKER.length);
+    const oldSection = existingContent.substring(startIndex, endIndex + SECTION_END_MARKER.length);
+    if (oldSection === schemockSection) {
+      return { content: existingContent, wasUpdated: false };
+    }
+    return {
+      content: before + schemockSection + after,
+      wasUpdated: true
+    };
+  }
+  const separator = existingContent.trim() ? "\n\n" : "";
+  return {
+    content: existingContent.trim() + separator + schemockSection + "\n",
+    wasUpdated: true
+  };
+}
+function validateExistingContent(content) {
+  const warnings = [];
+  const startCount = (content.match(/SCHEMOCK:START/g) || []).length;
+  const endCount = (content.match(/SCHEMOCK:END/g) || []).length;
+  if (startCount !== endCount) {
+    warnings.push(
+      `Found mismatched Schemock markers (${startCount} START, ${endCount} END). Section will be appended instead of replaced.`
+    );
+  }
+  if (startCount > 1 || endCount > 1) {
+    warnings.push(
+      "Found multiple Schemock sections. Only the first will be replaced."
+    );
+  }
+  return {
+    isValid: warnings.length === 0,
+    warnings
+  };
+}
+function generateClaudeMd(config, existingContent = "") {
+  const warnings = [];
+  if (existingContent) {
+    const validation = validateExistingContent(existingContent);
+    warnings.push(...validation.warnings);
+  }
+  const schemockSection = generateSchemockSection(config);
+  const { content, wasUpdated } = mergeClaudeMdContent(existingContent, schemockSection);
+  return {
+    created: !existingContent,
+    modified: wasUpdated,
+    content,
+    path: "CLAUDE.md",
+    warnings
+  };
+}
+function generateCursorRules(config) {
+  const outputDirs = getOutputDirectories(config);
+  const lines = [];
+  lines.push("# Schemock Rules for Cursor");
+  lines.push("");
+  lines.push("## Generated Files - DO NOT MODIFY");
+  lines.push("");
+  lines.push("Never edit files in these directories:");
+  for (const dir of outputDirs) {
+    lines.push(`- ${dir}/**/*`);
+  }
+  lines.push("");
+  lines.push("To make changes, edit schema files and run: npx schemock generate");
+  lines.push("");
+  lines.push(`Schema files location: ${config.schemas}`);
+  lines.push("");
+  return lines.join("\n");
+}
+
+// src/cli/commands/setup-ai.ts
+async function setupAI(options = {}) {
+  console.log("\n\u{1F916} Schemock AI Setup\n");
+  const config = await loadConfig(options.config);
+  const outputDir = options.output || process.cwd();
+  const claudeMdPath = path.resolve(outputDir, "CLAUDE.md");
+  let existingContent = "";
+  if (fs.existsSync(claudeMdPath)) {
+    console.log("\u{1F4C4} Found existing CLAUDE.md");
+    existingContent = fs.readFileSync(claudeMdPath, "utf-8");
+  } else {
+    console.log("\u{1F4C4} No existing CLAUDE.md found - will create new file");
+  }
+  const claudeMdResult = generateClaudeMd(config, existingContent);
+  claudeMdResult.path = claudeMdPath;
+  if (claudeMdResult.warnings.length > 0) {
+    console.log("\n\u26A0\uFE0F  Warnings:");
+    for (const warning of claudeMdResult.warnings) {
+      console.log(`   ${warning}`);
+    }
+    console.log("");
+  }
+  if (options.dryRun) {
+    console.log("\n[DRY RUN] Would write CLAUDE.md:");
+    console.log("\u2500".repeat(60));
+    const sectionMatch = claudeMdResult.content.match(/<!-- SCHEMOCK:START[\s\S]*?SCHEMOCK:END -->/);
+    if (sectionMatch) {
+      console.log(sectionMatch[0]);
+    }
+    console.log("\u2500".repeat(60));
+  } else if (claudeMdResult.modified || claudeMdResult.created) {
+    fs.writeFileSync(claudeMdPath, claudeMdResult.content, "utf-8");
+    if (claudeMdResult.created) {
+      console.log(`   \u2713 Created ${claudeMdPath}`);
+    } else {
+      console.log(`   \u2713 Updated ${claudeMdPath} (Schemock section)`);
+    }
+  } else {
+    console.log("   \u2139 CLAUDE.md is already up to date");
+  }
+  let cursorResult;
+  if (options.cursor) {
+    const cursorPath = path.resolve(outputDir, ".cursorrules");
+    const cursorExists = fs.existsSync(cursorPath);
+    console.log("\n\u{1F4C4} Generating .cursorrules for Cursor IDE...");
+    const cursorContent = generateCursorRules(config);
+    if (options.dryRun) {
+      console.log("\n[DRY RUN] Would write .cursorrules:");
+      console.log("\u2500".repeat(60));
+      console.log(cursorContent);
+      console.log("\u2500".repeat(60));
+      cursorResult = { created: !cursorExists, modified: true, path: cursorPath };
+    } else {
+      let shouldWrite = true;
+      if (cursorExists && !options.force) {
+        const existingCursor = fs.readFileSync(cursorPath, "utf-8");
+        if (!existingCursor.includes("Schemock Rules for Cursor")) {
+          console.log("   \u26A0\uFE0F  Existing .cursorrules was not created by Schemock");
+          console.log("   Use --force to overwrite, or manually add Schemock rules");
+          shouldWrite = false;
+        } else if (existingCursor === cursorContent) {
+          console.log("   \u2139 .cursorrules is already up to date");
+          shouldWrite = false;
+        }
+      }
+      if (shouldWrite) {
+        fs.writeFileSync(cursorPath, cursorContent, "utf-8");
+        console.log(`   \u2713 ${cursorExists ? "Updated" : "Created"} ${cursorPath}`);
+      }
+      cursorResult = { created: !cursorExists, modified: shouldWrite, path: cursorPath };
+    }
+  }
+  console.log("\n\u2705 AI setup complete!\n");
+  console.log("What this does:");
+  console.log("  \u2022 CLAUDE.md tells Claude Code about your generated files");
+  console.log("  \u2022 Helps AI avoid modifying auto-generated code");
+  console.log("  \u2022 Provides schema DSL reference for AI assistance");
+  if (options.cursor) {
+    console.log("  \u2022 .cursorrules provides similar guidance for Cursor IDE");
+  }
+  console.log("\nNext steps:");
+  console.log("  1. Commit CLAUDE.md to your repository");
+  console.log("  2. Claude Code will now understand your Schemock project");
+  console.log("");
+  return {
+    claudeMd: claudeMdResult,
+    cursorRules: cursorResult
+  };
+}
+
 exports.CodeBuilder = CodeBuilder;
 exports.analyzeSchemas = analyzeSchemas;
 exports.defineConfig = defineConfig;
@@ -6453,20 +7071,26 @@ exports.discoverSchemas = discoverSchemas;
 exports.fieldToFakerCall = fieldToFakerCall;
 exports.fieldToTsType = fieldToTsType;
 exports.generate = generate;
+exports.generateClaudeMd = generateClaudeMd;
+exports.generateCursorRules = generateCursorRules;
 exports.generateFetchClient = generateFetchClient;
 exports.generateFirebaseClient = generateFirebaseClient;
+exports.generateFormSchemas = generateFormSchemas;
 exports.generateHooks = generateHooks;
 exports.generateMockClient = generateMockClient;
 exports.generateMockDb = generateMockDb;
 exports.generateMockHandlers = generateMockHandlers;
+exports.generateSchemockSection = generateSchemockSection;
 exports.generateSeed = generateSeed;
 exports.generateSupabaseClient = generateSupabaseClient;
 exports.generateTypes = generateTypes;
 exports.getDefaultConfig = getDefaultConfig;
 exports.getRelativePath = getRelativePath;
 exports.loadConfig = loadConfig;
+exports.mergeClaudeMdContent = mergeClaudeMdContent;
 exports.pluralize = pluralize;
 exports.primitiveToTs = primitiveToTs;
+exports.setupAI = setupAI;
 exports.toCamelCase = toCamelCase;
 exports.toPascalCase = toPascalCase;
 //# sourceMappingURL=index.js.map